The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 14:45 UTC
fix(web): discarded drafts stay discarded after image compression (#36732)
Co-authored-by: Julius Marminge <julius0216@outlook.com>
Wout Stiens committed
Nov 14, 2026 at 14:10 UTC
f84ad6f30b6b9b29e772ed4ff455cf38c57c52a8
5 files changed
+252
-1
apps/web/src/components/chat/preparingComposerImages.ts
+10
@@ -81,3 +81,13 @@ export function removePreparingComposerImages(
81
});
82
return removed;
83
}
84
+
85
+/** Drops every image still preparing for the target, so its compression result is discarded. */
86
+export function cancelPreparingComposerImages(targetKey: string): void {
87
+ if (!usePreparingComposerImageStore.getState().byTargetKey[targetKey]) return;
88
+ usePreparingComposerImageStore.setState((state) => {
89
+ const byTargetKey = { ...state.byTargetKey };
90
+ delete byTargetKey[targetKey];
91
+ return { byTargetKey };
92
+ });
93
+}
apps/web/src/components/chat/useComposerAttachmentIntake.browser.test.tsx
+95
-1
@@ -1,13 +1,18 @@
1
import { useEffect } from "react";
2
-import { ThreadId } from "@t3tools/contracts";
2
+import { EnvironmentId, ProjectId, ThreadId } from "@t3tools/contracts";
3
+import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime/environment";
4
import { expect, it, vi } from "vite-plus/test";
5
+import { AsyncResult } from "effect/reactivity";
6
7
import { act, render } from "../../../test/render";
8
import {
9
type ComposerImageAttachment,
10
DraftId,
11
+ composerTargetKey,
12
useComposerDraftStore,
13
} from "../../composerDraftStore";
14
+import { showThreadUndoNotice } from "../../hooks/showThreadUndoNotice";
15
+import { discardComposerDraft } from "../../lib/discardComposerDraft";
16
import { getPreparingComposerImages } from "./preparingComposerImages";
17
import { useComposerAttachmentIntake } from "./useComposerAttachmentIntake";
18
@@ -16,6 +21,7 @@ vi.mock("../../lib/imageCompression", async (importOriginal) => ({
21
...(await importOriginal<typeof import("../../lib/imageCompression")>()),
22
prepareImageForAttachment: compression.prepare,
23
}));
24
+vi.mock("../../hooks/showThreadUndoNotice", () => ({ showThreadUndoNotice: vi.fn() }));
25
26
type IntakeInput = Parameters<typeof useComposerAttachmentIntake>[0];
27
type Intake = ReturnType<typeof useComposerAttachmentIntake>;
@@ -123,3 +129,91 @@ it("prepares a repeated paste without a tile, and still keeps a different image"
129
await act(() => different);
130
expect(composerImagesRef.current).toHaveLength(2);
131
});
132
+
133
+// The thread row's discard runs after the composer left that thread; a draft session's discard
134
+// unmounts its composer afterwards.
135
+it.each(["thread", "session"] as const)(
136
+ "a %s draft discarded while an image compresses stays discarded and can be restored",
137
+ async (kind) => {
138
+ const store = useComposerDraftStore.getState();
139
+ const environmentId = EnvironmentId.make(`intake-discard-${kind}`);
140
+ const threadId = ThreadId.make("thread");
141
+ const target =
142
+ kind === "session" ? DraftId.make("intake-discard") : scopeThreadRef(environmentId, threadId);
143
+ if (typeof target === "string") {
144
+ store.setProjectDraftThreadId(scopeProjectRef(environmentId, ProjectId.make("p")), target);
145
+ }
146
+ store.setPrompt(target, "half-written prompt");
147
+ using _draft = {
148
+ [Symbol.dispose]: () => {
149
+ if (typeof target === "string") store.clearDraftThread(target);
150
+ else store.clearComposerContent(target);
151
+ },
152
+ };
153
+ const targetKey = composerTargetKey(target);
154
+
155
+ const compressing = deferred<void>();
156
+ const resumeCompression = deferred<void>();
157
+ compression.prepare.mockReset().mockImplementation(async (file: File) => {
158
+ compressing.resolve();
159
+ await resumeCompression.promise;
160
+ return compress(file);
161
+ });
162
+
163
+ const input = {
164
+ activeThreadId: threadId,
165
+ activePendingProgress: null,
166
+ activePendingIsResponding: false,
167
+ pendingUserInputs: [],
168
+ supportsQuestionAttachments: false,
169
+ isLiteralPendingAnswer: false,
170
+ projectSelectionRequired: false,
171
+ questionAttachmentTarget: null,
172
+ attachmentTargetKey: targetKey,
173
+ fileStagingLimit: null,
174
+ promptRef: { current: "half-written prompt" },
175
+ composerImagesRef: { current: [] },
176
+ composerFilesRef: { current: [] },
177
+ composerEditorRef: { current: null },
178
+ isRevertingCheckpointRef: { current: false },
179
+ setThreadError: () => {},
180
+ countReservedAttachments: () => getPreparingComposerImages(targetKey).length,
181
+ addComposerImage: (image) => store.addImages(target, [image]),
182
+ addComposerImagesToDraft: (images) => store.addImages(target, images),
183
+ addComposerFilesToDraft: () => [],
184
+ removeComposerImageFromDraft: (id) => store.removeImage(target, id),
185
+ insertAttachmentReferences: () => false,
186
+ } satisfies IntakeInput;
187
+ let intake!: Intake;
188
+ await using screen = await render(
189
+ <Harness
190
+ input={input}
191
+ ready={(value) => {
192
+ intake = value;
193
+ }}
194
+ />,
195
+ );
196
+ const attaching = intake.addComposerAttachments([pastedImage()]);
197
+ await compressing.promise;
198
+
199
+ if (kind === "session") {
200
+ discardComposerDraft(target);
201
+ await screen.unmount();
202
+ } else {
203
+ await screen.unmount();
204
+ discardComposerDraft(target);
205
+ }
206
+ await act(async () => {
207
+ resumeCompression.resolve();
208
+ await attaching;
209
+ });
210
+
211
+ expect(getPreparingComposerImages(targetKey)).toHaveLength(0);
212
+ expect(useComposerDraftStore.getState().getComposerDraft(target)).toBeNull();
213
+ const undo = vi.mocked(showThreadUndoNotice).mock.calls.at(-1)![0].undo;
214
+ expect(AsyncResult.isSuccess(await undo())).toBe(true);
215
+ const restored = useComposerDraftStore.getState().getComposerDraft(target);
216
+ expect(restored?.prompt).toBe("half-written prompt");
217
+ expect(restored?.images).toEqual([]);
218
+ },
219
+);
apps/web/src/lib/discardComposerDraft.ts
+6
@@ -1,9 +1,11 @@
1
import * as Cause from "effect/Cause";
2
import { AsyncResult } from "effect/reactivity";
3
4
+import { cancelPreparingComposerImages } from "../components/chat/preparingComposerImages";
5
import {
6
type ComposerThreadTarget,
7
composerDraftHasUserContent,
8
+ composerTargetKey,
9
resolveComposerDraftKey,
10
useComposerDraftStore,
11
} from "../composerDraftStore";
@@ -23,6 +25,10 @@ export function discardComposerDraft(target: ComposerThreadTarget): void {
25
const discardsSession = typeof target === "string";
26
27
const claim = ThreadUndo.begin("discard", key);
28
+ // The composer may key attachments by the target or by its resolved draft id; a late
29
+ // compression under either would recreate the draft.
30
+ cancelPreparingComposerImages(composerTargetKey(target));
31
+ cancelPreparingComposerImages(key);
32
if (discardsSession) {
33
store.clearDraftThread(target);
34
} else {
scripts/scenarios/discarded-thread-draft-stays-discarded.e2e.ts
new
+38
@@ -0,0 +1,38 @@
1
+import { expect } from "e2e";
2
+
3
+import {
4
+ finishImageCompression,
5
+ holdImageCompression,
6
+ pasteWideScreenshot,
7
+} from "./image-compression-hold.ts";
8
+import { test, WEB } from "./t3.ts";
9
+
10
+test(
11
+ "A thread draft discarded while its pasted image compresses stays discarded and can be restored",
12
+ WEB,
13
+ async ({ t3, app, browser, screen }) => {
14
+ await holdImageCompression(browser);
15
+ const project = await t3.project("demo");
16
+ const source = await t3.thread({ project, title: "Screenshot work", messages: ["first"] });
17
+ await t3.thread({ project, title: "Other work", messages: ["first"] });
18
+ await t3.open(source);
19
+ await expect(screen.getByText("first fixture turn complete", { exact: false })).toBeVisible();
20
+
21
+ const composer = screen.getByRole("textbox");
22
+ await composer.fill("Half-written prompt");
23
+ await pasteWideScreenshot(browser);
24
+ // The sidebar offers a thread's discard only once that thread is no longer open.
25
+ await screen.getByRole("button", "Other work", { exact: false }).tap();
26
+ // The row's controls show on hover, over its labels.
27
+ await screen.getByRole("button", "Screenshot work", { exact: false }).hover();
28
+ await screen.getByRole("button", "Discard draft").tap();
29
+ await finishImageCompression(browser);
30
+ await app.screenshot("after-compression");
31
+ await expect(screen.getByRole("img", "Unsent draft")).toBeHidden();
32
+
33
+ await screen.getByRole("button", "undo", { exact: false }).tap();
34
+ await screen.getByRole("button", "Screenshot work", { exact: false }).tap();
35
+ await app.screenshot("after-undo");
36
+ await expect(composer).toContainText("Half-written prompt");
37
+ },
38
+);
scripts/scenarios/image-compression-hold.ts
new
+103
@@ -0,0 +1,103 @@
1
+/// <reference lib="dom" />
2
+// Holds pasted-image compression open in the page, so a scenario can act while an image is
3
+// still preparing, then tells it when every image decode, encode and read has settled.
4
+import { expect } from "e2e";
5
+import type { Browser } from "@e2e-dev/web";
6
+
7
+interface CompressionHold {
8
+ readonly release: () => void;
9
+ released: boolean;
10
+ compressionDecodes: number;
11
+ inFlight: number;
12
+}
13
+
14
+declare global {
15
+ interface Window {
16
+ compressionHold?: CompressionHold;
17
+ }
18
+}
19
+
20
+/** Installs the hold before the app loads; call before `t3.open`. */
21
+export const holdImageCompression = (browser: Browser) =>
22
+ browser.addInitScript(() => {
23
+ let release!: () => void;
24
+ const released = new Promise<void>((resolve) => {
25
+ release = resolve;
26
+ });
27
+ const hold: CompressionHold = {
28
+ release: () => {
29
+ hold.released = true;
30
+ release();
31
+ },
32
+ released: false,
33
+ compressionDecodes: 0,
34
+ inFlight: 0,
35
+ };
36
+ window.compressionHold = hold;
37
+ const track = async <T>(work: () => Promise<T>) => {
38
+ hold.inFlight++;
39
+ try {
40
+ return await work();
41
+ } finally {
42
+ hold.inFlight--;
43
+ }
44
+ };
45
+
46
+ const decode = window.createImageBitmap.bind(window);
47
+ window.createImageBitmap = ((source: ImageBitmapSource, ...rest: [ImageBitmapOptions?]) =>
48
+ track(async () => {
49
+ // Only attachment compression decodes with an orientation; placeholder thumbnails do not.
50
+ if (rest[0]?.imageOrientation === undefined) return decode(source, ...rest);
51
+ await released;
52
+ const bitmap = await decode(source, ...rest);
53
+ hold.compressionDecodes++;
54
+ return bitmap;
55
+ })) as typeof createImageBitmap;
56
+
57
+ const convertToBlob = OffscreenCanvas.prototype.convertToBlob;
58
+ OffscreenCanvas.prototype.convertToBlob = function (options) {
59
+ return track(() => convertToBlob.call(this, options));
60
+ };
61
+ const readAsDataURL = FileReader.prototype.readAsDataURL;
62
+ FileReader.prototype.readAsDataURL = function (blob) {
63
+ hold.inFlight++;
64
+ this.addEventListener("loadend", () => hold.inFlight--, { once: true });
65
+ readAsDataURL.call(this, blob);
66
+ };
67
+ });
68
+
69
+/** Pastes a PNG wider than the 2000 px attachment limit into the focused composer. */
70
+export const pasteWideScreenshot = (browser: Browser) =>
71
+ browser.evaluate(async () => {
72
+ const canvas = new OffscreenCanvas(2200, 20);
73
+ canvas.getContext("2d")!.fillRect(0, 0, 2200, 20);
74
+ const file = new File([await canvas.convertToBlob({ type: "image/png" })], "screenshot.png", {
75
+ type: "image/png",
76
+ });
77
+ const clipboardData = new DataTransfer();
78
+ clipboardData.items.add(file);
79
+ const editor = document.querySelector('[contenteditable="true"]');
80
+ if (!editor) throw new Error("No composer editor to paste into");
81
+ return editor.dispatchEvent(
82
+ new ClipboardEvent("paste", { clipboardData, bubbles: true, cancelable: true }),
83
+ );
84
+ });
85
+
86
+/**
87
+ * Lets the held compression finish and waits until it has. What follows the last tracked step
88
+ * is synchronous or microtask-only, so the app has applied the result by the next evaluate.
89
+ */
90
+export const finishImageCompression = async (browser: Browser) => {
91
+ await browser.evaluate(() => {
92
+ window.compressionHold!.release();
93
+ return null;
94
+ });
95
+ await expect
96
+ .poll(() =>
97
+ browser.evaluate(() => {
98
+ const hold = window.compressionHold!;
99
+ return hold.released && hold.compressionDecodes > 0 && hold.inFlight === 0;
100
+ }),
101
+ )
102
+ .toBe(true);
103
+};