fix(desktop): preserve snapshot delivery and image coordinates

Author: juliusmarminge

apps/desktop/src/snapShot/DesktopSnapShot.test.ts

@@ -554,6 +554,7 @@ function concurrentCaptureFixture(platform: NodeJS.Platform, animations: boolean
   const images = new Map<string, Uint8Array>();
   const metadata = new Map<string, string>();
   const readyIds: string[] = [];
+  const requestedIds: string[] = [];
   const bounds = { x: 10, y: 20, width: 800, height: 600 };
   const takeSnapshot = async () => {
     const index = state.snapshots++;
@@ -665,6 +666,12 @@ function concurrentCaptureFixture(platform: NodeJS.Platform, animations: boolean
           state.preparedWithoutOverlay &&= flashWindows.every((window) => window.destroyed);
         }),
         dispatchMenuAction: (action: string, options?: { readonly reveal?: boolean }) => {
+          if (action.startsWith("snap-shot-requested:")) {
+            return Effect.sync(() => {
+              assert.isFalse(options?.reveal);
+              requestedIds.push(action.slice("snap-shot-requested:".length));
+            });
+          }
           if (!action.startsWith("snap-shot-started:")) return Effect.void;
           if (state.failNextReveal && options?.reveal !== false) {
             state.failNextReveal = false;
@@ -684,6 +691,7 @@ function concurrentCaptureFixture(platform: NodeJS.Platform, animations: boolean
     second: second!,
     state,
     readyIds,
+    requestedIds,
     layer,
     settings: {
       ...DEFAULT_CLIENT_SETTINGS,
@@ -1100,10 +1108,13 @@ it.effect.each([
       Effect.gen(function* () {
         const service = yield* DesktopSnapShot.make;
         yield* service.configure(fixture.settings);
-        fixture.first.pixels.resolve();
         const first = yield* Effect.promise(fixture.trigger).pipe(
           Effect.forkChild({ startImmediately: true }),
         );
+        yield* Effect.promise(() => fixture.first.started.promise);
+        assert.lengthOf(fixture.requestedIds, 1);
+        assert.lengthOf(fixture.readyIds, 0);
+        fixture.first.pixels.resolve();
         yield* Effect.promise(() => fixture.first.handoff.promise);
         assert.lengthOf(fixture.readyIds, 0);
 
@@ -1128,6 +1139,7 @@ it.effect.each([
         yield* Fiber.join(first);
         assert.lengthOf(fixture.readyIds, 2);
         assert.equal(new Set(fixture.readyIds).size, 2);
+        assert.deepEqual(fixture.readyIds, fixture.requestedIds.toReversed());
         const newer = yield* service.read(fixture.readyIds[0]!);
         const older = yield* service.read(fixture.readyIds[1]!);
         assert.equal(newer.source.windowTitle, fixture.second.title);

apps/desktop/src/snapShot/DesktopSnapShot.ts

@@ -831,8 +831,16 @@ export const make = Effect.gen(function* () {
   const notifyFailure = desktopWindow
     .dispatchMenuAction(CAPTURE_FAILED_ACTION)
     .pipe(Effect.catch(() => Effect.void));
-  const setFailure = (message: string) =>
-    Ref.update(stateRef, (state) => ({ ...state, message })).pipe(Effect.andThen(notifyFailure));
+  const setFailure = (message: string, captureId?: string) =>
+    Ref.update(stateRef, (state) => ({ ...state, message })).pipe(
+      Effect.andThen(
+        captureId
+          ? desktopWindow
+              .dispatchMenuAction(`${CAPTURE_FAILED_ACTION}:${captureId}`)
+              .pipe(Effect.catch(() => Effect.void))
+          : notifyFailure,
+      ),
+    );
   const setShortcutFailure = (shortcutMessage: string) =>
     Effect.sync(() => {
       shortcutVerified = false;
@@ -876,6 +884,9 @@ export const make = Effect.gen(function* () {
       flash.dispose();
       transition.dispose();
       yield* fileSystem.makeDirectory(captureDirectory, { recursive: true });
+      yield* desktopWindow
+        .dispatchMenuAction(`snap-shot-requested:${id}`, { reveal: false })
+        .pipe(Effect.catch(() => Effect.void));
       const snapshot = yield* Effect.tryPromise({
         try: () =>
           captureSource({
@@ -977,7 +988,7 @@ export const make = Effect.gen(function* () {
     const prepared = yield* prepareCapture(settings, target).pipe(
       Effect.tapError((error) =>
         (error.captureId ? discardCapture(error.captureId) : Effect.void).pipe(
-          Effect.andThen(setFailure(error.message)),
+          Effect.andThen(setFailure(error.message, error.captureId)),
         ),
       ),
       snapshotMutex.withPermitsIfAvailable(1),

apps/web/src/components/chat/ChatComposer.tsx

@@ -215,6 +215,7 @@ import {
   shouldAnimateSnapShotArrival,
   subscribeToPendingSnapShotAnimations,
 } from "../../lib/snapShotAnimation";
+import { resizeSnapShotSource } from "../../lib/snapShotSource";
 import { basenameOfPath } from "../../pierre-icons";
 import { cn, randomUUID } from "~/lib/utils";
 import {
@@ -3675,7 +3676,9 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
           mimeType: result.image.mimeType,
           sizeBytes: result.image.sizeBytes,
           dataUrl: result.image.dataUrl,
-          ...(image.source ? { source: image.source } : {}),
+          ...(image.source
+            ? { source: resizeSnapShotSource(image.source, result.image.imageSize) }
+            : {}),
         });
       }
       const { kept, droppedNames } = partitionStashAttachments(candidateAttachments);

apps/web/src/components/desktop/SnapShotCoordinator.test.ts

@@ -15,18 +15,38 @@ import {
   dismissFailedSnapShot,
   resolveExistingSnapShotTarget,
   resolveSnapShotTargetOnce,
+  resolveSnapShotDeliveryTarget,
 } from "./SnapShotCoordinator";
 import {
   beginSnapShotAnimation,
   dismissAllSnapShotAnimations,
   getPendingSnapShotAnimations,
   setSnapShotAnimationDestination,
+  scheduleSnapShotAnimationDestination,
 } from "../../lib/snapShotAnimation";
 
+const storage = vi.hoisted(() => {
+  const values = new Map<string, string>();
+  const storage = {
+    getItem: (key: string) => values.get(key) ?? null,
+    setItem: vi.fn((key: string, value: string) => {
+      values.set(key, value);
+    }),
+    removeItem: (key: string) => {
+      values.delete(key);
+    },
+    clear: () => values.clear(),
+  };
+  vi.stubGlobal("localStorage", storage);
+  return storage;
+});
+
 const environmentId = EnvironmentId.make("snap-shot-environment");
 const projectRef = scopeProjectRef(environmentId, ProjectId.make("snap-shot-project"));
 
 beforeEach(() => {
+  storage.clear();
+  vi.stubGlobal("localStorage", storage);
   useComposerDraftStore.setState({
     draftsByThreadKey: {},
     draftThreadsByThreadKey: {},
@@ -49,6 +69,7 @@ describe("window capture failures", () => {
     const soundedIds = new Set(["older", "newer"]);
     const dismissSnapShotAnimation = vi.fn(async () => undefined);
     vi.stubGlobal("window", {
+      localStorage: storage,
       desktopBridge: {
         requestSnapShotPermissions: vi.fn(),
         getSnapShotState: vi.fn(),
@@ -170,6 +191,7 @@ describe("window capture delivery", () => {
         },
       };
       vi.stubGlobal("window", {
+        localStorage: storage,
         desktopBridge: bridge,
         setTimeout,
         clearTimeout,
@@ -268,3 +290,93 @@ describe("window capture target resolution", () => {
     expect(resolveExistingSnapShotTarget(routeThreadRef, routeThreadRef)).toEqual(routeThreadRef);
   });
 });
+
+describe("durable snapshot delivery", () => {
+  it.each([false, true])(
+    "retains a capture on quota failure and retries without duplicates (staged: %s)",
+    async (staged) => {
+      const target = scopeThreadRef(environmentId, ThreadId.make("quota-thread"));
+      const capture = {
+        id: "12345678-1234-1234-1234-123456789abc",
+        name: "window.png",
+        mimeType: "image/png" as const,
+        sizeBytes: 3,
+        dataUrl: "data:image/png;base64,AQID",
+        source: {
+          kind: "snap-shot" as const,
+          capturedAt: "2026-09-01T00:00:00.000Z",
+          appName: "Editor",
+          windowTitle: "main.ts",
+        },
+      };
+      const acknowledgeSnapShot = vi.fn(async () => undefined);
+      const bridge = {
+        readSnapShot: async () => capture,
+        acknowledgeSnapShot,
+      } as unknown as DesktopSnapShotBridge;
+      vi.stubGlobal("window", { localStorage: storage, dispatchEvent: vi.fn() });
+      const write = storage.setItem.getMockImplementation()!;
+      storage.setItem.mockImplementation(() => {
+        throw new Error("QuotaExceededError");
+      });
+      try {
+        if (staged) {
+          const store = useComposerDraftStore.getState();
+          store.addImage(target, {
+            type: "image",
+            ...capture,
+            previewUrl: capture.dataUrl,
+            file: new File([new Uint8Array([1, 2, 3])], capture.name, { type: capture.mimeType }),
+          });
+          void store.syncPersistedAttachments(target, [capture]);
+        }
+        await expect(deliverSnapShot(bridge, capture, target)).rejects.toThrow(
+          "could not be saved",
+        );
+        expect(acknowledgeSnapShot).not.toHaveBeenCalled();
+        expect(
+          useComposerDraftStore.getState().getComposerDraft(target)?.nonPersistedImageIds,
+        ).toContain(capture.id);
+        storage.setItem.mockImplementation(write);
+        await deliverSnapShot(bridge, capture, target);
+        expect(acknowledgeSnapShot).toHaveBeenCalledExactlyOnceWith(capture.id);
+        expect(useComposerDraftStore.getState().getComposerDraft(target)?.images).toHaveLength(1);
+        expect(
+          useComposerDraftStore.getState().getComposerDraft(target)?.persistedAttachments,
+        ).toHaveLength(1);
+      } finally {
+        storage.setItem.mockImplementation(write);
+      }
+    },
+  );
+});
+
+describe("snapshot destination ownership", () => {
+  it.each(["unmount", "blur", "disabled animations"])(
+    "keeps the original environment and thread after %s",
+    async (reason) => {
+      const original = scopeThreadRef(environmentId, ThreadId.make("original"));
+      const next = scopeThreadRef(EnvironmentId.make("another-environment"), ThreadId.make("next"));
+      const targets = new Map<string, Promise<typeof original | null>>();
+      let current = original;
+      const resolveTarget = async () => current;
+      const requested = resolveSnapShotDeliveryTarget(targets, "capture", resolveTarget);
+      if (reason !== "disabled animations") {
+        beginSnapShotAnimation("capture", original);
+        if (reason === "unmount") {
+          const unmount = scheduleSnapShotAnimationDestination("capture", () => undefined);
+          unmount();
+        } else dismissAllSnapShotAnimations();
+      }
+      current = next;
+      await requested;
+      expect(getPendingSnapShotAnimations()).toHaveLength(0);
+      expect(await resolveSnapShotDeliveryTarget(targets, "capture", resolveTarget)).toEqual(
+        original,
+      );
+      expect(await resolveSnapShotDeliveryTarget(targets, "later-capture", resolveTarget)).toEqual(
+        next,
+      );
+    },
+  );
+});