@devries-cameron20 / t3code Mirror · read-only / commits / f84ad6f30b
Fork 0

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 +};