From 9c3c7eea60641d02728815fb50e2bfe4a9f9dff0 Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Sun, 8 Nov 2026 02:44:30 +0100 Subject: [PATCH 01/11] perf(pr): actions, title edits and labels show at once on every host Close, reopen, ready, draft, and auto-merge on/off, title and body edits, and label changes now show in every loaded reader from the click. A host refusal takes the change back, and nothing guessed is saved. Merges wait for the host, because a merge queue can accept without merging. Created with Claude Opus 5.5 in Claude Code via T3 Code. --- .../src/state/pullRequests.test.ts | 478 ++++++++++++++++++ .../client-runtime/src/state/pullRequests.ts | 427 +++++++++++++--- 2 files changed, 827 insertions(+), 78 deletions(-) diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index f4571c44b03a7..088c94bab017d 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -2287,3 +2287,481 @@ it.effect("publishes the accepted guide run before the follow-up read finishes", }), ), ); + +const listResult = (entries: ReadonlyArray) => ({ + entries, + viewers: {}, + providers: [], + errors: [], + truncated: false, + nextCursors: {}, +}); + +it.effect.each([ + ["close", { state: "closed" }, "open"], + ["reopen", { state: "open" }, "closed"], + ["ready", { isDraft: false }, "open"], + ["draft", { isDraft: true }, "open"], + ["enable-auto-merge", { autoMergeEnabled: true }, "open"], + ["disable-auto-merge", { autoMergeEnabled: false }, "open"], +] as const)("shows %s in loaded readers before the host replies", ([action, shown, from]) => + Effect.scoped( + Effect.gen(function* () { + let reads = 0; + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const before = { + ...actionReference, + provider: "github", + title: "Ship it", + url: actionReply.url, + author: null, + headBranch: "feature", + baseBranch: "main", + state: from, + isDraft: action === "ready", + autoMergeEnabled: action === "disable-auto-merge", + createdAt: "2026-10-27T08:00:00Z", + updatedAt: "2026-10-27T09:00:00Z", + observedAt: 100, + }; + const read = () => + Effect.sync(() => { + reads++; + return before; + }); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: read, + [WS_METHODS.pullRequestsPreview]: read, + [WS_METHODS.pullRequestsSummary]: read, + [WS_METHODS.pullRequestsList]: () => + Effect.sync(() => { + reads++; + return listResult([before]); + }), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + return { ...before, ...shown, updatedAt: "2026-10-27T10:00:00Z", observedAt: 200 }; + }), + }); + const { atoms, registry, runtime } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const readers: ReadonlyArray>> = [ + atoms.detail(target), + atoms.preview(target), + createLinkedPullRequestSummaryAtomFamily(runtime, atoms.refreshes)(target), + ]; + const list = atoms.list({ environmentId: target.environmentId, input: { state: from } }); + for (const atom of [...readers, list]) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + reads = 0; + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { ...target, input: { ...actionReference, action } }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + + for (const atom of readers.slice(0, action.includes("auto-merge") ? 1 : readers.length)) { + expect(Option.getOrThrow(AsyncResult.value(registry.get(atom)))).toMatchObject(shown); + } + const rows = Option.getOrThrow(AsyncResult.value(registry.get(list))).entries; + if ("state" in shown) expect(rows).toEqual([]); + else if ("isDraft" in shown) expect(rows).toMatchObject([shown]); + else expect(rows).toHaveLength(1); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(acting); + expect(Option.getOrThrow(AsyncResult.value(registry.get(readers[0]!)))).toMatchObject({ + ...shown, + updatedAt: "2026-10-27T10:00:00Z", + }); + // Only a reopen re-reads, for the branch data and permissions its reply lacks. + expect(reads).toBe(action === "reopen" ? 1 : 0); + }), + ), +); + +it.effect("puts readers back when the host refuses an action, and saves nothing it guessed", () => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const open = { ...actionReference, state: "open", isDraft: false, observedAt: 100 }; + const saved = new Map(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => Effect.succeed(open), + [WS_METHODS.pullRequestsList]: () => Effect.succeed(listResult([open])), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + return yield* new PullRequestOperationError({ + operation: "runAction", + detail: "You cannot close this pull request.", + }); + }), + }); + const { atoms, registry } = yield* makeTestRuntime( + client, + undefined, + false, + {}, + { + load: (_environmentId, key) => Effect.sync(() => Option.fromUndefinedOr(saved.get(key))), + save: (_environmentId, key, payload) => Effect.sync(() => void saved.set(key, payload)), + }, + ); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + const list = atoms.list({ environmentId: target.environmentId, input: { state: "open" } }); + const loaded: ReadonlyArray>> = [ + detail, + list, + ]; + for (const atom of loaded) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "close" }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("closed"); + yield* Deferred.succeed(release, undefined); + expect((yield* Fiber.join(acting))._tag).toBe("Failure"); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("open"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toMatchObject([ + { state: "open" }, + ]); + expect([...saved.values()].some((payload) => payload.includes('"closed"'))).toBe(false); + }), + ), +); + +it.effect( + "keeps an accepted change on screen until the re-read when the reply has no summary", + () => + Effect.scoped( + Effect.gen(function* () { + let state = "open"; + let reads = 0; + const rereadStarted = yield* Deferred.make(); + const releaseReread = yield* Deferred.make(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => + Effect.gen(function* () { + reads++; + const answer = { ...actionReference, state, observedAt: reads }; + if (reads === 2) { + yield* Deferred.succeed(rereadStarted, undefined); + yield* Deferred.await(releaseReread); + } + return answer; + }), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.sync(() => { + state = "closed"; + return undefined; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + registry.mount(detail); + yield* Effect.promise(() => executeAtomQuery(registry, detail)); + + yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "close" }, + }), + ); + yield* Deferred.await(rereadStarted); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("closed"); + yield* Deferred.succeed(releaseReread, undefined); + expect( + (yield* AtomRegistry.getResult(registry, detail, { suspendOnWaiting: true })).observedAt, + ).toBe(2); + }), + ), +); + +it.effect("shows a queued close before the action ahead of it answers", () => + Effect.scoped( + Effect.gen(function* () { + const firstSent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const rows = [1, 2].map((number) => ({ + ...actionReference, + number, + state: "open", + isDraft: false, + updatedAt: `2026-10-27T0${number}:00:00Z`, + })); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsList]: () => Effect.succeed(listResult(rows)), + [WS_METHODS.pullRequestsRunAction]: (input: { readonly number: number }) => + Effect.gen(function* () { + if (input.number === 1) { + yield* Deferred.succeed(firstSent, undefined); + yield* Deferred.await(release); + } + return undefined; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const list = atoms.list({ environmentId: TARGET.environmentId, input: { state: "open" } }); + registry.mount(list); + yield* Effect.promise(() => executeAtomQuery(registry, list)); + + const closes = [1, 2].map((number) => + atoms.runAction.run(registry, { + environmentId: TARGET.environmentId, + input: { ...actionReference, number, action: "close" }, + }), + ); + yield* Deferred.await(firstSent); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toEqual([]); + yield* Deferred.succeed(release, undefined); + yield* Effect.promise(() => Promise.all(closes)); + }), + ), +); + +it.effect("leaves a merge as it is until the host says what it did", () => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => + Effect.succeed({ ...actionReference, state: "open", observedAt: 100 }), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + // A merge queue takes the merge and merges later. + return { ...actionReply, state: "open", autoMergeEnabled: true }; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + registry.mount(detail); + yield* Effect.promise(() => executeAtomQuery(registry, detail)); + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "merge" }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("open"); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(acting); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail)))).toMatchObject({ + state: "open", + autoMergeEnabled: true, + }); + }), + ), +); + +it.effect.each(["accepted", "refused"] as const)( + "shows a title edit at once and keeps it only when the host takes it (%s)", + (outcome) => + Effect.scoped( + Effect.gen(function* () { + let title = "Original"; + let reads = 0; + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const read = () => + Effect.sync(() => { + reads++; + return { ...actionReference, state: "open", title, observedAt: reads }; + }); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: read, + [WS_METHODS.pullRequestsPreview]: read, + [WS_METHODS.pullRequestsList]: () => + Effect.sync(() => { + reads++; + return listResult([ + { ...actionReference, state: "open", title, updatedAt: actionReply.updatedAt }, + ]); + }), + [WS_METHODS.pullRequestsUpdate]: (input: { readonly title: string }) => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + if (outcome === "refused") return yield* new MutationRefused(); + title = input.title; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + const preview = atoms.preview(target); + const list = atoms.list({ environmentId: target.environmentId, input: { state: "open" } }); + const loaded: ReadonlyArray>> = [ + detail, + preview, + list, + ]; + for (const atom of loaded) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + const titles = () => [ + Option.getOrThrow(AsyncResult.value(registry.get(detail))).title, + Option.getOrThrow(AsyncResult.value(registry.get(preview))).title, + Option.getOrThrow(AsyncResult.value(registry.get(list))).entries[0]?.title, + ]; + + const editing = yield* Effect.promise(() => + atoms.update.run(registry, { ...target, input: { ...actionReference, title: "Edited" } }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(titles()).toEqual(["Edited", "Edited", "Edited"]); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(editing); + + expect(titles()).toEqual( + outcome === "refused" + ? ["Original", "Original", "Original"] + : ["Edited", "Edited", "Edited"], + ); + // The edit is known, so no reader asks the host again. + expect(reads).toBe(3); + }), + ), +); + +it.effect("shows a label change at once and takes it back when the host refuses it", () => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const existing = { name: "existing", color: "111111" }; + const added = { name: "new", color: "abcdef" }; + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => + Effect.succeed({ ...actionReference, state: "open", labels: [existing] }), + [WS_METHODS.pullRequestsLabelCandidates]: () => + Effect.succeed({ + candidates: [ + { ...existing, description: null, isApplied: true }, + { ...added, description: null, isApplied: false }, + ], + truncated: false, + }), + [WS_METHODS.pullRequestsSetLabels]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + return yield* new MutationRefused(); + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + const candidates = atoms.labelCandidates(target); + const loaded: ReadonlyArray>> = [ + detail, + candidates, + ]; + for (const atom of loaded) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + + const labelling = yield* Effect.promise(() => + atoms.setLabels.run(registry, { + ...target, + input: { ...actionReference, labels: ["new"], applied: true }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual([ + existing, + added, + ]); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( + (candidate) => candidate.isApplied, + ), + ).toEqual([true, true]); + yield* Deferred.succeed(release, undefined); + expect((yield* Fiber.join(labelling))._tag).toBe("Failure"); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual([existing]); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( + (candidate) => candidate.isApplied, + ), + ).toEqual([true, false]); + }), + ), +); + +it.effect("keeps an accepted label change when a candidates read sent before it answers late", () => + Effect.scoped( + Effect.gen(function* () { + let applied = false; + let reads = 0; + const readStarted = yield* Deferred.make(); + const releaseRead = yield* Deferred.make(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsLabelCandidates]: () => + Effect.gen(function* () { + reads++; + const answer = { + candidates: [{ name: "new", color: null, description: null, isApplied: applied }], + truncated: false, + }; + if (reads === 2) { + yield* Deferred.succeed(readStarted, undefined); + yield* Deferred.await(releaseRead); + } + return answer; + }), + [WS_METHODS.pullRequestsSetLabels]: () => + Effect.sync(() => { + applied = true; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const candidates = atoms.labelCandidates(target); + registry.mount(candidates); + yield* Effect.promise(() => executeAtomQuery(registry, candidates)); + registry.refresh(candidates); + yield* Deferred.await(readStarted); + + yield* Effect.promise(() => + atoms.setLabels.run(registry, { + ...target, + input: { ...actionReference, labels: ["new"], applied: true }, + }), + ); + yield* Deferred.succeed(releaseRead, undefined); + + expect( + (yield* AtomRegistry.getResult(registry, candidates, { suspendOnWaiting: true })) + .candidates[0]?.isApplied, + ).toBe(true); + }), + ), +); diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index e0ded133128a6..22208487ec82b 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -16,11 +16,15 @@ import { type PullRequestListInput, type PullRequestListStatsInput, type PullRequestListStatsResult, + type PullRequestUpdateInput, type PullRequestDetail, type PullRequestDiffInput, type PullRequestListEntry, type PullRequestRef, type PullRequestMergeMethod, + type PullRequestLabel, + type PullRequestLabelCandidateList, + type PullRequestState, PullRequestOperationError, PullRequestSummary, type VcsStatusResult, @@ -34,6 +38,7 @@ import * as SubscriptionRef from "effect/SubscriptionRef"; import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity"; import { + type AtomCommand, createAtomCommandScheduler, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, @@ -119,10 +124,11 @@ function writableQueryFamily( /** Restart pre-mutation reads before patching so they cannot restore stale values. */ function updateCached( registry: AtomRegistry.AtomRegistry, - atom: Atom.Writable>, + shown: Atom.Writable>, update: (value: A) => A, refresh = false, ) { + const atom = (uneditedReaders.get(shown) ?? shown) as typeof shown; if (refresh || registry.get(atom).waiting) registry.refresh(atom); registry.update(atom, AsyncResult.map(update)); } @@ -142,6 +148,198 @@ interface ActionReplyPatch { // Module-wide so readers built by separate factories, such as linked summaries, are patched too. const actionReplyPatches = new WeakMap(); +/** What a write in flight will change, shown by every reader until the host answers. */ +interface PullRequestPendingEdit { + readonly reference: PullRequestRef; + readonly state?: PullRequestState; + readonly isDraft?: boolean; + readonly autoMergeEnabled?: boolean; + readonly title?: string; + readonly body?: string; + readonly labels?: { + readonly applied: boolean; + readonly labels: ReadonlyArray; + }; +} + +type EditedField = "state" | "isDraft" | "autoMergeEnabled" | "title" | "body"; + +interface EditableReader { + readonly environmentId: EnvironmentId; + readonly concerns: (reference: PullRequestRef) => boolean; + readonly edit: (value: never, edit: PullRequestPendingEdit) => unknown; +} + +// Module-wide like the reply patches, so separately built readers see the same writes. +const pendingEdits = Atom.family((_environmentId: EnvironmentId) => + Atom.make>([]).pipe(Atom.keepAlive), +); +const editableReaders = new WeakMap(); +const editedReaders = new WeakMap(); +const uneditedReaders = new WeakMap(); + +function loadedValue(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom) { + return Option.flatMap(registry.getNodes().get(atom)?.valueOption() ?? Option.none(), (result) => + AsyncResult.value(result as AsyncResult.AsyncResult), + ); +} + +function withEdit( + value: T, + edit: PullRequestPendingEdit, + fields: ReadonlyArray, +): T { + const held = value as Record; + const changed = fields.filter( + (field) => edit[field] !== undefined && held[field] !== edit[field], + ); + let next = + changed.length === 0 + ? held + : { ...held, ...Object.fromEntries(changed.map((field) => [field, edit[field]])) }; + if (edit.autoMergeEnabled === false && next.autoMergeMethod !== undefined) { + const { autoMergeMethod: _disarmed, ...withoutAutoMerge } = next; + next = withoutAutoMerge; + } + return next as T; +} + +function withLabelEdit }>( + value: T, + edit: PullRequestPendingEdit, +): T { + if (edit.labels === undefined) return value; + const { applied, labels: changed } = edit.labels; + const names = new Set(changed.map((label) => label.name)); + const labels = applied + ? [ + ...value.labels, + ...changed.filter((label) => !value.labels.some((held) => held.name === label.name)), + ] + : value.labels.filter((label) => !names.has(label.name)); + return labels.length === value.labels.length ? value : { ...value, labels }; +} + +/** + * The reader with every write in flight for its pull request applied. Writes go to the reader + * underneath, so a refused edit never stays behind in what the host said. + */ +function editedQuery( + inner: Atom.Writable>, + reader: Omit & { + readonly edit: (value: A, edit: PullRequestPendingEdit) => A; + }, + idleTtlMs = 5 * 60_000, +): Atom.Writable> { + const existing = editedReaders.get(inner); + if (existing !== undefined) return existing as Atom.Writable>; + const shown = Atom.writable( + (get) => { + const result = get(inner); + const edits = get(pendingEdits(reader.environmentId)); + const value = AsyncResult.value(result); + if (edits.length === 0 || Option.isNone(value)) return result; + const next = edits.reduce( + (current, edit) => (reader.concerns(edit.reference) ? reader.edit(current, edit) : current), + value.value, + ); + return next === value.value ? result : AsyncResult.map(result, () => next); + }, + (context, value: AsyncResult.AsyncResult) => context.set(inner, value), + (refresh) => refresh(inner), + ).pipe(Atom.setIdleTTL(idleTtlMs)); + editableReaders.set(inner, reader as EditableReader); + editedReaders.set(inner, shown); + uneditedReaders.set(shown, inner); + return shown; +} + +/** Shows the command's edit from the click until it settles, queued behind others or not. */ +function showWhileInFlight( + command: C & AtomCommand, + editOf: (registry: AtomRegistry.AtomRegistry, target: Target) => PullRequestPendingEdit | null, +): C { + return { + ...command, + run: async (registry, target) => { + const edit = editOf(registry, target); + if (edit === null) return command.run(registry, target); + const edits = pendingEdits(target.environmentId); + registry.update(edits, (current) => [...current, edit]); + try { + return await command.run(registry, target); + } finally { + registry.update(edits, (current) => current.filter((entry) => entry !== edit)); + } + }, + } satisfies AtomCommand; +} + +/** Keeps an accepted edit in loaded readers once it stops being in flight. */ +function settleEdit( + registry: AtomRegistry.AtomRegistry, + environmentId: EnvironmentId, + edit: PullRequestPendingEdit | null, + readsAfterWrite = false, +) { + if (edit === null) return; + for (const atom of registry.getNodes().keys()) { + const reader = typeof atom === "string" ? undefined : editableReaders.get(atom); + if (reader?.environmentId !== environmentId || !reader.concerns(edit.reference)) continue; + const shown = loadedValue(registry, atom as Atom.Atom); + if (Option.isNone(shown) || reader.edit(shown.value, edit) === shown.value) continue; + const writable = atom as Atom.Writable>; + // A read still waiting may predate the write, unless the caller started it after the commit. + if (!readsAfterWrite && registry.get(writable).waiting) registry.refresh(writable); + registry.update( + writable, + AsyncResult.map((value) => reader.edit(value, edit) as never), + ); + } +} + +function pullRequestReference(input: PullRequestRef): PullRequestRef { + const { projectId, host, repository, number, expectedAccountId } = input; + return { + projectId, + ...(host === undefined ? {} : { host }), + repository, + number, + ...(expectedAccountId === undefined ? {} : { expectedAccountId }), + }; +} + +/** What an action changes, left out where only the host knows, as when a queue takes a merge. */ +function actionEdit(input: PullRequestActionInput): PullRequestPendingEdit | null { + if (input.stackNumber !== undefined) return null; + const reference = pullRequestReference(input); + switch (input.action) { + case "close": + return { reference, state: "closed" }; + case "reopen": + return { reference, state: "open" }; + case "ready": + return { reference, isDraft: false }; + case "draft": + return { reference, isDraft: true }; + case "enable-auto-merge": + return { reference, autoMergeEnabled: true }; + case "disable-auto-merge": + return { reference, autoMergeEnabled: false }; + default: + return null; + } +} + +function updateEdit(input: PullRequestUpdateInput): PullRequestPendingEdit | null { + if (input.title === undefined && input.body === undefined) return null; + return { + reference: pullRequestReference(input), + ...(input.title === undefined ? {} : { title: input.title }), + ...(input.body === undefined ? {} : { body: input.body }), + }; +} + function samePullRequest(reader: PullRequestRef, acted: PullRequestRef) { return ( reader.projectId === acted.projectId && @@ -214,6 +412,22 @@ export function patchPullRequestListEntries( : entries; } +function editListEntries( + input: PullRequestListInput, + entries: ReadonlyArray, + edit: PullRequestPendingEdit, +): ReadonlyArray { + let changed = false; + const edited = entries.flatMap((entry): Entry[] => { + if (!samePullRequest(entry, edit.reference)) return [entry]; + const next = withLabelEdit(withEdit(entry, edit, ["state", "isDraft", "title"]), edit); + if (next === entry) return [entry]; + changed = true; + return listAccepts(input, next.state, next.isDraft) ? [next] : []; + }); + return changed ? edited : entries; +} + function patchListWithReply( input: PullRequestListInput, value: PullRequestListResult, @@ -252,6 +466,8 @@ function actionPatchedQuery( readonly rereadWithoutReply?: boolean; /** False for reads the refresh stream does not restart; defaults to true. */ readonly refreshedByServer?: (input: Input) => boolean; + /** Shows a write in flight; absent where the reader holds nothing such a write changes. */ + readonly edit?: (input: Input, value: A, edit: PullRequestPendingEdit) => A; }, ) { const writable = Atom.family((atom: Atom.Atom>) => @@ -260,7 +476,20 @@ function actionPatchedQuery( return (target: { readonly environmentId: EnvironmentId; readonly input: Input }) => { const query = source(target); const atom = writable(query); - if (actionReplyPatches.has(atom)) return atom; + const edit = options.edit; + const reader = + edit === undefined + ? atom + : editedQuery( + atom, + { + environmentId: target.environmentId, + concerns: (reference) => options.concerns(target.input, reference), + edit: (value, pending) => edit(target.input, value, pending), + }, + options.idleTtlMs, + ); + if (actionReplyPatches.has(atom)) return reader; const pendingRead = (registry: AtomRegistry.AtomRegistry) => { const result = Option.getOrUndefined( registry.getNodes().get(query)?.valueOption() ?? Option.none(), @@ -296,7 +525,9 @@ function actionPatchedQuery( if (next === shown.value) return lacking || (unrefreshed && pending !== undefined) ? reread() : undefined; yield* options.onAnswer?.(target, next, registry) ?? Effect.void; - const mounted = (registry.getNodes().get(atom)?.listeners.size ?? 0) > 0; + const mounted = [atom, reader].some( + (shownBy) => (registry.getNodes().get(shownBy)?.listeners.size ?? 0) > 0, + ); if (!freshRead && (pending !== undefined || lacking || (unrefreshed && mounted))) registry.refresh(atom); registry.update( @@ -313,7 +544,7 @@ function actionPatchedQuery( }, ), }); - return atom; + return reader; }; } @@ -380,6 +611,8 @@ export function createLinkedPullRequestSummaryAtomFamily( number: value.number, ...(value.observedAt === undefined ? {} : { observedAt: value.observedAt }), }, + edit: (_input, value, edit) => + withEdit(value, edit, ["state", "isDraft", "autoMergeEnabled", "title"]), }, ); } @@ -515,6 +748,11 @@ export function createPullRequestEnvironmentAtoms( const { autoMergeMethod: _disarmed, ...withoutAutoMerge } = patched; return withoutAutoMerge; }, + edit: (_input, value, edit) => + withLabelEdit( + withEdit(value, edit, ["state", "isDraft", "autoMergeEnabled", "title", "body"]), + edit, + ), }, ), ); @@ -577,6 +815,7 @@ export function createPullRequestEnvironmentAtoms( "observedAt", ]), }, + edit: (_input, value, edit) => withEdit(value, edit, ["state", "isDraft", "title"]), }, ), ); @@ -584,7 +823,7 @@ export function createPullRequestEnvironmentAtoms( // Hover cards read their own atoms, so a pending or failed hover read never decides where a // click on the same link goes. const previewCard = previewQuery("environment-data:pull-requests:preview-card"); - const labelCandidates = writableQueryFamily( + const labelCandidateQueries = writableQueryFamily( createEnvironmentRpcQueryAtomFamily(runtime, { label: "environment-data:pull-requests:label-candidates", tag: WS_METHODS.pullRequestsLabelCandidates, @@ -592,6 +831,51 @@ export function createPullRequestEnvironmentAtoms( staleTimeMs: 60_000, }), ); + const labelCandidates = normalizePullRequestQuery((target) => + editedQuery(labelCandidateQueries(target), { + environmentId: target.environmentId, + concerns: (reference) => samePullRequest(target.input, reference), + edit: (value, edit) => { + if (edit.labels === undefined) return value; + const { applied, labels } = edit.labels; + let changed = false; + const candidates = value.candidates.map((candidate) => { + if ( + candidate.isApplied === applied || + !labels.some((label) => label.name === candidate.name) + ) + return candidate; + changed = true; + return { ...candidate, isApplied: applied }; + }); + return changed ? { ...value, candidates } : value; + }, + }), + ); + const labelEdit = ( + registry: AtomRegistry.AtomRegistry, + target: { + readonly environmentId: EnvironmentId; + readonly input: PullRequestRef & { + readonly labels: ReadonlyArray; + readonly applied: boolean; + }; + }, + ): PullRequestPendingEdit => { + const candidates = Option.getOrUndefined( + loadedValue(registry, labelCandidates(target)), + )?.candidates; + return { + reference: pullRequestReference(target.input), + labels: { + applied: target.input.applied, + labels: target.input.labels.map((name) => ({ + name, + color: candidates?.find((candidate) => candidate.name === name)?.color ?? null, + })), + }, + }; + }; const reviewGuide = writableQueryFamily( createEnvironmentRpcQueryAtomFamily(runtime, { label: "environment-data:pull-requests:review-guide", @@ -744,6 +1028,10 @@ export function createPullRequestEnvironmentAtoms( input.host.toLowerCase() === reference.host.toLowerCase()), refreshedByServer: (input) => input.cursors === undefined, patch: patchListWithReply, + edit: (input, value, edit) => { + const entries = editListEntries(input, value.entries, edit); + return entries === value.entries ? value : { ...value, entries }; + }, }, ), /** @@ -848,41 +1136,48 @@ export function createPullRequestEnvironmentAtoms( JSON.stringify([environmentId, input.projectId, input.repository, input.number]), }, }), - runAction: createEnvironmentRpcCommand(runtime, { - tag: WS_METHODS.pullRequestsRunAction, - label: "environment-data:pull-requests:run-action", - // Preparation belongs to the write's lane. Refreshable queries would restart it after - // every preceding action, and preparing outside the lane could reorder the clicks. - execute: runAction, - onStart: (_target, registry) => readsInFlight(registry), - // Loaded readers show the reply, or re-read when the host's reply lacked the pull request. - onSuccess: ({ environmentId, input }, registry, reply, readsBeforeSend) => { - const { projectId, host, repository, number, expectedAccountId } = input; - return applyActionReply( - registry, - environmentId, - { - projectId, - ...(host === undefined ? {} : { host }), - repository, - number, - ...(expectedAccountId === undefined ? {} : { expectedAccountId }), - }, - reply, - readsBeforeSend ?? new Set(), - ); - }, - scheduler: commandScheduler, - concurrency: serialPerEnvironment, - }), - update: createEnvironmentRpcCommand(runtime, { - label: "environment-data:pull-requests:update", - tag: WS_METHODS.pullRequestsUpdate, - execute: (input) => routedRequest(WS_METHODS.pullRequestsUpdate, input), - onSuccess: (target, registry) => Effect.sync(() => registry.refresh(preview(target))), - scheduler: commandScheduler, - concurrency: serialPerEnvironment, - }), + runAction: showWhileInFlight( + createEnvironmentRpcCommand(runtime, { + tag: WS_METHODS.pullRequestsRunAction, + label: "environment-data:pull-requests:run-action", + // Preparation belongs to the write's lane. Refreshable queries would restart it after + // every preceding action, and preparing outside the lane could reorder the clicks. + execute: runAction, + onStart: (_target, registry) => readsInFlight(registry), + // Loaded readers show the reply, or re-read when the host's reply lacked the pull request. + onSuccess: ({ environmentId, input }, registry, reply, readsBeforeSend) => + applyActionReply( + registry, + environmentId, + pullRequestReference(input), + reply, + readsBeforeSend ?? new Set(), + ).pipe( + // The re-read a bare reply starts would otherwise show the old state until it answers. + Effect.andThen( + Effect.sync(() => { + if (reply === undefined) + settleEdit(registry, environmentId, actionEdit(input), true); + }), + ), + ), + scheduler: commandScheduler, + concurrency: serialPerEnvironment, + }), + (_registry, { input }) => actionEdit(input), + ), + update: showWhileInFlight( + createEnvironmentRpcCommand(runtime, { + label: "environment-data:pull-requests:update", + tag: WS_METHODS.pullRequestsUpdate, + execute: (input) => routedRequest(WS_METHODS.pullRequestsUpdate, input), + onSuccess: ({ environmentId, input }, registry) => + Effect.sync(() => settleEdit(registry, environmentId, updateEdit(input))), + scheduler: commandScheduler, + concurrency: serialPerEnvironment, + }), + (_registry, { input }) => updateEdit(input), + ), comment: createEnvironmentRpcCommand(runtime, { label: "environment-data:pull-requests:comment", tag: WS_METHODS.pullRequestsComment, @@ -1018,44 +1313,20 @@ export function createPullRequestEnvironmentAtoms( }), }), labelCandidates, - setLabels: createEnvironmentRpcCommand(runtime, { - label: "environment-data:pull-requests:set-labels", - tag: WS_METHODS.pullRequestsSetLabels, - execute: (input) => routedRequest(WS_METHODS.pullRequestsSetLabels, input), - scheduler: commandScheduler, - concurrency: serialPerEnvironment, - onSuccess: (target, registry) => - Effect.sync(() => { - const { labels, applied } = target.input; - const candidatesAtom = labelCandidates(target); - const candidates = AsyncResult.getOrElse(registry.get(candidatesAtom), () => null); - const names = new Set(labels); - updateCached(registry, candidatesAtom, (value) => ({ - ...value, - candidates: value.candidates.map((candidate) => - names.has(candidate.name) ? { ...candidate, isApplied: applied } : candidate, - ), - })); - for (const atom of loadedDetails(registry, target)) { - updateCached(registry, atom, (value) => ({ - ...value, - labels: applied - ? [ - ...value.labels, - ...labels - .filter((name) => !value.labels.some((label) => label.name === name)) - .map((name) => ({ - name, - color: - candidates?.candidates.find((candidate) => candidate.name === name) - ?.color ?? null, - })), - ] - : value.labels.filter((label) => !names.has(label.name)), - })); - } - }), - }), + setLabels: showWhileInFlight( + createEnvironmentRpcCommand(runtime, { + label: "environment-data:pull-requests:set-labels", + tag: WS_METHODS.pullRequestsSetLabels, + execute: (input) => routedRequest(WS_METHODS.pullRequestsSetLabels, input), + scheduler: commandScheduler, + concurrency: serialPerEnvironment, + onSuccess: (target, registry) => + Effect.sync(() => + settleEdit(registry, target.environmentId, labelEdit(registry, target)), + ), + }), + labelEdit, + ), setThreadResolution: createEnvironmentRpcCommand(runtime, { label: "environment-data:pull-requests:set-thread-resolution", tag: WS_METHODS.pullRequestsSetThreadResolution, From 4a19a4646230329b94ebee8c7b06ac331dcda297 Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Sun, 8 Nov 2026 02:46:16 +0100 Subject: [PATCH 02/11] perf(web): title editor and label picker stop waiting on the host The title editor closes at once and no longer re-reads detail, activity, and stack after a save. The label picker stays usable while a change is in flight; changes queue on the host in order. Created with Claude Opus 5.5 in Claude Code via T3 Code. --- .../src/components/pullRequest/PullRequestDetailPanel.tsx | 1 - .../src/components/pullRequest/PullRequestLabelPicker.tsx | 7 ++----- .../src/components/pullRequest/PullRequestTitleEditor.tsx | 8 +++----- 3 files changed, 5 insertions(+), 11 deletions(-) diff --git a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx index 9d0f6193f7e3f..c5998929bae38 100644 --- a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx +++ b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx @@ -1521,7 +1521,6 @@ export function PullRequestDetailPanel({ pullRequestKey={pullRequestKey} detail={detail} canWriteSourceControl={canWriteSourceControl} - onSaved={refreshDetail} /> } author={ diff --git a/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx b/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx index e32ef26053bd2..24b4d1eedd7b5 100644 --- a/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx +++ b/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx @@ -32,7 +32,6 @@ export function PullRequestLabelPicker({ }) { const [open, setOpen] = useState(false); const [query, setQuery] = useState(""); - const [pending, setPending] = useState(null); const candidatesQuery = useEnvironmentQuery( open ? pullRequestEnvironment.labelCandidates({ environmentId, input: reference }) : null, @@ -45,14 +44,12 @@ export function PullRequestLabelPicker({ matches(entry, query), ); + // Each change shows at once and queues behind the one before it on the host. const toggle = async (candidate: PullRequestLabelCandidate) => { - if (pending !== null) return; - setPending(candidate.name); const result = await setLabels({ environmentId, input: { ...reference, labels: [candidate.name], applied: !candidate.isApplied }, }); - setPending(null); if (result._tag === "Failure") { toastManager.add({ type: "error", @@ -88,7 +85,7 @@ export function PullRequestLabelPicker({ truncated={candidatesQuery.data?.truncated === true} truncatedLabel="This repository has more labels than are listed here. Apply the rest on the host." candidateKey={(candidate) => candidate.name} - disabled={pending !== null} + disabled={false} onSelect={(candidate) => void toggle(candidate)} > {(candidate) => { diff --git a/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx b/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx index ce6e8a801074d..992e785f018b8 100644 --- a/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx +++ b/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx @@ -24,14 +24,12 @@ export function PullRequestTitleEditor({ pullRequestKey, detail, canWriteSourceControl, - onSaved, }: { environmentId: EnvironmentId; reference: PullRequestRef; pullRequestKey: string; detail: PullRequestDetail; canWriteSourceControl: boolean; - onSaved: () => void; }) { const update = useAtomCommand(pullRequestEnvironment.update, { reportFailure: false }); const [titleScope, setTitleScope] = useState<{ @@ -49,9 +47,12 @@ export function PullRequestTitleEditor({ return; } setTitleSaving(true); + // The new title shows while the host takes it, so the editor closes at once. + setTitleScope(null); const result = await update({ environmentId, input: { ...reference, title } }); setTitleSaving(false); if (result._tag === "Failure") { + setTitleScope({ pullRequestKey, text: title }); toastManager.add({ type: "error", title: "The title could not be saved", @@ -60,10 +61,7 @@ export function PullRequestTitleEditor({ "The host refused the new title.", ), }); - return; } - setTitleScope(null); - onSaved(); }; if (titleDraft === null) { From d29511373b7d3f04e2c52ee05899835f004e2401 Mon Sep 17 00:00:00 2001 From: maria-rcks Date: Tue, 10 Nov 2026 04:37:24 +0000 Subject: [PATCH 03/11] fix(pr): preserve optimistic titles across shared summaries --- apps/web/src/state/pullRequests.ts | 23 +++++++++++- .../src/state/pullRequests.test.ts | 32 ++++++++++++++--- .../client-runtime/src/state/pullRequests.ts | 36 +++++++++++++++---- 3 files changed, 80 insertions(+), 11 deletions(-) diff --git a/apps/web/src/state/pullRequests.ts b/apps/web/src/state/pullRequests.ts index 914b6e6c72056..96c931b8490b4 100644 --- a/apps/web/src/state/pullRequests.ts +++ b/apps/web/src/state/pullRequests.ts @@ -1,9 +1,11 @@ import { useAtomValue } from "@effect/atom-react"; import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients"; import { + applyPullRequestSummaryEdits, createLinkedPullRequestSummaryAtomFamily, createPullRequestEnvironmentAtoms, createPullRequestStackAtomFamily, + pullRequestPendingEditsAtom, } from "@t3tools/client-runtime/state/pull-requests"; import { PullRequestListResult, @@ -368,6 +370,20 @@ export function restoredPullRequestList( // Answers are stamped on arrival: older servers leave no other ordering for same-dated reads. export const pullRequestEnvironment = createPullRequestEnvironmentAtoms(connectionAtomRuntime, { + acceptedEdit: ({ environmentId, input }, edit, registry) => + Effect.map(Clock.currentTimeMillis, (observedAt) => { + const saved = registry.get( + savedPullRequestSummaryAtom(savedPullRequestKey(environmentId, input)), + ); + recordObservation(registry, pullRequestSummaryKey(environmentId, input), (current) => { + const summary = applyPullRequestSummaryEdits( + input, + newestPullRequestSummary(observedPullRequestSummary(current), saved), + [edit], + ); + return summary === null ? current : { ...current, metadata: { summary, observedAt } }; + }); + }), list: ({ environmentId, input }, answer, registry) => Effect.map(Clock.currentTimeMillis, (observedAt) => { rememberPullRequestListAnswer(snapshotStorage(), { environmentId, input }, answer); @@ -503,6 +519,7 @@ export function useSharedPullRequestSummary( ? "none" : pullRequestSummaryKey(environmentId, reference); const observations = useAtomValue(pullRequestObservationsAtom(key)); + const edits = useAtomValue(pullRequestPendingEditsAtom(environmentId)); const saved = useAtomValue( savedPullRequestSummaryAtom( environmentId === null || reference === null @@ -510,7 +527,11 @@ export function useSharedPullRequestSummary( : savedPullRequestKey(environmentId, reference), ), ); - return newestPullRequestSummary(observedPullRequestSummary(observations), saved); + return applyPullRequestSummaryEdits( + reference, + newestPullRequestSummary(observedPullRequestSummary(observations), saved), + edits, + ); } export const pullRequestStackAtom = createPullRequestStackAtomFamily( connectionAtomRuntime, diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index 088c94bab017d..7ef4ccde50964 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -7,6 +7,7 @@ import { AuthOrchestrationOperateScope, ProjectId, PullRequestOperationError, + SourceControlProviderKind, WS_METHODS, type AuthSessionState, type PullRequestListInput, @@ -39,8 +40,10 @@ import * as EnvironmentSupervisor from "../connection/supervisor.ts"; import type { WsRpcProtocolClient } from "../rpc/protocol.ts"; import type { RpcSession } from "../rpc/session.ts"; import { + applyPullRequestSummaryEdits, createLinkedPullRequestSummaryAtomFamily, createPullRequestEnvironmentAtoms, + pullRequestPendingEditsAtom, } from "./pullRequests.ts"; import * as PullRequestDiffLoader from "./pullRequestDiffHttp.ts"; import { executeAtomQuery, queryPersistenceKey } from "./runtime.ts"; @@ -2610,7 +2613,18 @@ it.effect.each(["accepted", "refused"] as const)( title = input.title; }), }); - const { atoms, registry } = yield* makeTestRuntime(client); + let observedTitle = "Original"; + const handlers = { + detail: (_target: unknown, detail: { readonly title: string }) => + Effect.sync(() => { + observedTitle = detail.title; + }), + acceptedEdit: (_target: unknown, edit: { readonly title?: string }) => + Effect.sync(() => { + observedTitle = edit.title ?? observedTitle; + }), + }; + const { atoms, registry } = yield* makeTestRuntime(client, undefined, false, handlers); const target = { environmentId: TARGET.environmentId, input: actionReference }; const detail = atoms.detail(target); const preview = atoms.preview(target); @@ -2628,21 +2642,31 @@ it.effect.each(["accepted", "refused"] as const)( Option.getOrThrow(AsyncResult.value(registry.get(detail))).title, Option.getOrThrow(AsyncResult.value(registry.get(preview))).title, Option.getOrThrow(AsyncResult.value(registry.get(list))).entries[0]?.title, + applyPullRequestSummaryEdits( + actionReference, + { + ...actionReply, + provider: SourceControlProviderKind.make("github"), + title: observedTitle, + }, + registry.get(pullRequestPendingEditsAtom(target.environmentId)), + )?.title, ]; const editing = yield* Effect.promise(() => atoms.update.run(registry, { ...target, input: { ...actionReference, title: "Edited" } }), ).pipe(Effect.forkScoped); yield* Deferred.await(sent); - expect(titles()).toEqual(["Edited", "Edited", "Edited"]); + expect(titles()).toEqual(["Edited", "Edited", "Edited", "Edited"]); yield* Deferred.succeed(release, undefined); yield* Fiber.join(editing); expect(titles()).toEqual( outcome === "refused" - ? ["Original", "Original", "Original"] - : ["Edited", "Edited", "Edited"], + ? ["Original", "Original", "Original", "Original"] + : ["Edited", "Edited", "Edited", "Edited"], ); + expect(observedTitle).toBe(outcome === "refused" ? "Original" : "Edited"); // The edit is known, so no reader asks the host again. expect(reads).toBe(3); }), diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index 22208487ec82b..7dc73cdfafcfb 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -149,7 +149,7 @@ interface ActionReplyPatch { const actionReplyPatches = new WeakMap(); /** What a write in flight will change, shown by every reader until the host answers. */ -interface PullRequestPendingEdit { +export interface PullRequestPendingEdit { readonly reference: PullRequestRef; readonly state?: PullRequestState; readonly isDraft?: boolean; @@ -171,7 +171,7 @@ interface EditableReader { } // Module-wide like the reply patches, so separately built readers see the same writes. -const pendingEdits = Atom.family((_environmentId: EnvironmentId) => +export const pullRequestPendingEditsAtom = Atom.family((_environmentId: EnvironmentId | null) => Atom.make>([]).pipe(Atom.keepAlive), ); const editableReaders = new WeakMap(); @@ -236,7 +236,7 @@ function editedQuery( const shown = Atom.writable( (get) => { const result = get(inner); - const edits = get(pendingEdits(reader.environmentId)); + const edits = get(pullRequestPendingEditsAtom(reader.environmentId)); const value = AsyncResult.value(result); if (edits.length === 0 || Option.isNone(value)) return result; const next = edits.reduce( @@ -264,7 +264,7 @@ function showWhileInFlight { const edit = editOf(registry, target); if (edit === null) return command.run(registry, target); - const edits = pendingEdits(target.environmentId); + const edits = pullRequestPendingEditsAtom(target.environmentId); registry.update(edits, (current) => [...current, edit]); try { return await command.run(registry, target); @@ -351,6 +351,21 @@ function samePullRequest(reader: PullRequestRef, acted: PullRequestRef) { ); } +export function applyPullRequestSummaryEdits( + reference: PullRequestRef | null, + summary: PullRequestSummary | null, + edits: ReadonlyArray, +): PullRequestSummary | null { + if (reference === null || summary === null) return summary; + return edits.reduce( + (current, edit) => + samePullRequest(reference, edit.reference) + ? withEdit(current, edit, ["state", "isDraft", "autoMergeEnabled", "title"]) + : current, + summary, + ); +} + function pickDefined( source: T, keys: ReadonlyArray, @@ -626,6 +641,7 @@ export interface PullRequestAnswerHandlers { readonly reviewGuide?: QueryAnswerHandler; /** Once per action reply, after the loaded readers show it; unscoped references only. */ readonly actionReply?: QueryAnswerHandler; + readonly acceptedEdit?: QueryAnswerHandler; } export function createPullRequestStackAtomFamily( @@ -1171,8 +1187,16 @@ export function createPullRequestEnvironmentAtoms( label: "environment-data:pull-requests:update", tag: WS_METHODS.pullRequestsUpdate, execute: (input) => routedRequest(WS_METHODS.pullRequestsUpdate, input), - onSuccess: ({ environmentId, input }, registry) => - Effect.sync(() => settleEdit(registry, environmentId, updateEdit(input))), + onSuccess: (target, registry) => { + const edit = updateEdit(target.input); + return Effect.sync(() => settleEdit(registry, target.environmentId, edit)).pipe( + Effect.andThen(() => + edit === null + ? Effect.void + : (onAnswer.acceptedEdit?.(target, edit, registry) ?? Effect.void), + ), + ); + }, scheduler: commandScheduler, concurrency: serialPerEnvironment, }), From 8e4a2bc36fe06279fd4e9289a04d37f0ed02e4ef Mon Sep 17 00:00:00 2001 From: maria-rcks Date: Tue, 10 Nov 2026 04:53:22 +0000 Subject: [PATCH 04/11] fix(pr): retain accepted titles when saved summaries tie --- apps/web/src/state/pullRequests.test.ts | 2 ++ apps/web/src/state/pullRequests.ts | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/apps/web/src/state/pullRequests.test.ts b/apps/web/src/state/pullRequests.test.ts index 87b1483f992df..10efe769bcf83 100644 --- a/apps/web/src/state/pullRequests.test.ts +++ b/apps/web/src/state/pullRequests.test.ts @@ -94,6 +94,8 @@ describe("pull request summary cache", () => { const older = summary({ updatedAt: "2026-09-11T00:00:00Z", observedAt: 999 }); expect(newestPullRequestSummary(older, reopened)).toBe(reopened); expect(newestPullRequestSummary(reopened, older)).toBe(reopened); + const edited = summary({ title: "Accepted title" }); + expect(newestPullRequestSummary(edited, summary())).toBe(edited); }); it("reuses saved thread state while detail is stale and lets newer detail replace it", () => { diff --git a/apps/web/src/state/pullRequests.ts b/apps/web/src/state/pullRequests.ts index 96c931b8490b4..17a02a8093555 100644 --- a/apps/web/src/state/pullRequests.ts +++ b/apps/web/src/state/pullRequests.ts @@ -64,7 +64,7 @@ export function newestPullRequestSummary( ): PullRequestSummary | null { if (current === null) return observed; if (observed === null) return current; - return compareSummaries(current, observed) >= 0 ? observed : current; + return compareSummaries(current, observed) > 0 ? observed : current; } export function pullRequestListEntryToSummary(entry: PullRequestListEntry): PullRequestSummary { From fcf73a0206bd058d5e1ef1e54aa176e2eb484c53 Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Tue, 10 Nov 2026 18:36:34 +0100 Subject: [PATCH 05/11] fix(pr): a queued reopen keeps a closed pull request in open lists An open-only list dropped a pull request when a queued close was followed by a queued reopen, because each pending edit filtered the row on its own. Readers now get all pending edits for their pull request at once, and the list checks membership against the row's final state. Claude Opus 5.5 via Claude Code --- .../src/state/pullRequests.test.ts | 10 ++- .../client-runtime/src/state/pullRequests.ts | 88 +++++++++++-------- 2 files changed, 62 insertions(+), 36 deletions(-) diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index 7ef4ccde50964..cf8c37edf673d 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -2535,8 +2535,16 @@ it.effect("shows a queued close before the action ahead of it answers", () => yield* Deferred.await(firstSent); expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toEqual([]); + + const reopen = atoms.runAction.run(registry, { + environmentId: TARGET.environmentId, + input: { ...actionReference, number: 1, action: "reopen" }, + }); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(list))).entries.map((row) => row.number), + ).toEqual([1]); yield* Deferred.succeed(release, undefined); - yield* Effect.promise(() => Promise.all(closes)); + yield* Effect.promise(() => Promise.all([...closes, reopen])); }), ), ); diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index 7dc73cdfafcfb..979c1443866a4 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -167,7 +167,7 @@ type EditedField = "state" | "isDraft" | "autoMergeEnabled" | "title" | "body"; interface EditableReader { readonly environmentId: EnvironmentId; readonly concerns: (reference: PullRequestRef) => boolean; - readonly edit: (value: never, edit: PullRequestPendingEdit) => unknown; + readonly edit: (value: never, edits: ReadonlyArray) => unknown; } // Module-wide like the reply patches, so separately built readers see the same writes. @@ -220,6 +220,22 @@ function withLabelEdit { + if (candidate.isApplied === applied || !labels.some((label) => label.name === candidate.name)) + return candidate; + changed = true; + return { ...candidate, isApplied: applied }; + }); + return changed ? { ...value, candidates } : value; +} + /** * The reader with every write in flight for its pull request applied. Writes go to the reader * underneath, so a refused edit never stays behind in what the host said. @@ -227,7 +243,7 @@ function withLabelEdit( inner: Atom.Writable>, reader: Omit & { - readonly edit: (value: A, edit: PullRequestPendingEdit) => A; + readonly edit: (value: A, edits: ReadonlyArray) => A; }, idleTtlMs = 5 * 60_000, ): Atom.Writable> { @@ -236,13 +252,12 @@ function editedQuery( const shown = Atom.writable( (get) => { const result = get(inner); - const edits = get(pullRequestPendingEditsAtom(reader.environmentId)); + const edits = get(pullRequestPendingEditsAtom(reader.environmentId)).filter((edit) => + reader.concerns(edit.reference), + ); const value = AsyncResult.value(result); if (edits.length === 0 || Option.isNone(value)) return result; - const next = edits.reduce( - (current, edit) => (reader.concerns(edit.reference) ? reader.edit(current, edit) : current), - value.value, - ); + const next = reader.edit(value.value, edits); return next === value.value ? result : AsyncResult.map(result, () => next); }, (context, value: AsyncResult.AsyncResult) => context.set(inner, value), @@ -287,13 +302,13 @@ function settleEdit( const reader = typeof atom === "string" ? undefined : editableReaders.get(atom); if (reader?.environmentId !== environmentId || !reader.concerns(edit.reference)) continue; const shown = loadedValue(registry, atom as Atom.Atom); - if (Option.isNone(shown) || reader.edit(shown.value, edit) === shown.value) continue; + if (Option.isNone(shown) || reader.edit(shown.value, [edit]) === shown.value) continue; const writable = atom as Atom.Writable>; // A read still waiting may predate the write, unless the caller started it after the commit. if (!readsAfterWrite && registry.get(writable).waiting) registry.refresh(writable); registry.update( writable, - AsyncResult.map((value) => reader.edit(value, edit) as never), + AsyncResult.map((value) => reader.edit(value, [edit]) as never), ); } } @@ -430,12 +445,17 @@ export function patchPullRequestListEntries( function editListEntries( input: PullRequestListInput, entries: ReadonlyArray, - edit: PullRequestPendingEdit, + edits: ReadonlyArray, ): ReadonlyArray { let changed = false; const edited = entries.flatMap((entry): Entry[] => { - if (!samePullRequest(entry, edit.reference)) return [entry]; - const next = withLabelEdit(withEdit(entry, edit, ["state", "isDraft", "title"]), edit); + const next = edits.reduce( + (current, edit) => + samePullRequest(entry, edit.reference) + ? withLabelEdit(withEdit(current, edit, ["state", "isDraft", "title"]), edit) + : current, + entry, + ); if (next === entry) return [entry]; changed = true; return listAccepts(input, next.state, next.isDraft) ? [next] : []; @@ -482,7 +502,7 @@ function actionPatchedQuery( /** False for reads the refresh stream does not restart; defaults to true. */ readonly refreshedByServer?: (input: Input) => boolean; /** Shows a write in flight; absent where the reader holds nothing such a write changes. */ - readonly edit?: (input: Input, value: A, edit: PullRequestPendingEdit) => A; + readonly edit?: (input: Input, value: A, edits: ReadonlyArray) => A; }, ) { const writable = Atom.family((atom: Atom.Atom>) => @@ -626,8 +646,12 @@ export function createLinkedPullRequestSummaryAtomFamily( number: value.number, ...(value.observedAt === undefined ? {} : { observedAt: value.observedAt }), }, - edit: (_input, value, edit) => - withEdit(value, edit, ["state", "isDraft", "autoMergeEnabled", "title"]), + edit: (_input, value, edits) => + edits.reduce( + (current, edit) => + withEdit(current, edit, ["state", "isDraft", "autoMergeEnabled", "title"]), + value, + ), }, ); } @@ -764,10 +788,14 @@ export function createPullRequestEnvironmentAtoms( const { autoMergeMethod: _disarmed, ...withoutAutoMerge } = patched; return withoutAutoMerge; }, - edit: (_input, value, edit) => - withLabelEdit( - withEdit(value, edit, ["state", "isDraft", "autoMergeEnabled", "title", "body"]), - edit, + edit: (_input, value, edits) => + edits.reduce( + (current, edit) => + withLabelEdit( + withEdit(current, edit, ["state", "isDraft", "autoMergeEnabled", "title", "body"]), + edit, + ), + value, ), }, ), @@ -831,7 +859,11 @@ export function createPullRequestEnvironmentAtoms( "observedAt", ]), }, - edit: (_input, value, edit) => withEdit(value, edit, ["state", "isDraft", "title"]), + edit: (_input, value, edits) => + edits.reduce( + (current, edit) => withEdit(current, edit, ["state", "isDraft", "title"]), + value, + ), }, ), ); @@ -851,21 +883,7 @@ export function createPullRequestEnvironmentAtoms( editedQuery(labelCandidateQueries(target), { environmentId: target.environmentId, concerns: (reference) => samePullRequest(target.input, reference), - edit: (value, edit) => { - if (edit.labels === undefined) return value; - const { applied, labels } = edit.labels; - let changed = false; - const candidates = value.candidates.map((candidate) => { - if ( - candidate.isApplied === applied || - !labels.some((label) => label.name === candidate.name) - ) - return candidate; - changed = true; - return { ...candidate, isApplied: applied }; - }); - return changed ? { ...value, candidates } : value; - }, + edit: (value, edits) => edits.reduce(withLabelCandidateEdit, value), }), ); const labelEdit = ( From b42e869974a6c1de89e5ec9a5a5ced894da26dc3 Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Tue, 10 Nov 2026 18:50:08 +0100 Subject: [PATCH 06/11] fix(pr): a stored detail snapshot no longer hides a pending title When the detail read had no value yet, the panel fell back to its stored snapshot. Against an older server that sends no observedAt, the snapshot tied the shared summary, won the tie, and hid a pending or accepted title until a detail read succeeded. A shared summary now wins a tie against the stored snapshot. A loaded detail keeps winning ties, since it already carries the edits. Claude Opus 5.5 via Claude Code --- .../components/pullRequest/usePullRequestDetail.ts | 4 +++- apps/web/src/state/pullRequests.test.ts | 4 ++++ apps/web/src/state/pullRequests.ts | 11 +++++++++++ 3 files changed, 18 insertions(+), 1 deletion(-) diff --git a/apps/web/src/components/pullRequest/usePullRequestDetail.ts b/apps/web/src/components/pullRequest/usePullRequestDetail.ts index 7d6ab0c7a6154..2f1392c403b86 100644 --- a/apps/web/src/components/pullRequest/usePullRequestDetail.ts +++ b/apps/web/src/components/pullRequest/usePullRequestDetail.ts @@ -13,6 +13,7 @@ import { useServerConfigs } from "~/state/entities"; import { useEnvironmentQuery } from "~/state/query"; import { useEnvironmentScope } from "~/state/session"; import { + newestDisplayedPullRequestSummary, newestPullRequestSummary, pullRequestEnvironment, pullRequestListEntryToSummary, @@ -115,8 +116,9 @@ export function usePullRequestDetail( // `detail` would cost it its cache scope. const listSummary = listEntry === null ? null : pullRequestListEntryToSummary(listEntry); // The row can come from the page's stored snapshot, which no answer has published yet. - const sharedSummary = newestPullRequestSummary( + const sharedSummary = newestDisplayedPullRequestSummary( resolvedCoreDetail, + liveDetail === null, newestPullRequestSummary(observedSummary, listSummary), ); const coreDetail = diff --git a/apps/web/src/state/pullRequests.test.ts b/apps/web/src/state/pullRequests.test.ts index 10efe769bcf83..3078d72d4e16b 100644 --- a/apps/web/src/state/pullRequests.test.ts +++ b/apps/web/src/state/pullRequests.test.ts @@ -15,6 +15,7 @@ import { observePullRequestChecks, observePullRequestMetadata, newestPullRequestSummary, + newestDisplayedPullRequestSummary, rememberPullRequestListAnswer, restorePullRequestList, restoredPullRequestList, @@ -96,6 +97,9 @@ describe("pull request summary cache", () => { expect(newestPullRequestSummary(reopened, older)).toBe(reopened); const edited = summary({ title: "Accepted title" }); expect(newestPullRequestSummary(edited, summary())).toBe(edited); + const loaded = summary(); + expect(newestDisplayedPullRequestSummary(loaded, false, edited)).toBe(loaded); + expect(newestDisplayedPullRequestSummary(summary(), true, edited)).toBe(edited); }); it("reuses saved thread state while detail is stale and lets newer detail replace it", () => { diff --git a/apps/web/src/state/pullRequests.ts b/apps/web/src/state/pullRequests.ts index 17a02a8093555..5aa309c1a54ee 100644 --- a/apps/web/src/state/pullRequests.ts +++ b/apps/web/src/state/pullRequests.ts @@ -67,6 +67,17 @@ export function newestPullRequestSummary( return compareSummaries(current, observed) > 0 ? observed : current; } +/** A stored snapshot carries no edit, so a shared summary dated the same wins over it. */ +export function newestDisplayedPullRequestSummary( + detail: PullRequestSummary | null, + fromSnapshot: boolean, + shared: PullRequestSummary | null, +): PullRequestSummary | null { + return fromSnapshot + ? newestPullRequestSummary(shared, detail) + : newestPullRequestSummary(detail, shared); +} + export function pullRequestListEntryToSummary(entry: PullRequestListEntry): PullRequestSummary { return { provider: entry.provider, From 3fbca2431da1e9c2f4eafd6324b1120673dd8d34 Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Tue, 10 Nov 2026 19:59:55 +0100 Subject: [PATCH 07/11] fix(pr): a label read still loading restarts when a label change lands A label-candidate read that had not answered yet was skipped when an accepted change settled, so its reply, sent before the change, could show the label as not applied once the overlay was gone. Claude Opus 5.5 via Claude Code --- .../src/state/pullRequests.test.ts | 96 ++++++++++--------- .../client-runtime/src/state/pullRequests.ts | 4 +- 2 files changed, 53 insertions(+), 47 deletions(-) diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index cf8c37edf673d..b696bfee6aa40 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -2748,52 +2748,56 @@ it.effect("shows a label change at once and takes it back when the host refuses ), ); -it.effect("keeps an accepted label change when a candidates read sent before it answers late", () => - Effect.scoped( - Effect.gen(function* () { - let applied = false; - let reads = 0; - const readStarted = yield* Deferred.make(); - const releaseRead = yield* Deferred.make(); - const client = actionReplyClient({ - [WS_METHODS.pullRequestsLabelCandidates]: () => - Effect.gen(function* () { - reads++; - const answer = { - candidates: [{ name: "new", color: null, description: null, isApplied: applied }], - truncated: false, - }; - if (reads === 2) { - yield* Deferred.succeed(readStarted, undefined); - yield* Deferred.await(releaseRead); - } - return answer; - }), - [WS_METHODS.pullRequestsSetLabels]: () => - Effect.sync(() => { - applied = true; - }), - }); - const { atoms, registry } = yield* makeTestRuntime(client); - const target = { environmentId: TARGET.environmentId, input: actionReference }; - const candidates = atoms.labelCandidates(target); - registry.mount(candidates); - yield* Effect.promise(() => executeAtomQuery(registry, candidates)); - registry.refresh(candidates); - yield* Deferred.await(readStarted); +it.effect.each(["loaded", "loading"] as const)( + "keeps an accepted label change when a candidates read sent before it answers late (%s)", + (shown) => + Effect.scoped( + Effect.gen(function* () { + let applied = false; + let reads = 0; + const readStarted = yield* Deferred.make(); + const releaseRead = yield* Deferred.make(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsLabelCandidates]: () => + Effect.gen(function* () { + reads++; + const answer = { + candidates: [{ name: "new", color: null, description: null, isApplied: applied }], + truncated: false, + }; + if (reads === (shown === "loaded" ? 2 : 1)) { + yield* Deferred.succeed(readStarted, undefined); + yield* Deferred.await(releaseRead); + } + return answer; + }), + [WS_METHODS.pullRequestsSetLabels]: () => + Effect.sync(() => { + applied = true; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const candidates = atoms.labelCandidates(target); + registry.mount(candidates); + if (shown === "loaded") { + yield* Effect.promise(() => executeAtomQuery(registry, candidates)); + registry.refresh(candidates); + } + yield* Deferred.await(readStarted); - yield* Effect.promise(() => - atoms.setLabels.run(registry, { - ...target, - input: { ...actionReference, labels: ["new"], applied: true }, - }), - ); - yield* Deferred.succeed(releaseRead, undefined); + yield* Effect.promise(() => + atoms.setLabels.run(registry, { + ...target, + input: { ...actionReference, labels: ["new"], applied: true }, + }), + ); + yield* Deferred.succeed(releaseRead, undefined); - expect( - (yield* AtomRegistry.getResult(registry, candidates, { suspendOnWaiting: true })) - .candidates[0]?.isApplied, - ).toBe(true); - }), - ), + expect( + (yield* AtomRegistry.getResult(registry, candidates, { suspendOnWaiting: true })) + .candidates[0]?.isApplied, + ).toBe(true); + }), + ), ); diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index 979c1443866a4..54dc54c2edd48 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -302,10 +302,12 @@ function settleEdit( const reader = typeof atom === "string" ? undefined : editableReaders.get(atom); if (reader?.environmentId !== environmentId || !reader.concerns(edit.reference)) continue; const shown = loadedValue(registry, atom as Atom.Atom); - if (Option.isNone(shown) || reader.edit(shown.value, [edit]) === shown.value) continue; const writable = atom as Atom.Writable>; + const unchanged = Option.isSome(shown) && reader.edit(shown.value, [edit]) === shown.value; + if (unchanged) continue; // A read still waiting may predate the write, unless the caller started it after the commit. if (!readsAfterWrite && registry.get(writable).waiting) registry.refresh(writable); + if (Option.isNone(shown)) continue; registry.update( writable, AsyncResult.map((value) => reader.edit(value, [edit]) as never), From 2ce33a150f14166675340558343da7a82a1ad21d Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Fri, 13 Nov 2026 14:36:01 +0100 Subject: [PATCH 08/11] fix(pr): keep pending edits out of retained list rows --- .../pull-requests/usePullRequestList.ts | 49 ++++++-- apps/mobile/src/state/pull-requests.ts | 2 + .../pullRequest/PullRequestsPage.tsx | 67 ++++++++-- .../pullRequest/usePullRequestDetail.ts | 2 +- apps/web/src/state/pullRequests.test.ts | 2 +- apps/web/src/state/pullRequests.ts | 35 ++++-- .../src/state/pullRequests.test.ts | 39 +++++- .../client-runtime/src/state/pullRequests.ts | 114 +++++++++++++++--- 8 files changed, 256 insertions(+), 54 deletions(-) diff --git a/apps/mobile/src/features/pull-requests/usePullRequestList.ts b/apps/mobile/src/features/pull-requests/usePullRequestList.ts index d4fe1ab3461bd..8ba0721fd7fb5 100644 --- a/apps/mobile/src/features/pull-requests/usePullRequestList.ts +++ b/apps/mobile/src/features/pull-requests/usePullRequestList.ts @@ -1,3 +1,8 @@ +import { + editHeldPullRequestListEntries, + pullRequestHostAnswer, + pullRequestPendingEditsFor, +} from "@t3tools/client-runtime/state/pull-requests"; import { RegistryContext, useAtomMount, useAtomSubscribe, useAtomValue } from "@effect/atom-react"; import { executeAtomQuery, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime"; import type { EnvironmentId, PullRequestDiffStat, PullRequestListInput } from "@t3tools/contracts"; @@ -31,7 +36,10 @@ type Read = (atom: Atom.Atom) => A; /** The head the list query holds now, cached or answered. */ function currentHead(read: Read, target: ListTarget) { - return AsyncResult.getOrElse(read(composerPullRequests.list(target)), () => null); + return AsyncResult.getOrElse( + read(pullRequestHostAnswer(composerPullRequests.list(target))), + () => null, + ); } function currentPages(read: Read, target: ListTarget): PullRequestListPages | null { @@ -44,12 +52,23 @@ function currentPages(read: Read, target: ListTarget): PullRequestListPages | nu const sourcesFamily = Atom.family((key: string) => { const targets: readonly ListTarget[] = JSON.parse(key); return Atom.make((get) => - targets.map((target) => ({ - target, - result: get(composerPullRequests.list(target)), - pages: currentPages(get, target), - stats: get(pullRequestListStatsFamily(target.environmentId)), - })), + targets.map((target) => { + const pages = currentPages(get, target); + return { + target, + result: get(composerPullRequests.list(target)), + pages: + pages === null + ? null + : { + ...pages, + entries: editHeldPullRequestListEntries(target.input, pages.entries, (entry) => + get(pullRequestPendingEditsFor(target.environmentId, entry)), + ), + }, + stats: get(pullRequestListStatsFamily(target.environmentId)), + }; + }), ); }); @@ -71,7 +90,7 @@ async function loadNextPages( continuations(registry, targets).map(async ({ target, pages, input }) => { const response = await executeAtomQuery( registry, - composerPullRequests.list({ ...target, input }), + pullRequestHostAnswer(composerPullRequests.list({ ...target, input })), { signal, refresh: retry, @@ -113,11 +132,15 @@ async function refreshHeads( input: {}, }); if (signal.aborted) return; - const response = await executeAtomQuery(registry, composerPullRequests.list(target), { - refresh: true, - signal, - reportFailure: false, - }); + const response = await executeAtomQuery( + registry, + pullRequestHostAnswer(composerPullRequests.list(target)), + { + refresh: true, + signal, + reportFailure: false, + }, + ); if (signal.aborted) return; if (response._tag === "Failure") throw squashAtomCommandFailure(response); registry.set( diff --git a/apps/mobile/src/state/pull-requests.ts b/apps/mobile/src/state/pull-requests.ts index 6d7872fa5600f..f8a04d6a9d255 100644 --- a/apps/mobile/src/state/pull-requests.ts +++ b/apps/mobile/src/state/pull-requests.ts @@ -2,6 +2,7 @@ import { createPullRequestEnvironmentAtoms, createPullRequestStackAtomFamily, patchPullRequestListEntries, + pullRequestPendingEditsAtom, } from "@t3tools/client-runtime/state/pull-requests"; import type { EnvironmentId, PullRequestListInput } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; @@ -56,6 +57,7 @@ export const composerPullRequests = createPullRequestEnvironmentAtoms(connection pages.entries, target.input, reply, + registry.get(pullRequestPendingEditsAtom(target.environmentId)), ); return entries === "refresh" || entries === pages.entries ? pages : { ...pages, entries }; }); diff --git a/apps/web/src/components/pullRequest/PullRequestsPage.tsx b/apps/web/src/components/pullRequest/PullRequestsPage.tsx index a85b6a080948f..e11f055350f02 100644 --- a/apps/web/src/components/pullRequest/PullRequestsPage.tsx +++ b/apps/web/src/components/pullRequest/PullRequestsPage.tsx @@ -1,3 +1,8 @@ +import { + editHeldPullRequestListEntries, + pullRequestPendingEditsFor, +} from "@t3tools/client-runtime/state/pull-requests"; +import { Atom } from "effect/reactivity"; import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients"; import { applyPullRequestDraftFilterChange } from "@t3tools/client-runtime/pull-request-query"; import { Spinner } from "~/components/ui/spinner"; @@ -104,7 +109,7 @@ import { import { useSidebarProjectGroups } from "~/hooks/useSidebarProjectGroups"; import { pullRequestEnvironment, - usePullRequestList, + usePullRequestHostList, usePullRequestListStats, restoredPullRequestList, usePullRequestTurnRefreshes, @@ -147,6 +152,19 @@ const EMPTY_PREVIEW_SESSIONS = {}; const EMPTY_PREVIEW_DESKTOP_STATE = {}; const EMPTY_TERMINAL_LABELS = new Map(); const EMPTY_PENDING_SURFACES = new Set(); +function usePendingListEntries( + input: PullRequestListInput, + entries: ReadonlyArray | undefined, +) { + return useAtomValue( + Atom.make((get) => + editHeldPullRequestListEntries(input, entries ?? [], (entry) => + get(pullRequestPendingEditsFor(entry.environmentId, entry)), + ), + ), + ); +} + export function PullRequestsPage() { const search = useSearch({ from: "/_chat/pull-requests" }); const sort = search.sort ?? "ready"; @@ -341,7 +359,7 @@ export function PullRequestsPage() { ]; }); const listTargets = listTargetsFor(environmentQueries); - const listQuery = usePullRequestList(listTargets); + const listQuery = usePullRequestHostList(listTargets); /** * Kept as its own read rather than remembered from an earlier answer because an answer cannot @@ -362,7 +380,7 @@ export function PullRequestsPage() { } satisfies PullRequestListInput, })); const baselineTargets = baselineTargetsFor(environmentQueries); - const baselineQuery = usePullRequestList(baselineTargets); + const baselineQuery = usePullRequestHostList(baselineTargets); const observedHosts = rememberPullRequestHosts( rememberPullRequestHosts(hostReads, baselineQuery.observations), listQuery.observations, @@ -387,7 +405,7 @@ export function PullRequestsPage() { } satisfies PullRequestListInput, })); })(); - const facetQuery = usePullRequestList(facetTargets); + const facetQuery = usePullRequestHostList(facetTargets); const filterOptionScope = environmentQueries.map(({ environmentId, projectIds }) => ({ environmentId, input: { @@ -423,8 +441,8 @@ export function PullRequestsPage() { })); return { authored: targetsFor("authored"), reviewing: targetsFor("reviewing") }; })(); - const authoredQuery = usePullRequestList(partitionTargets.authored); - const reviewingQuery = usePullRequestList(partitionTargets.reviewing); + const authoredQuery = usePullRequestHostList(partitionTargets.authored); + const reviewingQuery = usePullRequestHostList(partitionTargets.reviewing); const invalidate = useAtomCommand(pullRequestEnvironment.invalidate, { reportFailure: false }); const [detailRefreshToken, setDetailRefreshToken] = useState(0); const [invalidating, setInvalidating] = useState(false); @@ -703,6 +721,23 @@ export function PullRequestsPage() { search.state, ); + const heldEntries = ordered?.key === filterKey ? ordered.entries : (listData?.entries ?? []); + const overlayInput = { state: search.state, filters }; + const shownEntries = usePendingListEntries(overlayInput, heldEntries); + const shownBaseline = usePendingListEntries( + overlayInput, + typedParsed.filters.checks === undefined ? baselineQuery.data?.entries : undefined, + ); + const shownAuthored = usePendingListEntries( + overlayInput, + partitionsWanted ? authoredQuery.data?.entries : undefined, + ); + const shownReviewing = usePendingListEntries( + overlayInput, + partitionsWanted ? reviewingQuery.data?.entries : undefined, + ); + const shownHeldAuthored = usePendingListEntries(overlayInput, heldPartitions?.authored); + const shownHeldReviewing = usePendingListEntries(overlayInput, heldPartitions?.reviewing); const scrollRef = useRef(null); const { entries, @@ -711,9 +746,12 @@ export function PullRequestsPage() { entriesByStatsKey, heldPullRequestsBySurface, } = pullRequestGroups({ - known: ordered?.key === filterKey ? ordered.entries : (listData?.entries ?? []), + known: shownEntries, // The baseline was read without typed qualifiers, and rows cannot be checked for `checks:`. - baseline: typedParsed.filters.checks === undefined ? baselineQuery.data?.entries : undefined, + baseline: + typedParsed.filters.checks === undefined && baselineQuery.data !== null + ? shownBaseline + : undefined, providers: baselineQuery.data?.providers ?? listData?.providers ?? [], viewers, involvement: search.involvement, @@ -723,11 +761,14 @@ export function PullRequestsPage() { answeredLocally: querySettled && !showingCarried, baselineEmpty, held: - loaded !== null && loaded.environmentKey === environmentKey && loaded.scope === scopeKey - ? loaded.partitions - : undefined, - authored: partitionsWanted ? authoredQuery.data?.entries : undefined, - reviewing: partitionsWanted ? reviewingQuery.data?.entries : undefined, + heldPartitions === undefined + ? undefined + : { + authored: shownHeldAuthored, + reviewing: shownHeldReviewing, + }, + authored: partitionsWanted && authoredQuery.data !== null ? shownAuthored : undefined, + reviewing: partitionsWanted && reviewingQuery.data !== null ? shownReviewing : undefined, partitionsWanted, }); diff --git a/apps/web/src/components/pullRequest/usePullRequestDetail.ts b/apps/web/src/components/pullRequest/usePullRequestDetail.ts index 0e3ee4fa0cbca..e9052ae190a45 100644 --- a/apps/web/src/components/pullRequest/usePullRequestDetail.ts +++ b/apps/web/src/components/pullRequest/usePullRequestDetail.ts @@ -119,7 +119,7 @@ export function usePullRequestDetail( const sharedSummary = newestDisplayedPullRequestSummary( resolvedCoreDetail, liveDetail === null, - newestPullRequestSummary(observedSummary, listSummary), + newestPullRequestSummary(listSummary, observedSummary), ); const coreDetail = resolvedCoreDetail === null || sharedSummary === null || sharedSummary === resolvedCoreDetail diff --git a/apps/web/src/state/pullRequests.test.ts b/apps/web/src/state/pullRequests.test.ts index a84c6055de419..b6b7d60b34dcf 100644 --- a/apps/web/src/state/pullRequests.test.ts +++ b/apps/web/src/state/pullRequests.test.ts @@ -130,7 +130,7 @@ describe("pull request summary cache", () => { expect(newestPullRequestSummary(older, reopened)).toBe(reopened); expect(newestPullRequestSummary(reopened, older)).toBe(reopened); const edited = summary({ title: "Accepted title" }); - expect(newestPullRequestSummary(edited, summary())).toBe(edited); + expect(newestPullRequestSummary(summary(), edited)).toBe(edited); const loaded = summary(); expect(newestDisplayedPullRequestSummary(loaded, false, edited)).toBe(loaded); expect(newestDisplayedPullRequestSummary(summary(), true, edited)).toBe(edited); diff --git a/apps/web/src/state/pullRequests.ts b/apps/web/src/state/pullRequests.ts index 0c69b52c4933b..895964beba058 100644 --- a/apps/web/src/state/pullRequests.ts +++ b/apps/web/src/state/pullRequests.ts @@ -5,7 +5,8 @@ import { createLinkedPullRequestSummaryAtomFamily, createPullRequestEnvironmentAtoms, createPullRequestStackAtomFamily, - pullRequestPendingEditsAtom, + pullRequestPendingEditsFor, + pullRequestHostAnswer, } from "@t3tools/client-runtime/state/pull-requests"; import { PullRequestListResult, @@ -67,7 +68,7 @@ export function newestPullRequestSummary( ): PullRequestSummary | null { if (current === null) return observed; if (observed === null) return current; - return compareSummaries(current, observed) > 0 ? observed : current; + return compareSummaries(current, observed) >= 0 ? observed : current; } /** A stored snapshot carries no edit, so a shared summary dated the same wins over it. */ @@ -77,8 +78,8 @@ export function newestDisplayedPullRequestSummary( shared: PullRequestSummary | null, ): PullRequestSummary | null { return fromSnapshot - ? newestPullRequestSummary(shared, detail) - : newestPullRequestSummary(detail, shared); + ? newestPullRequestSummary(detail, shared) + : newestPullRequestSummary(shared, detail); } export function pullRequestListEntryToSummary(entry: PullRequestListEntry): PullRequestSummary { @@ -392,7 +393,7 @@ export const pullRequestEnvironment = createPullRequestEnvironmentAtoms(connecti recordObservation(registry, pullRequestSummaryKey(environmentId, input), (current) => { const summary = applyPullRequestSummaryEdits( input, - newestPullRequestSummary(observedPullRequestSummary(current), saved), + newestPullRequestSummary(saved, observedPullRequestSummary(current)), [edit], ); return summary === null ? current : { ...current, metadata: { summary, observedAt } }; @@ -533,7 +534,7 @@ export function useSharedPullRequestSummary( ? "none" : pullRequestSummaryKey(environmentId, reference); const observations = useAtomValue(pullRequestObservationsAtom(key)); - const edits = useAtomValue(pullRequestPendingEditsAtom(environmentId)); + const edits = useAtomValue(pullRequestPendingEditsFor(environmentId, reference)); const saved = useAtomValue( savedPullRequestSummaryAtom( environmentId === null || reference === null @@ -543,7 +544,7 @@ export function useSharedPullRequestSummary( ); return applyPullRequestSummaryEdits( reference, - newestPullRequestSummary(observedPullRequestSummary(observations), saved), + newestPullRequestSummary(saved, observedPullRequestSummary(observations)), edits, ); } @@ -651,6 +652,13 @@ function createMergedEnvironmentQuery( }; } +const usePullRequestHostListsQuery = createMergedEnvironmentQuery( + "web-pull-requests:host-list", + (target: EnvironmentQueryTarget) => + pullRequestHostAnswer(pullRequestEnvironment.list(target)), + observeFailedPullRequestList, +); + const usePullRequestListsQuery = createMergedEnvironmentQuery( "web-pull-requests:list", pullRequestEnvironment.list, @@ -697,7 +705,18 @@ export interface MergedPullRequestListView { export function usePullRequestList( targets: ReadonlyArray>, ): MergedPullRequestListView { - const query = usePullRequestListsQuery(targets); + return mergedPullRequestListView(usePullRequestListsQuery(targets)); +} + +export function usePullRequestHostList( + targets: ReadonlyArray>, +): MergedPullRequestListView { + return mergedPullRequestListView(usePullRequestHostListsQuery(targets)); +} + +function mergedPullRequestListView( + query: ReturnType, +): MergedPullRequestListView { const data = mergePullRequestLists(query.values); return { data, diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index 6276e18f4e673..1bab875378cc4 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -44,7 +44,10 @@ import { applyPullRequestSummaryEdits, createLinkedPullRequestSummaryAtomFamily, createPullRequestEnvironmentAtoms, + editHeldPullRequestListEntries, + pullRequestHostAnswer, pullRequestPendingEditsAtom, + pullRequestPendingEditsFor, } from "./pullRequests.ts"; import * as PullRequestDiffLoader from "./pullRequestDiffHttp.ts"; import { executeAtomQuery, queryPersistenceKey } from "./runtime.ts"; @@ -2412,6 +2415,14 @@ it.effect("puts readers back when the host refuses an action, and saves nothing ).pipe(Effect.forkScoped); yield* Deferred.await(sent); expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("closed"); + const held = Option.getOrThrow( + AsyncResult.value(registry.get(pullRequestHostAnswer(list))), + ).entries; + const shownHeld = () => + editHeldPullRequestListEntries({ state: "open" }, held, () => + registry.get(pullRequestPendingEditsFor(target.environmentId, actionReference)), + ); + expect(shownHeld()).toEqual([]); yield* Deferred.succeed(release, undefined); expect((yield* Fiber.join(acting))._tag).toBe("Failure"); @@ -2419,6 +2430,7 @@ it.effect("puts readers back when the host refuses an action, and saves nothing expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toMatchObject([ { state: "open" }, ]); + expect(shownHeld()).toMatchObject([{ state: "open" }]); expect([...saved.values()].some((payload) => payload.includes('"closed"'))).toBe(false); }), ), @@ -2473,11 +2485,15 @@ it.effect( ), ); -it.effect("shows a queued close before the action ahead of it answers", () => +it.effect.each([ + ["with", { ...actionReply, state: "closed" as const }], + ["without", undefined], +] as const)("shows a queued close before the action ahead of it answers, %s a reply", ([, reply]) => Effect.scoped( Effect.gen(function* () { const firstSent = yield* Deferred.make(); const release = yield* Deferred.make(); + const releaseReopen = yield* Deferred.make(); const rows = [1, 2].map((number) => ({ ...actionReference, number, @@ -2487,11 +2503,22 @@ it.effect("shows a queued close before the action ahead of it answers", () => })); const client = actionReplyClient({ [WS_METHODS.pullRequestsList]: () => Effect.succeed(listResult(rows)), - [WS_METHODS.pullRequestsRunAction]: (input: { readonly number: number }) => + [WS_METHODS.pullRequestsRunAction]: (input: { + readonly number: number; + readonly action: string; + }) => Effect.gen(function* () { + if (input.action === "reopen") { + yield* Deferred.await(releaseReopen); + return yield* new PullRequestOperationError({ + operation: "runAction", + detail: "reopen refused", + }); + } if (input.number === 1) { yield* Deferred.succeed(firstSent, undefined); yield* Deferred.await(release); + return reply; } return undefined; }), @@ -2519,7 +2546,13 @@ it.effect("shows a queued close before the action ahead of it answers", () => Option.getOrThrow(AsyncResult.value(registry.get(list))).entries.map((row) => row.number), ).toEqual([1]); yield* Deferred.succeed(release, undefined); - yield* Effect.promise(() => Promise.all([...closes, reopen])); + yield* Effect.promise(() => Promise.all(closes)); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(list))).entries.map((row) => row.number), + ).toEqual([1]); + yield* Deferred.succeed(releaseReopen, undefined); + expect((yield* Effect.promise(() => reopen))._tag).toBe("Failure"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toEqual([]); }), ), ); diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index 5992ee85240fb..09cc0481e612e 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -168,7 +168,11 @@ type EditedField = "state" | "isDraft" | "autoMergeEnabled" | "title" | "body"; interface EditableReader { readonly environmentId: EnvironmentId; readonly concerns: (reference: PullRequestRef) => boolean; - readonly edit: (value: never, edits: ReadonlyArray) => unknown; + readonly edit: ( + value: never, + edits: ReadonlyArray, + pending?: ReadonlyArray, + ) => unknown; } // Module-wide like the reply patches, so separately built readers see the same writes. @@ -179,6 +183,34 @@ const editableReaders = new WeakMap(); const editedReaders = new WeakMap(); const uneditedReaders = new WeakMap(); +const pendingEditsByPullRequest = Atom.family((key: string) => { + const [environmentId, reference] = JSON.parse(key) as [EnvironmentId, PullRequestRef]; + return Atom.make((get) => + get(pullRequestPendingEditsAtom(environmentId)).filter((edit) => + samePullRequest(reference, edit.reference), + ), + ).pipe( + Atom.withEquality( + (previous: ReadonlyArray, next) => + previous.length === next.length && previous.every((edit, index) => edit === next[index]), + ), + ); +}); +const noPendingEdits = Atom.make>([]); + +export function pullRequestPendingEditsFor( + environmentId: EnvironmentId | null, + reference: PullRequestRef | null, +): Atom.Atom> { + return environmentId === null || reference === null + ? noPendingEdits + : pendingEditsByPullRequest(JSON.stringify([environmentId, pullRequestReference(reference)])); +} + +export function pullRequestHostAnswer(reader: Atom.Atom): Atom.Atom { + return (uneditedReaders.get(reader) ?? reader) as Atom.Atom; +} + function loadedValue(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom) { return Option.flatMap(registry.getNodes().get(atom)?.valueOption() ?? Option.none(), (result) => AsyncResult.value(result as AsyncResult.AsyncResult), @@ -244,7 +276,11 @@ function withLabelCandidateEdit( function editedQuery( inner: Atom.Writable>, reader: Omit & { - readonly edit: (value: A, edits: ReadonlyArray) => A; + readonly edit: ( + value: A, + edits: ReadonlyArray, + pending?: ReadonlyArray, + ) => A; }, idleTtlMs = 5 * 60_000, ): Atom.Writable> { @@ -257,7 +293,7 @@ function editedQuery( reader.concerns(edit.reference), ); const value = AsyncResult.value(result); - if (edits.length === 0 || Option.isNone(value)) return result; + if (Option.isNone(value)) return result; const next = reader.edit(value.value, edits); return next === value.value ? result : AsyncResult.map(result, () => next); }, @@ -299,19 +335,21 @@ function settleEdit( readsAfterWrite = false, ) { if (edit === null) return; + const pending = registry.get(pullRequestPendingEditsAtom(environmentId)); for (const atom of registry.getNodes().keys()) { const reader = typeof atom === "string" ? undefined : editableReaders.get(atom); if (reader?.environmentId !== environmentId || !reader.concerns(edit.reference)) continue; const shown = loadedValue(registry, atom as Atom.Atom); const writable = atom as Atom.Writable>; - const unchanged = Option.isSome(shown) && reader.edit(shown.value, [edit]) === shown.value; + const unchanged = + Option.isSome(shown) && reader.edit(shown.value, [edit], pending) === shown.value; if (unchanged) continue; // A read still waiting may predate the write, unless the caller started it after the commit. if (!readsAfterWrite && registry.get(writable).waiting) registry.refresh(writable); if (Option.isNone(shown)) continue; registry.update( writable, - AsyncResult.map((value) => reader.edit(value, [edit]) as never), + AsyncResult.map((value) => reader.edit(value, [edit], pending) as never), ); } } @@ -402,6 +440,22 @@ function listAccepts(input: PullRequestListInput, state: string, isDraft: boolea ); } +function listKeeps( + input: PullRequestListInput, + entry: PullRequestListEntry, + pending: ReadonlyArray, +) { + if (listAccepts(input, entry.state, entry.isDraft)) return true; + const edited = pending.reduce( + (current, edit) => + samePullRequest(entry, edit.reference) + ? withEdit(current, edit, ["state", "isDraft"]) + : current, + entry, + ); + return edited !== entry && listAccepts(input, edited.state, edited.isDraft); +} + /** * Listing rows with an action's reply applied, the same array when it changes none, and `refresh` * when the reply adds the pull request to a listing, which only a read can place. @@ -411,6 +465,7 @@ export function patchPullRequestListEntries( entries: ReadonlyArray, reference: PullRequestRef, reply: PullRequestSummary, + pending: ReadonlyArray = [], ): ReadonlyArray | "refresh" { let found = false; let changed = false; @@ -433,7 +488,7 @@ export function patchPullRequestListEntries( "updatedAt", ]), }; - return listAccepts(input, next.state, next.isDraft) ? [next] : []; + return listKeeps(input, next, pending) ? [next] : []; }); if (!found) { return input.cursors === undefined && listAccepts(input, reply.state, reply.isDraft) @@ -445,10 +500,11 @@ export function patchPullRequestListEntries( : entries; } -function editListEntries( +function editPullRequestListEntries( input: PullRequestListInput, entries: ReadonlyArray, edits: ReadonlyArray, + pending = edits, ): ReadonlyArray { let changed = false; const edited = entries.flatMap((entry): Entry[] => { @@ -459,20 +515,36 @@ function editListEntries( : current, entry, ); - if (next === entry) return [entry]; + if (next === entry && listAccepts(input, next.state, next.isDraft)) return [entry]; changed = true; - return listAccepts(input, next.state, next.isDraft) ? [next] : []; + return listKeeps(input, next, pending) ? [next] : []; }); return changed ? edited : entries; } +export function editHeldPullRequestListEntries( + input: PullRequestListInput, + entries: ReadonlyArray, + editsOf: (entry: Entry) => ReadonlyArray, +): ReadonlyArray { + let changed = false; + const shown = entries.flatMap((entry) => { + const edits = editsOf(entry); + const next = editPullRequestListEntries(input, [entry], edits); + if (next[0] !== entry) changed = true; + return next; + }); + return changed ? shown : entries; +} + function patchListWithReply( input: PullRequestListInput, value: PullRequestListResult, reference: PullRequestRef, reply: PullRequestSummary, + pending: ReadonlyArray, ): PullRequestListResult | "refresh" { - const entries = patchPullRequestListEntries(input, value.entries, reference, reply); + const entries = patchPullRequestListEntries(input, value.entries, reference, reply, pending); if (entries === "refresh") return entries; return entries === value.entries ? value : { ...value, entries }; } @@ -497,6 +569,7 @@ function actionPatchedQuery( value: A, reference: PullRequestRef, reply: PullRequestSummary, + pending: ReadonlyArray, ) => A | "refresh"; /** Fields the reply lacks also changed, so the patched value shows while a read fetches them. */ readonly rereads?: (value: A, reply: PullRequestSummary) => boolean; @@ -505,7 +578,12 @@ function actionPatchedQuery( /** False for reads the refresh stream does not restart; defaults to true. */ readonly refreshedByServer?: (input: Input) => boolean; /** Shows a write in flight; absent where the reader holds nothing such a write changes. */ - readonly edit?: (input: Input, value: A, edits: ReadonlyArray) => A; + readonly edit?: ( + input: Input, + value: A, + edits: ReadonlyArray, + pending?: ReadonlyArray, + ) => A; }, ) { const writable = Atom.family((atom: Atom.Atom>) => @@ -523,7 +601,7 @@ function actionPatchedQuery( { environmentId: target.environmentId, concerns: (reference) => options.concerns(target.input, reference), - edit: (value, pending) => edit(target.input, value, pending), + edit: (value, edits, pending) => edit(target.input, value, edits, pending), }, options.idleTtlMs, ); @@ -556,7 +634,13 @@ function actionPatchedQuery( (current: AsyncResult.AsyncResult) => AsyncResult.value(current), ); if (Option.isNone(shown)) return reread(); - const patched = options.patch(target.input, shown.value, reference, reply); + const patched = options.patch( + target.input, + shown.value, + reference, + reply, + registry.get(pullRequestPendingEditsAtom(environmentId)), + ); if (patched === "refresh") return reread(); const lacking = options.rereads?.(shown.value, reply) === true; const next = reuseUnchanged(shown.value, patched); @@ -1083,8 +1167,8 @@ export function createPullRequestEnvironmentAtoms( input.host.toLowerCase() === reference.host.toLowerCase()), refreshedByServer: (input) => input.cursors === undefined, patch: patchListWithReply, - edit: (input, value, edit) => { - const entries = editListEntries(input, value.entries, edit); + edit: (input, value, edits, pending) => { + const entries = editPullRequestListEntries(input, value.entries, edits, pending); return entries === value.entries ? value : { ...value, entries }; }, }, From 7a1d2d39fcf42f87c27691a81f1b92447e977717 Mon Sep 17 00:00:00 2001 From: Bil0000 <62337003+Bil0000@users.noreply.github.com> Date: Fri, 13 Nov 2026 15:44:25 +0100 Subject: [PATCH 09/11] fix(pr): an accepted edit stays on retained list rows Co-Authored-By: GPT-6.1 Sol --- apps/mobile/src/state/pull-requests.ts | 19 ++ .../pullRequest/PullRequestsPage.tsx | 29 ++- .../src/state/pullRequests.test.ts | 204 ++++++++++++------ .../client-runtime/src/state/pullRequests.ts | 54 +++-- 4 files changed, 215 insertions(+), 91 deletions(-) diff --git a/apps/mobile/src/state/pull-requests.ts b/apps/mobile/src/state/pull-requests.ts index f8a04d6a9d255..73a53da129f38 100644 --- a/apps/mobile/src/state/pull-requests.ts +++ b/apps/mobile/src/state/pull-requests.ts @@ -1,5 +1,6 @@ import { createPullRequestEnvironmentAtoms, + editHeldPullRequestListEntries, createPullRequestStackAtomFamily, patchPullRequestListEntries, pullRequestPendingEditsAtom, @@ -63,6 +64,24 @@ export const composerPullRequests = createPullRequestEnvironmentAtoms(connection }); } }), + acceptedEdit: (target, edit, registry) => + Effect.sync(() => { + for (const atom of registry.getNodes().keys()) { + const listing = + typeof atom === "string" ? undefined : pullRequestListPagesTargets.get(atom); + if (listing === undefined || listing[0] !== target.environmentId) continue; + registry.update(atom as Atom.Writable, (pages) => { + if (pages === null) return pages; + const entries = editHeldPullRequestListEntries( + listing[1], + pages.entries, + () => [edit], + registry.get(pullRequestPendingEditsAtom(target.environmentId)), + ); + return entries === pages.entries ? pages : { ...pages, entries }; + }); + } + }), // A new head can change which files GitHub still counts as viewed, so the viewed-files read is // refreshed where the new head lands. The detail atom still holds the previous answer here. detail: (target, value, registry) => diff --git a/apps/web/src/components/pullRequest/PullRequestsPage.tsx b/apps/web/src/components/pullRequest/PullRequestsPage.tsx index e11f055350f02..f4fea4423d4c1 100644 --- a/apps/web/src/components/pullRequest/PullRequestsPage.tsx +++ b/apps/web/src/components/pullRequest/PullRequestsPage.tsx @@ -1,8 +1,5 @@ -import { - editHeldPullRequestListEntries, - pullRequestPendingEditsFor, -} from "@t3tools/client-runtime/state/pull-requests"; -import { Atom } from "effect/reactivity"; +import { heldPullRequestListEntriesAtom } from "@t3tools/client-runtime/state/pull-requests"; +import { AsyncResult, Atom } from "effect/reactivity"; import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients"; import { applyPullRequestDraftFilterChange } from "@t3tools/client-runtime/pull-request-query"; import { Spinner } from "~/components/ui/spinner"; @@ -152,15 +149,31 @@ const EMPTY_PREVIEW_SESSIONS = {}; const EMPTY_PREVIEW_DESKTOP_STATE = {}; const EMPTY_TERMINAL_LABELS = new Map(); const EMPTY_PENDING_SURFACES = new Set(); +const heldRowReaders = new WeakMap< + EnvironmentPullRequestEntry, + Map>> +>(); + function usePendingListEntries( input: PullRequestListInput, entries: ReadonlyArray | undefined, ) { + const key = JSON.stringify(input); return useAtomValue( Atom.make((get) => - editHeldPullRequestListEntries(input, entries ?? [], (entry) => - get(pullRequestPendingEditsFor(entry.environmentId, entry)), - ), + (entries ?? []).flatMap((entry) => { + let readers = heldRowReaders.get(entry); + if (readers === undefined) { + readers = new Map(); + heldRowReaders.set(entry, readers); + } + let reader = readers.get(key); + if (reader === undefined) { + reader = heldPullRequestListEntriesAtom(entry.environmentId, input, [entry]); + readers.set(key, reader); + } + return AsyncResult.getOrElse(get(reader), () => []); + }), ), ); } diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index 1bab875378cc4..63bdb37df2b10 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -11,6 +11,7 @@ import { WS_METHODS, type AuthSessionState, type PullRequestListInput, + type PullRequestListEntry, } from "@t3tools/contracts"; import { expect, it } from "@effect/vitest"; import * as Schema from "effect/Schema"; @@ -45,6 +46,7 @@ import { createLinkedPullRequestSummaryAtomFamily, createPullRequestEnvironmentAtoms, editHeldPullRequestListEntries, + heldPullRequestListEntriesAtom, pullRequestHostAnswer, pullRequestPendingEditsAtom, pullRequestPendingEditsFor, @@ -1101,6 +1103,20 @@ const actionReply = { observedAt: 200, }; +const actionListEntry: PullRequestListEntry = { + ...actionReply, + provider: SourceControlProviderKind.make("github"), + projectTitle: "Web", + state: "open", + author: null, + mergeability: "unknown", + additions: 0, + deletions: 0, + createdAt: actionReply.updatedAt, + viewerReviewRequested: false, + labels: [], +}; + function actionReplyClient(overrides: Record = {}) { return { [WS_METHODS.pullRequestsSubscribeRefreshes]: () => Stream.never, @@ -2462,8 +2478,20 @@ it.effect( return undefined; }), }); - const { atoms, registry } = yield* makeTestRuntime(client); + let held = [actionListEntry] as ReadonlyArray; + const { atoms, registry } = yield* makeTestRuntime(client, undefined, false, { + acceptedEdit: (_target, edit) => + Effect.sync(() => { + held = editHeldPullRequestListEntries({ state: "all" }, held, () => [edit]); + }), + }); const target = { environmentId: TARGET.environmentId, input: actionReference }; + const retained = heldPullRequestListEntriesAtom( + target.environmentId, + { state: "all" }, + held, + ); + registry.mount(retained); const detail = atoms.detail(target); registry.mount(detail); yield* Effect.promise(() => executeAtomQuery(registry, detail)); @@ -2477,6 +2505,10 @@ it.effect( yield* Deferred.await(rereadStarted); expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("closed"); + expect(held[0]?.state).toBe("closed"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(retained)))[0]?.state).toBe( + "closed", + ); yield* Deferred.succeed(releaseReread, undefined); expect( (yield* AtomRegistry.getResult(registry, detail, { suspendOnWaiting: true })).observedAt, @@ -2629,15 +2661,20 @@ it.effect.each(["accepted", "refused"] as const)( title = input.title; }), }); + let held: ReadonlyArray = []; let observedTitle = "Original"; const handlers = { detail: (_target: unknown, detail: { readonly title: string }) => Effect.sync(() => { observedTitle = detail.title; }), - acceptedEdit: (_target: unknown, edit: { readonly title?: string }) => + acceptedEdit: ( + _target: unknown, + edit: Parameters[2][number], + ) => Effect.sync(() => { observedTitle = edit.title ?? observedTitle; + held = editHeldPullRequestListEntries({ state: "open" }, held, () => [edit]); }), }; const { atoms, registry } = yield* makeTestRuntime(client, undefined, false, handlers); @@ -2654,6 +2691,15 @@ it.effect.each(["accepted", "refused"] as const)( registry.mount(atom); yield* Effect.promise(() => executeAtomQuery(registry, atom)); } + held = Option.getOrThrow( + AsyncResult.value(registry.get(pullRequestHostAnswer(list))), + ).entries; + const retained = heldPullRequestListEntriesAtom( + target.environmentId, + { state: "open" }, + held, + ); + registry.mount(retained); const titles = () => [ Option.getOrThrow(AsyncResult.value(registry.get(detail))).title, Option.getOrThrow(AsyncResult.value(registry.get(preview))).title, @@ -2683,77 +2729,105 @@ it.effect.each(["accepted", "refused"] as const)( : ["Edited", "Edited", "Edited", "Edited"], ); expect(observedTitle).toBe(outcome === "refused" ? "Original" : "Edited"); + expect(held[0]?.title).toBe(outcome === "refused" ? "Original" : "Edited"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(retained)))[0]?.title).toBe( + outcome === "refused" ? "Original" : "Edited", + ); // The edit is known, so no reader asks the host again. expect(reads).toBe(3); }), ), ); -it.effect("shows a label change at once and takes it back when the host refuses it", () => - Effect.scoped( - Effect.gen(function* () { - const sent = yield* Deferred.make(); - const release = yield* Deferred.make(); - const existing = { name: "existing", color: "111111" }; - const added = { name: "new", color: "abcdef" }; - const client = actionReplyClient({ - [WS_METHODS.pullRequestsDetail]: () => - Effect.succeed({ ...actionReference, state: "open", labels: [existing] }), - [WS_METHODS.pullRequestsLabelCandidates]: () => - Effect.succeed({ - candidates: [ - { ...existing, description: null, isApplied: true }, - { ...added, description: null, isApplied: false }, - ], - truncated: false, - }), - [WS_METHODS.pullRequestsSetLabels]: () => - Effect.gen(function* () { - yield* Deferred.succeed(sent, undefined); - yield* Deferred.await(release); - return yield* new MutationRefused(); - }), - }); - const { atoms, registry } = yield* makeTestRuntime(client); - const target = { environmentId: TARGET.environmentId, input: actionReference }; - const detail = atoms.detail(target); - const candidates = atoms.labelCandidates(target); - const loaded: ReadonlyArray>> = [ - detail, - candidates, - ]; - for (const atom of loaded) { - registry.mount(atom); - yield* Effect.promise(() => executeAtomQuery(registry, atom)); - } +it.effect.each(["accepted", "refused"] as const)( + "keeps a label change on retained rows only when the host takes it (%s)", + (outcome) => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const existing = { name: "existing", color: "111111" }; + const added = { name: "new", color: "abcdef" }; + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => + Effect.succeed({ ...actionReference, state: "open", labels: [existing] }), + [WS_METHODS.pullRequestsLabelCandidates]: () => + Effect.succeed({ + candidates: [ + { ...existing, description: null, isApplied: true }, + { ...added, description: null, isApplied: false }, + ], + truncated: false, + }), + [WS_METHODS.pullRequestsSetLabels]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + if (outcome === "refused") return yield* new MutationRefused(); + }), + }); + let held: ReadonlyArray = [ + { ...actionListEntry, labels: [existing] }, + ]; + const { atoms, registry } = yield* makeTestRuntime(client, undefined, false, { + acceptedEdit: (_target, edit) => + Effect.sync(() => { + held = editHeldPullRequestListEntries({ state: "open" }, held, () => [edit]); + }), + }); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const retained = heldPullRequestListEntriesAtom( + target.environmentId, + { state: "open" }, + held, + ); + registry.mount(retained); + const detail = atoms.detail(target); + const candidates = atoms.labelCandidates(target); + const loaded: ReadonlyArray>> = [ + detail, + candidates, + ]; + for (const atom of loaded) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } - const labelling = yield* Effect.promise(() => - atoms.setLabels.run(registry, { - ...target, - input: { ...actionReference, labels: ["new"], applied: true }, - }), - ).pipe(Effect.forkScoped); - yield* Deferred.await(sent); - expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual([ - existing, - added, - ]); - expect( - Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( - (candidate) => candidate.isApplied, - ), - ).toEqual([true, true]); - yield* Deferred.succeed(release, undefined); - expect((yield* Fiber.join(labelling))._tag).toBe("Failure"); + const labelling = yield* Effect.promise(() => + atoms.setLabels.run(registry, { + ...target, + input: { ...actionReference, labels: ["new"], applied: true }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual([ + existing, + added, + ]); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( + (candidate) => candidate.isApplied, + ), + ).toEqual([true, true]); + yield* Deferred.succeed(release, undefined); + expect((yield* Fiber.join(labelling))._tag).toBe( + outcome === "refused" ? "Failure" : "Success", + ); + expect(held[0]?.labels).toEqual(outcome === "refused" ? [existing] : [existing, added]); + expect(Option.getOrThrow(AsyncResult.value(registry.get(retained)))[0]?.labels).toEqual( + outcome === "refused" ? [existing] : [existing, added], + ); - expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual([existing]); - expect( - Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( - (candidate) => candidate.isApplied, - ), - ).toEqual([true, false]); - }), - ), + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual( + outcome === "refused" ? [existing] : [existing, added], + ); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( + (candidate) => candidate.isApplied, + ), + ).toEqual(outcome === "refused" ? [true, false] : [true, true]); + }), + ), ); it.effect.each(["loaded", "loading"] as const)( diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index 09cc0481e612e..e1ba8c5d67be0 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -526,17 +526,32 @@ export function editHeldPullRequestListEntries, editsOf: (entry: Entry) => ReadonlyArray, + pending?: ReadonlyArray, ): ReadonlyArray { let changed = false; const shown = entries.flatMap((entry) => { const edits = editsOf(entry); - const next = editPullRequestListEntries(input, [entry], edits); + const next = editPullRequestListEntries(input, [entry], edits, pending); if (next[0] !== entry) changed = true; return next; }); return changed ? shown : entries; } +export function heldPullRequestListEntriesAtom( + environmentId: EnvironmentId, + input: PullRequestListInput, + entries: ReadonlyArray, +) { + return actionPatchedQuery(() => Atom.make(AsyncResult.success(entries)), { + label: "pull-requests:held-list-entries", + concerns: (_input: PullRequestListInput, reference) => + entries.some((entry) => samePullRequest(entry, reference)), + edit: editPullRequestListEntries, + patch: patchPullRequestListEntries, + })({ environmentId, input }); +} + function patchListWithReply( input: PullRequestListInput, value: PullRequestListResult, @@ -1123,6 +1138,20 @@ export function createPullRequestEnvironmentAtoms( ); } }); + const acceptEdit = ( + registry: AtomRegistry.AtomRegistry, + environmentId: EnvironmentId, + edit: PullRequestPendingEdit | null, + readsAfterWrite = false, + ) => + Effect.sync(() => settleEdit(registry, environmentId, edit, readsAfterWrite)).pipe( + Effect.andThen(() => + edit === null + ? Effect.void + : (onAnswer.acceptedEdit?.({ environmentId, input: edit.reference }, edit, registry) ?? + Effect.void), + ), + ); const listLabel = "environment-data:pull-requests:list"; const listPersistence = persistQuery(PullRequestListResult); @@ -1294,10 +1323,9 @@ export function createPullRequestEnvironmentAtoms( ).pipe( // The re-read a bare reply starts would otherwise show the old state until it answers. Effect.andThen( - Effect.sync(() => { - if (reply === undefined) - settleEdit(registry, environmentId, actionEdit(input), true); - }), + reply === undefined + ? acceptEdit(registry, environmentId, actionEdit(input), true) + : Effect.void, ), ), scheduler: commandScheduler, @@ -1310,16 +1338,8 @@ export function createPullRequestEnvironmentAtoms( label: "environment-data:pull-requests:update", tag: WS_METHODS.pullRequestsUpdate, execute: (input) => routedRequest(WS_METHODS.pullRequestsUpdate, input), - onSuccess: (target, registry) => { - const edit = updateEdit(target.input); - return Effect.sync(() => settleEdit(registry, target.environmentId, edit)).pipe( - Effect.andThen(() => - edit === null - ? Effect.void - : (onAnswer.acceptedEdit?.(target, edit, registry) ?? Effect.void), - ), - ); - }, + onSuccess: (target, registry) => + acceptEdit(registry, target.environmentId, updateEdit(target.input)), scheduler: commandScheduler, concurrency: serialPerEnvironment, }), @@ -1468,9 +1488,7 @@ export function createPullRequestEnvironmentAtoms( scheduler: commandScheduler, concurrency: serialPerEnvironment, onSuccess: (target, registry) => - Effect.sync(() => - settleEdit(registry, target.environmentId, labelEdit(registry, target)), - ), + acceptEdit(registry, target.environmentId, labelEdit(registry, target)), }), labelEdit, ), From 49ae4f691f51254cdb4407772ee6789b837c931b Mon Sep 17 00:00:00 2001 From: Shivam Sharma <91240327+shivamhwp@users.noreply.github.com> Date: Sat, 14 Nov 2026 14:19:21 +0530 Subject: [PATCH 10/11] fix(pr): the PR page loads again, and a pending title shows over a stored snapshot Co-Authored-By: Claude Opus 5.5 --- .../pullRequest/usePullRequestDetail.ts | 5 +++ apps/web/src/state/pullRequests.test.ts | 8 +++-- apps/web/src/state/pullRequests.ts | 33 +++++++++++++------ 3 files changed, 34 insertions(+), 12 deletions(-) diff --git a/apps/web/src/components/pullRequest/usePullRequestDetail.ts b/apps/web/src/components/pullRequest/usePullRequestDetail.ts index e9052ae190a45..a7b28a21b2337 100644 --- a/apps/web/src/components/pullRequest/usePullRequestDetail.ts +++ b/apps/web/src/components/pullRequest/usePullRequestDetail.ts @@ -1,4 +1,6 @@ +import { useAtomValue } from "@effect/atom-react"; import { resolvePullRequestDetailChecks } from "@t3tools/client-runtime/pull-request-checks"; +import { pullRequestPendingEditsFor } from "@t3tools/client-runtime/state/pull-requests"; import { AuthSourceControlWriteScope, type EnvironmentId, @@ -106,6 +108,7 @@ export function usePullRequestDetail( setCachedDetail(detailQuery.data); } const observedSummary = useSharedPullRequestSummary(environmentId, reference); + const pendingEdits = useAtomValue(pullRequestPendingEditsFor(environmentId, reference)); const activity = activityQuery.data; const resolvedCoreDetail = resolveDisplayedPullRequestDetail({ live: liveDetail, @@ -120,6 +123,8 @@ export function usePullRequestDetail( resolvedCoreDetail, liveDetail === null, newestPullRequestSummary(listSummary, observedSummary), + reference, + pendingEdits, ); const coreDetail = resolvedCoreDetail === null || sharedSummary === null || sharedSummary === resolvedCoreDetail diff --git a/apps/web/src/state/pullRequests.test.ts b/apps/web/src/state/pullRequests.test.ts index b6b7d60b34dcf..a39fc5f7a5d00 100644 --- a/apps/web/src/state/pullRequests.test.ts +++ b/apps/web/src/state/pullRequests.test.ts @@ -132,8 +132,12 @@ describe("pull request summary cache", () => { const edited = summary({ title: "Accepted title" }); expect(newestPullRequestSummary(summary(), edited)).toBe(edited); const loaded = summary(); - expect(newestDisplayedPullRequestSummary(loaded, false, edited)).toBe(loaded); - expect(newestDisplayedPullRequestSummary(summary(), true, edited)).toBe(edited); + expect(newestDisplayedPullRequestSummary(loaded, false, edited, loaded, [])).toBe(loaded); + expect(newestDisplayedPullRequestSummary(summary(), true, edited, loaded, [])).toBe(edited); + const titleEdit = { reference: loaded, title: "Pending title" }; + expect(newestDisplayedPullRequestSummary(loaded, true, null, loaded, [titleEdit])?.title).toBe( + "Pending title", + ); }); it("reuses saved thread state while detail is stale and lets newer detail replace it", () => { diff --git a/apps/web/src/state/pullRequests.ts b/apps/web/src/state/pullRequests.ts index 895964beba058..267dcb42e03df 100644 --- a/apps/web/src/state/pullRequests.ts +++ b/apps/web/src/state/pullRequests.ts @@ -7,6 +7,7 @@ import { createPullRequestStackAtomFamily, pullRequestPendingEditsFor, pullRequestHostAnswer, + type PullRequestPendingEdit, } from "@t3tools/client-runtime/state/pull-requests"; import { PullRequestListResult, @@ -76,10 +77,17 @@ export function newestDisplayedPullRequestSummary( detail: PullRequestSummary | null, fromSnapshot: boolean, shared: PullRequestSummary | null, + reference: PullRequestRef, + edits: ReadonlyArray, ): PullRequestSummary | null { - return fromSnapshot - ? newestPullRequestSummary(detail, shared) - : newestPullRequestSummary(shared, detail); + // With no shared summary the snapshot is all there is, and no answer applied its edits yet. + return applyPullRequestSummaryEdits( + reference, + fromSnapshot + ? newestPullRequestSummary(detail, shared) + : newestPullRequestSummary(shared, detail), + edits, + ); } export function pullRequestListEntryToSummary(entry: PullRequestListEntry): PullRequestSummary { @@ -702,21 +710,26 @@ export interface MergedPullRequestListView { readonly refresh: (targets?: ReadonlyArray>) => void; } +// Merge inside each hook: the React Compiler memoizes it on `query.values` only there, and +// PullRequestsPage sets state when the merged list's identity changes. export function usePullRequestList( targets: ReadonlyArray>, ): MergedPullRequestListView { - return mergedPullRequestListView(usePullRequestListsQuery(targets)); + const query = usePullRequestListsQuery(targets); + const data = mergePullRequestLists(query.values); + return { + data, + error: query.error, + isPending: query.isPending, + observations: query.observations, + refresh: query.refresh, + }; } export function usePullRequestHostList( targets: ReadonlyArray>, ): MergedPullRequestListView { - return mergedPullRequestListView(usePullRequestHostListsQuery(targets)); -} - -function mergedPullRequestListView( - query: ReturnType, -): MergedPullRequestListView { + const query = usePullRequestHostListsQuery(targets); const data = mergePullRequestLists(query.values); return { data, From 69dfacf9376b8375e22cd681993f8c880e90d9e1 Mon Sep 17 00:00:00 2001 From: Shivam Sharma <91240327+shivamhwp@users.noreply.github.com> Date: Sun, 15 Nov 2026 10:46:52 +0530 Subject: [PATCH 11/11] fix(pr): a closed pull request no longer flashes open after the close lands The panel takes its state from the newer of detail and checks. Checks did not apply pending edits or action replies, so once a close settled its older "open" answer won for about half a second. Checks now go through the same overlay as the other readers. Moved here from #32842. Co-Authored-By: Claude Opus 5.5 --- .../src/state/pullRequests.test.ts | 47 +++++++++++++++++++ .../client-runtime/src/state/pullRequests.ts | 44 ++++++++++++----- 2 files changed, 80 insertions(+), 11 deletions(-) diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index 63bdb37df2b10..4788e56f8b849 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -2883,3 +2883,50 @@ it.effect.each(["loaded", "loading"] as const)( }), ), ); + +it.effect.each(["accepted", "refused"] as const)( + "shows a close in the checks read the panel takes its state from (%s)", + (outcome) => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + let reads = 0; + const client = actionReplyClient({ + [WS_METHODS.pullRequestsChecks]: () => + reads++ === 0 + ? Effect.succeed({ state: "open", checks: [], observedAt: 100 }) + : Effect.never, + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + if (outcome === "accepted") return { ...actionReply, state: "closed" as const }; + return yield* new PullRequestOperationError({ + operation: "runAction", + detail: "You cannot close this pull request.", + }); + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const checks = atoms.checks(target); + registry.mount(checks); + yield* Effect.promise(() => executeAtomQuery(registry, checks)); + const state = () => Option.getOrThrow(AsyncResult.value(registry.get(checks)))?.state; + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "close" }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(state()).toBe("closed"); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(acting); + // An accepted close stays while the next checks read is still out. + expect(state()).toBe(outcome === "accepted" ? "closed" : "open"); + }), + ), +); diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index 72b0dc4aa96d3..623ced4fc4f5b 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -1139,6 +1139,38 @@ export function createPullRequestEnvironmentAtoms( ); } }); + const checksLabel = "environment-data:pull-requests:checks"; + const checksPersistence = persistQuery(Schema.NullOr(PullRequestChecks)); + // Panels take the state from the newest of detail and checks, so checks show writes too. + const checks = normalizePullRequestQuery( + actionPatchedQuery( + createEnvironmentRpcQueryAtomFamily(runtime, { + label: checksLabel, + persistence: checksPersistence, + tag: WS_METHODS.pullRequestsChecks, + execute: (input) => routedRequest(WS_METHODS.pullRequestsChecks, input), + staleTimeMs: 45_000, + refreshTrigger: ({ environmentId }) => refreshes({ environmentId, input: {} }), + ...(onAnswer.checks === undefined ? {} : { onAnswer: onAnswer.checks }), + }), + { + label: checksLabel, + persistence: checksPersistence, + onAnswer: onAnswer.checks, + concerns: samePullRequest, + patch: (_input, value, _reference, reply) => + value === null || value.state === reply.state || isStalePullRequestReply(value, reply) + ? value + : { ...value, state: reply.state }, + edit: (_input, value, edits) => { + const state = edits.findLast((edit) => edit.state !== undefined)?.state; + return value === null || state === undefined || value.state === state + ? value + : { ...value, state }; + }, + }, + ), + ); const acceptEdit = ( registry: AtomRegistry.AtomRegistry, environmentId: EnvironmentId, @@ -1225,17 +1257,7 @@ export function createPullRequestEnvironmentAtoms( detailReadVersion, preview, previewCard, - checks: normalizePullRequestQuery( - createEnvironmentRpcQueryAtomFamily(runtime, { - label: "environment-data:pull-requests:checks", - persistence: persistQuery(Schema.NullOr(PullRequestChecks)), - tag: WS_METHODS.pullRequestsChecks, - execute: (input) => routedRequest(WS_METHODS.pullRequestsChecks, input), - staleTimeMs: 45_000, - refreshTrigger: ({ environmentId }) => refreshes({ environmentId, input: {} }), - ...(onAnswer.checks === undefined ? {} : { onAnswer: onAnswer.checks }), - }), - ), + checks, activity, threadComments: createEnvironmentRpcCommand(runtime, { label: "environment-data:pull-requests:thread-comments",