Skip to content

Commit 8ff9ae1

Browse files
fix(mobile): delivered messages no longer reappear at the bottom of long threads (#26739)
Co-authored-by: Claude Opus 5.5 <[email protected]>
1 parent a5448f4 commit 8ff9ae1

17 files changed

Lines changed: 176 additions & 60 deletions

‎apps/mobile/src/features/threads/pending-thread-feed.test.ts‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -114,14 +114,17 @@ describe("pending timeline messages", () => {
114114
expect(appendPendingThreadMessages([], [delivered], [queued])).toEqual([]);
115115
});
116116

117-
it("stops showing an acknowledged message once the projection holds it, even when the feed hides it", () => {
117+
it("stops showing an acknowledged message once the thread catches up, even when the feed hides it", () => {
118118
// A rolled-back or cancelled queued run keeps its message in projection.messages
119119
// while its user_message item leaves the visible feed.
120120
const echoed = pending("rolled-back");
121-
const waiting = pending("waiting");
122-
const shown = selectPendingAcknowledgedMessages([echoed, waiting], {
121+
// A bounded projection pages an applied message out; it must not come back as pending.
122+
const pagedOut = { ...pending("paged-out"), sequence: 40 };
123+
const waiting = { ...pending("waiting"), sequence: 50 };
124+
const shown = selectPendingAcknowledgedMessages([echoed, pagedOut, waiting], {
123125
threadKey: "env:thread",
124126
queuedMessages: [],
127+
sequence: 45,
125128
projectedMessages: [{ id: echoed.messageId }],
126129
});
127130
expect(shown).toEqual([waiting]);

‎apps/mobile/src/features/threads/pending-thread-feed.ts‎

Lines changed: 13 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,11 @@ import {
55
} from "@t3tools/contracts";
66
import type { ThreadFeedEntry } from "../../lib/threadActivity";
77
import { scopedThreadKey } from "../../lib/scopedEntities";
8-
import type { QueuedThreadMessage } from "../../state/thread-outbox-model";
8+
import { threadHasCaughtUpTo } from "@t3tools/client-runtime/state/threads";
9+
import type {
10+
AcknowledgedThreadMessage,
11+
QueuedThreadMessage,
12+
} from "../../state/thread-outbox-model";
913

1014
/**
1115
* A guest's message waiting for the owner's Send or Dismiss. It is a feed row, not the list
@@ -24,21 +28,25 @@ export type PendingThreadFeedEntry = ThreadFeedEntry & {
2428
readonly acknowledged?: boolean;
2529
};
2630

27-
// An acknowledged row stops being pending once the projection holds its message,
31+
// An acknowledged row stops being pending once the thread catches up to it,
2832
// even when the feed hides that message (a rolled-back or cancelled run).
2933
export function selectPendingAcknowledgedMessages(
30-
acknowledged: ReadonlyArray<QueuedThreadMessage>,
34+
acknowledged: ReadonlyArray<AcknowledgedThreadMessage>,
3135
thread: {
3236
readonly threadKey: string | null;
3337
readonly queuedMessages: ReadonlyArray<QueuedThreadMessage>;
38+
readonly sequence: number;
3439
readonly projectedMessages: ReadonlyArray<{ readonly id: string }> | undefined;
3540
},
36-
): ReadonlyArray<QueuedThreadMessage> {
41+
): ReadonlyArray<AcknowledgedThreadMessage> {
3742
return acknowledged.filter(
3843
(message) =>
3944
scopedThreadKey(message.environmentId, message.threadId) === thread.threadKey &&
4045
!thread.queuedMessages.some((queued) => queued.messageId === message.messageId) &&
41-
!thread.projectedMessages?.some((projected) => projected.id === message.messageId),
46+
!threadHasCaughtUpTo(message, {
47+
sequence: thread.sequence,
48+
messages: thread.projectedMessages,
49+
}),
4250
);
4351
}
4452

‎apps/mobile/src/state/acknowledged-thread-messages.ts‎

Lines changed: 20 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,31 +1,39 @@
11
import * as Option from "effect/Option";
22
import { Atom } from "effect/reactivity";
33
import { appAtomRegistry } from "./atom-registry";
4-
import type { QueuedThreadMessage } from "./thread-outbox-model";
4+
import { threadHasCaughtUpTo } from "@t3tools/client-runtime/state/threads";
5+
import type { AcknowledgedThreadMessage, QueuedThreadMessage } from "./thread-outbox-model";
56
import { environmentThreadDetails } from "./threads";
67

7-
// Keep acknowledged rows until their subscribed projection arrives; command receipts can precede messages.
8-
// Render hides rows the projection has echoed, so dropping them here only frees memory.
9-
export const acknowledgedThreadMessagesAtom = Atom.make<ReadonlyArray<QueuedThreadMessage>>(
8+
// Keep acknowledged rows until the thread catches up; command receipts can precede messages.
9+
export const acknowledgedThreadMessagesAtom = Atom.make<ReadonlyArray<AcknowledgedThreadMessage>>(
1010
[],
1111
).pipe(Atom.keepAlive);
1212

1313
// Peeks at a thread only when something already has it in the registry: reading
1414
// it through the registry would open a snapshot load and a live stream of its own.
15-
function isEchoedInMountedThread(message: QueuedThreadMessage): boolean {
16-
const threadAtom = environmentThreadDetails.threadAtom({
15+
function isEchoedInMountedThread(message: AcknowledgedThreadMessage): boolean {
16+
const stateAtom = environmentThreadDetails.stateAtom({
1717
environmentId: message.environmentId,
1818
threadId: message.threadId,
1919
});
20-
const node = appAtomRegistry.getNodes().get(threadAtom);
20+
const node = appAtomRegistry.getNodes().get(stateAtom);
2121
if (node === undefined) return false;
22-
const loaded: Option.Option<Atom.Type<typeof threadAtom>> = node.valueOption();
23-
const thread = Option.getOrNull(loaded);
24-
return thread?.projection.messages.some((entry) => entry.id === message.messageId) ?? false;
22+
const loaded: Option.Option<Atom.Type<typeof stateAtom>> = node.valueOption();
23+
return Option.match(loaded, {
24+
onNone: () => false,
25+
onSome: (thread) =>
26+
threadHasCaughtUpTo(message, {
27+
sequence: thread.sequence,
28+
messages: Option.getOrUndefined(thread.data)?.messages,
29+
}),
30+
});
2531
}
2632

2733
function writeAcknowledgedThreadMessages(
28-
update: (current: ReadonlyArray<QueuedThreadMessage>) => ReadonlyArray<QueuedThreadMessage>,
34+
update: (
35+
current: ReadonlyArray<AcknowledgedThreadMessage>,
36+
) => ReadonlyArray<AcknowledgedThreadMessage>,
2937
) {
3038
const current = appAtomRegistry.get(acknowledgedThreadMessagesAtom);
3139
const next = update(current).filter((entry) => !isEchoedInMountedThread(entry));
@@ -35,7 +43,7 @@ function writeAcknowledgedThreadMessages(
3543
appAtomRegistry.set(acknowledgedThreadMessagesAtom, next);
3644
}
3745

38-
export function retainAcknowledgedThreadMessage(message: QueuedThreadMessage) {
46+
export function retainAcknowledgedThreadMessage(message: AcknowledgedThreadMessage) {
3947
writeAcknowledgedThreadMessages((current) =>
4048
current.some((entry) => entry.messageId === message.messageId)
4149
? current

‎apps/mobile/src/state/thread-outbox-model.ts‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -287,3 +287,8 @@ export function resolveThreadOutboxFailureAction(input: {
287287
}
288288
return "restore";
289289
}
290+
291+
export type AcknowledgedThreadMessage = QueuedThreadMessage & {
292+
/** The server sequence that committed the message; older servers do not report it. */
293+
readonly sequence?: number;
294+
};

‎apps/mobile/src/state/thread-task-permissions.test.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -113,6 +113,7 @@ vi.mock("./threads", async () => {
113113
environmentThreadDetails: {
114114
queueWorkflowAtom: () => Atom.make(null),
115115
checkpointSummariesAtom: () => Atom.make([]),
116+
sequenceAtom: () => Atom.make(0),
116117
pendingRequestsAtom: () => Atom.make(state.pendingRequests),
117118
},
118119
threadEnvironment: {

‎apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -100,7 +100,7 @@ vi.mock("./threads", async () => {
100100
familyAtom: () => Atom.make(AsyncResult.success({})),
101101
refresh: vi.fn(),
102102
},
103-
environmentThreadDetails: { threadAtom: () => Atom.make(null) },
103+
environmentThreadDetails: { stateAtom: () => Atom.make(null) },
104104
};
105105
});
106106
vi.mock("./git", () => ({ gitEnvironment: { preparePullRequestThread: state.checkout } }));
@@ -224,6 +224,7 @@ beforeEach(() => {
224224
]) {
225225
command.mockReset().mockResolvedValue(AsyncResult.success(undefined));
226226
}
227+
state.start.mockResolvedValue(AsyncResult.success({}));
227228
state.prepare.mockReset().mockImplementation(async ({ attachments }) => ({
228229
status: "ready",
229230
attachments: [],
@@ -427,7 +428,8 @@ describe("queued task operation access", () => {
427428
);
428429
await state.manager.enqueue(queued);
429430
const started = Promise.withResolvers<void>();
430-
const delivery = Promise.withResolvers<AsyncResult.AsyncResult<void, Error>>();
431+
const delivery =
432+
Promise.withResolvers<AsyncResult.AsyncResult<{ readonly sequence?: number }, Error>>();
431433
state.start.mockImplementationOnce(() => {
432434
started.resolve();
433435
return delivery.promise;
@@ -437,7 +439,7 @@ describe("queued task operation access", () => {
437439
setOperateGrant("secondary", false);
438440
delivery.resolve(
439441
accepted
440-
? AsyncResult.success(undefined)
442+
? AsyncResult.success({})
441443
: AsyncResult.failure(Cause.fail(new Error("This connection cannot control this task."))),
442444
);
443445
await drained;

‎apps/mobile/src/state/threadOutboxDelivery.test.ts‎

Lines changed: 47 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,12 @@ import type { PreparedTurnAttachments } from "../lib/attachmentUpload";
1313

1414
const harness = vi.hoisted(() => ({
1515
canOperate: true,
16-
threadProjection: null as unknown as import("effect/reactivity").Atom.Writable<{
17-
readonly projection: { readonly messages: ReadonlyArray<{ readonly id: string }> };
18-
} | null>,
16+
threadState: null as unknown as import("effect/reactivity").Atom.Writable<{
17+
readonly data: import("effect/Option").Option<{
18+
readonly messages: ReadonlyArray<{ readonly id: string }>;
19+
}>;
20+
readonly sequence: number;
21+
}>,
1922
manager: null as unknown as ReturnType<
2023
typeof import("./thread-outbox-manager").createThreadOutboxManager
2124
>,
@@ -92,12 +95,14 @@ vi.mock("./git", () => ({ gitEnvironment: {} }));
9295

9396
vi.mock("./threads", async () => {
9497
const { Atom } = await import("effect/reactivity");
95-
harness.threadProjection = Atom.make<{
96-
readonly projection: { readonly messages: ReadonlyArray<{ readonly id: string }> };
97-
} | null>(null).pipe(Atom.keepAlive);
98+
const Option = await import("effect/Option");
99+
harness.threadState = Atom.make({
100+
data: Option.none<{ readonly messages: ReadonlyArray<{ readonly id: string }> }>(),
101+
sequence: 0,
102+
}).pipe(Atom.keepAlive);
98103
return {
99104
threadEnvironment: {},
100-
environmentThreadDetails: { threadAtom: () => harness.threadProjection },
105+
environmentThreadDetails: { stateAtom: () => harness.threadState },
101106
};
102107
});
103108

@@ -138,6 +143,7 @@ vi.mock("./thread-outbox", async () => {
138143
};
139144
});
140145

146+
import * as Option from "effect/Option";
141147
import { appAtomRegistry } from "./atom-registry";
142148
import { pendingThreadCreationOutcomesAtom } from "./pending-thread-creation";
143149
import { clearThreadComposerError, threadComposerErrorsAtom } from "./thread-composer-error";
@@ -204,7 +210,7 @@ function remainingMessages(): ReadonlyArray<QueuedThreadMessage> {
204210

205211
beforeEach(() => {
206212
appAtomRegistry.set(acknowledgedThreadMessagesAtom, []);
207-
appAtomRegistry.set(harness.threadProjection, null);
213+
appAtomRegistry.set(harness.threadState, { data: Option.none(), sequence: 0 });
208214
harness.canOperate = true;
209215
harness.draftFile.setDocument({ schemaVersion: 1, drafts: {} });
210216
});
@@ -330,26 +336,32 @@ describe("thread outbox attachment preparation", () => {
330336
});
331337

332338
describe("thread outbox drain delivery cleanup", () => {
333-
it("drops echoed acknowledged rows at the next delivery without subscribing to the thread", async () => {
339+
it("drops caught-up acknowledged rows at the next delivery without subscribing to the thread", async () => {
334340
const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" });
335341
const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" });
336342
await harness.manager.enqueue(first);
337343
await harness.manager.enqueue(second);
338344

339345
await expect(
340-
completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId)),
346+
completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId), 7),
341347
).resolves.toBe("removed");
342-
expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([first]);
343-
344-
appAtomRegistry.set(harness.threadProjection, {
345-
projection: { messages: [{ id: "unrelated" }, { id: first.messageId }] },
348+
expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
349+
{ ...first, sequence: 7 },
350+
]);
351+
352+
// The thread applied the message, but its bounded window does not hold it.
353+
appAtomRegistry.set(harness.threadState, {
354+
data: Option.some({ messages: [{ id: "unrelated" }] }),
355+
sequence: 7,
346356
});
347-
expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([first]);
357+
expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1);
348358

349359
await expect(
350-
completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId)),
360+
completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId), 9),
351361
).resolves.toBe("removed");
352-
expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([second]);
362+
expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
363+
{ ...second, sequence: 9 },
364+
]);
353365
});
354366

355367
it("removes an acknowledged outbox item even when the sign-out archive write fails", async () => {
@@ -359,7 +371,11 @@ describe("thread outbox drain delivery cleanup", () => {
359371
harness.draftFile.setWriteError(new Error("Draft storage unavailable"));
360372

361373
await expect(
362-
completeQueuedMessageDelivery(message, harness.manager.revisionOf(message.messageId)),
374+
completeQueuedMessageDelivery(
375+
message,
376+
harness.manager.revisionOf(message.messageId),
377+
undefined,
378+
),
363379
).resolves.toBe("removed");
364380
expect(remainingMessages()).toEqual([]);
365381

@@ -390,9 +406,9 @@ describe("thread outbox drain delivery cleanup", () => {
390406
).toEqual([message]);
391407

392408
if (cleared) await harness.manager.clearEnvironment(message.environmentId);
393-
await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe(
394-
cleared ? "edited" : "removed",
395-
);
409+
await expect(
410+
completeQueuedMessageDelivery(message, deliveryRevision, undefined),
411+
).resolves.toBe(cleared ? "edited" : "removed");
396412

397413
appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, {
398414
accountId: null,
@@ -412,7 +428,9 @@ describe("thread outbox drain delivery cleanup", () => {
412428
await harness.manager.update(edited);
413429
await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]));
414430
await harness.manager.clearEnvironment(message.environmentId);
415-
await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe("edited");
431+
await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
432+
"edited",
433+
);
416434
await composerDrafts.restoreCloudComposerDrafts("account-a");
417435
expect(remainingMessages()).toEqual([edited]);
418436
});
@@ -447,7 +465,9 @@ describe("thread outbox drain delivery cleanup", () => {
447465
const edited = { ...message, text: "edited while the turn delivered" };
448466
await harness.manager.update(edited);
449467

450-
await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe("edited");
468+
await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
469+
"edited",
470+
);
451471

452472
expect(remainingMessages()).toEqual([edited]);
453473
expect(harness.removePersistedFile).not.toHaveBeenCalled();
@@ -458,7 +478,9 @@ describe("thread outbox drain delivery cleanup", () => {
458478
await harness.manager.enqueue(message);
459479
const deliveryRevision = harness.manager.revisionOf(message.messageId);
460480

461-
await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe("removed");
481+
await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
482+
"removed",
483+
);
462484

463485
expect(remainingMessages()).toEqual([]);
464486
expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]);
@@ -479,7 +501,7 @@ describe("thread outbox drain delivery cleanup", () => {
479501
await harness.manager.enqueue(message);
480502
const deliveryRevision = harness.manager.revisionOf(message.messageId);
481503

482-
const cleanup = completeQueuedMessageDelivery(message, deliveryRevision);
504+
const cleanup = completeQueuedMessageDelivery(message, deliveryRevision, undefined);
483505
await removeStarted.promise;
484506
appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
485507
removeBarrier.resolve();

‎apps/mobile/src/state/threadOutboxDelivery.ts‎

Lines changed: 20 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -250,6 +250,7 @@ function isQueuedMessagePayloadCurrent(
250250
export async function completeQueuedMessageDelivery(
251251
queuedMessage: QueuedThreadMessage,
252252
deliveryRevision: number,
253+
sequence: number | undefined,
253254
): Promise<"removed" | "edited" | "failed"> {
254255
clearThreadComposerError(
255256
scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId),
@@ -266,7 +267,9 @@ export async function completeQueuedMessageDelivery(
266267
if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
267268
return "edited";
268269
}
269-
retainAcknowledgedThreadMessage(queuedMessage);
270+
retainAcknowledgedThreadMessage(
271+
sequence === undefined ? queuedMessage : { ...queuedMessage, sequence },
272+
);
270273
const removed = await removeThreadOutboxMessage(
271274
queuedMessage,
272275
deliveryRevision,
@@ -616,6 +619,12 @@ const settledCreationOutcomeKeysAtom = Atom.make((get): ReadonlyArray<string> =>
616619
);
617620
}).pipe(Atom.withLabel("mobile:thread-outbox:settled-creation-outcomes"));
618621

622+
function deliveredSequence(
623+
result: AtomCommandResult<{ readonly sequence?: number }, unknown>,
624+
): number | undefined {
625+
return AsyncResult.isSuccess(result) ? result.value.sequence : undefined;
626+
}
627+
619628
const runDeliveryCommand = <W, A, E>(
620629
command: AtomCommand<W, A, E>,
621630
input: W,
@@ -896,7 +905,11 @@ export function createThreadOutboxDelivery(): {
896905
}
897906
acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId);
898907
const delivered =
899-
(await completeQueuedMessageDelivery(persistedMessage, deliveryRevision)) === "removed";
908+
(await completeQueuedMessageDelivery(
909+
persistedMessage,
910+
deliveryRevision,
911+
deliveredSequence(deliveryResult),
912+
)) === "removed";
900913
if (delivered) {
901914
acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId);
902915
}
@@ -1052,7 +1065,11 @@ export function createThreadOutboxDelivery(): {
10521065
return restoreQueuedMessage(persistedMessage, failure.message);
10531066
}
10541067
recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage });
1055-
const outcome = await completeQueuedMessageDelivery(persistedMessage, deliveryRevision);
1068+
const outcome = await completeQueuedMessageDelivery(
1069+
persistedMessage,
1070+
deliveryRevision,
1071+
deliveredSequence(deliveryResult),
1072+
);
10561073
if (outcome === "edited") {
10571074
if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
10581075
return true;

0 commit comments

Comments
 (0)