@frockbot/plugin-fly-sprite 0.3.20 → 0.3.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-fly-sprite",
-  "version": "0.3.20",
+  "version": "0.3.22",
   "private": false,
   "type": "module",
   "exports": {
@@ -25,16 +25,16 @@
   },
   "dependencies": {
     "@cordisjs/plugin-webui": "0.8.2",
-    "@frockbot/computer-core": "0.3.20",
-    "@frockbot/computer-host-protocol": "0.3.20",
-    "@frockbot/computer-host-runtime": "0.3.20",
-    "@frockbot/kernel-contracts": "0.3.20",
-    "@frockbot/plugin-computer": "0.3.20",
+    "@frockbot/computer-core": "0.3.22",
+    "@frockbot/computer-host-protocol": "0.3.22",
+    "@frockbot/computer-host-runtime": "0.3.22",
+    "@frockbot/kernel-contracts": "0.3.22",
+    "@frockbot/plugin-computer": "0.3.22",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {
-    "@frockbot/plugin-testkit": "0.3.20",
-    "@frockbot/workspace-store": "0.3.20",
+    "@frockbot/plugin-testkit": "0.3.22",
+    "@frockbot/workspace-store": "0.3.22",
     "@types/bun": "1.4.0",
     "@types/node": "26.2.0",
     "typescript": "^7.0.2"

package/src/computer.ts

@@ -185,8 +185,16 @@ export interface FlySpriteComputerOptions {
 }
 
 export interface BrowserAction {
-  action: "snapshot" | "navigate" | "click" | "fill" | "press" | "wait";
+  action:
+    | "snapshot"
+    | "navigate"
+    | "close-origins"
+    | "click"
+    | "fill"
+    | "press"
+    | "wait";
   url?: string;
+  origins?: readonly string[];
   role?: string;
   name?: string;
   label?: string;

package/src/doctor.test.ts

@@ -22,10 +22,20 @@ function report(generation: number): string {
     generation,
     capturedAt: "2026-09-01T00:00:00Z",
     checks: [
+      {
+        name: "watchdog",
+        status: "pass",
+        detail: "recent actions: none",
+      },
+      {
+        name: "memory-top",
+        status: "pass",
+        detail: "123 2048 chromium",
+      },
       { name: "disk-root", status: "pass", detail: "12% full" },
       { name: "dns", status: "fail", detail: "no resolver" },
     ],
-    summary: "2 checks, 1 passed, 1 failed",
+    summary: "4 checks, 3 passed, 1 failed",
   })}\n`;
 }
 
@@ -52,8 +62,10 @@ describe("doctorForAgent", () => {
 
     const decoded = await bot.doctor(signal());
 
-    expect(decoded.summary).toBe("2 checks, 1 passed, 1 failed");
+    expect(decoded.summary).toBe("4 checks, 3 passed, 1 failed");
     expect(decoded.checks.map((check) => check.status)).toEqual([
+      "pass",
+      "pass",
       "pass",
       "fail",
     ]);

package/src/host-double.ts

@@ -16,12 +16,13 @@
  * `host-client.test.ts`'s subject and the workerd suite's, and repeating it
  * here would test the transport three more times and the provider none.
  */
-import type {
-  ComputerHostControlResultV1,
-  ComputerHostFileReadResultV1,
-  ComputerHostOpenResultV1,
-  ComputerHostProvisioningV1,
-  ComputerHostViewerResultV1,
+import {
+  COMPUTER_HOST_LIMITS,
+  type ComputerHostControlResultV1,
+  type ComputerHostFileReadResultV1,
+  type ComputerHostOpenResultV1,
+  type ComputerHostProvisioningV1,
+  type ComputerHostViewerResultV1,
 } from "@frockbot/computer-host-protocol";
 import { DESKTOP_GUI_LEASE_KEY } from "@frockbot/computer-host-runtime";
 import {
@@ -136,6 +137,14 @@ export class FakeComputerHost {
         options?: ComputerHostCallOptions,
       ): Promise<ComputerHostExecOutcomeV1> {
         options?.signal?.throwIfAborted();
+        // The real host's decoder refuses an oversized script, and a double
+        // that accepted one would let a suite prove a push works at a size the
+        // Computer would never have been handed.
+        if (command.script.length > COMPUTER_HOST_LIMITS.script) {
+          throw new Error(
+            `script exceeds ${COMPUTER_HOST_LIMITS.script} characters`,
+          );
+        }
         host.commands.push({
           botId,
           script: command.script,

package/src/provider.ts

@@ -109,6 +109,8 @@ function browserAction(action: ComputerBrowserAction): BrowserAction {
       return { action: "snapshot" };
     case "navigate":
       return { action: "navigate", url: action.url };
+    case "close-origins":
+      return { action: "close-origins", origins: action.origins };
     case "click":
       return {
         action: "click",
@@ -315,7 +317,7 @@ function summarize(report: WorkspaceSyncReportV1): ComputerSyncSummaryV1 {
   }
   if (failed) {
     detail.push(
-      `${report.failures.length} sync ${report.failures.length === 1 ? "operation" : "operations"} failed: ${failed.status}: ${failed.reason}.`,
+      `${report.failures.length} sync ${report.failures.length === 1 ? "operation" : "operations"} failed${failed.path ? ` at "${failed.path}"` : ""}: ${failed.status}: ${failed.reason}.`,
     );
   }
   const summary: ComputerSyncSummaryV1 = {

package/src/sync.test.ts

@@ -25,8 +25,10 @@ import {
   FlySpriteSyncSurface,
   isWorkspaceSyncIgnoredPathV1,
   WORKSPACE_SYNC_IGNORED_DIRECTORIES_V1,
+  WORKSPACE_SYNC_CHUNK_BYTES_V1,
   WORKSPACE_SYNC_MANIFEST_MAX_BYTES_V1,
   WORKSPACE_SYNC_MANIFEST_MAX_ENTRIES_V1,
+  WORKSPACE_SYNC_MAX_FILE_BYTES_V1,
   type WorkspaceSyncReportV1,
 } from "./sync.ts";
 import { WORKSPACE_EMPTY_SHA256 } from "./workspace.ts";
@@ -65,6 +67,19 @@ function sha256(bytes: Uint8Array): string {
   return createHash("sha256").update(bytes).digest("hex");
 }
 
+/**
+ * Text of an exact length whose every chunk differs from every other, so a
+ * chunk carried twice, dropped, or reordered changes the bytes rather than
+ * hiding inside a repeated pattern.
+ */
+function largeText(length: number): string {
+  let text = "";
+  for (let index = 0; text.length < length; index += 1) {
+    text += `${index}:${"abcdefghijklmnopqrstuvwxyz".repeat(3)}\n`;
+  }
+  return text.slice(0, length);
+}
+
 function quoted(shell: string, name: string): string | undefined {
   return new RegExp(`${name}='([^']*)'`).exec(shell)?.[1];
 }
@@ -95,9 +110,12 @@ class FakeSyncSprite {
   lastScanScript?: string;
   /** Drops the next sidecar write, as a pause between store and Computer does. */
   dropNextMaterialize = false;
+  /** Every script this Computer was handed, in order. */
+  readonly scripts: string[] = [];
 
   /** Runs one script for the host double. */
   readonly run = (script: string): FakeComputerRunV1 => {
+    this.scripts.push(script);
     // A paused Sprite answers nothing, and the host reports the failed exit;
     // the provider turns that into `Sprite storage operation failed: …`.
     if (this.paused) return { exitCode: 1, stderr: "Sprite is paused" };
@@ -149,6 +167,7 @@ class FakeSyncSprite {
       );
       return this.scan(root ?? "", required);
     }
+    if (shell.includes("__STAGED__")) return this.stageChunk(shell);
     if (root && relative) {
       if (shell.includes("__SYNCED__")) {
         if (this.dropNextMaterialize) {
@@ -162,7 +181,7 @@ class FakeSyncSprite {
       if (shell.includes("__FORGOTTEN__")) return this.forget(root, relative);
       if (shell.includes("__PRESERVED__"))
         return this.preserve(root, relative, shell);
-      return this.read(`${root}/${relative}`);
+      return this.readFile(`${root}/${relative}`, shell);
     }
     const note = quoted(shell, "NOTE");
     if (note) {
@@ -182,6 +201,65 @@ class FakeSyncSprite {
     return "";
   }
 
+  /**
+   * The chunked file read: a header of size and digest with the first chunk,
+   * then one chunk per further command. `head -c` and `tail -c +N` are the
+   * coreutils the sync emits; the arithmetic is theirs, not an approximation.
+   */
+  private readFile(path: string, shell: string): string {
+    const bytes = this.files.get(path);
+    const chunk = /tail -c \+(\d+) "\$FILE" \| head -c (\d+)/.exec(shell);
+    if (chunk) {
+      const offset = Number(chunk[1]) - 1;
+      const limit = Number(chunk[2]);
+      const slice = bytes?.subarray(offset, offset + limit) ?? new Uint8Array();
+      return `${Buffer.from(slice).toString("base64")}\n`;
+    }
+    if (!bytes) return "__MISSING__\n";
+    if (bytes.byteLength > WORKSPACE_SYNC_MAX_FILE_BYTES_V1) {
+      return "__TOO_LARGE__\n";
+    }
+    const head = bytes.subarray(0, WORKSPACE_SYNC_CHUNK_BYTES_V1);
+    return `${bytes.byteLength}\t${sha256(bytes)}\n${Buffer.from(head).toString("base64")}\n`;
+  }
+
+  /** One appended chunk of a staged file, as the push writes it. */
+  private stageChunk(shell: string): string {
+    const path = quoted(shell, "STAGE") ?? "";
+    const encoded =
+      /printf %s '([^']*)' \| base64 -d >> "\$STAGE"/.exec(shell)?.[1] ?? "";
+    const chunk = Buffer.from(encoded, "base64");
+    const held = shell.includes('rm -f "$STAGE"')
+      ? undefined
+      : this.files.get(path);
+    this.files.set(
+      path,
+      Uint8Array.from(held ? Buffer.concat([Buffer.from(held), chunk]) : chunk),
+    );
+    return "__STAGED__\n";
+  }
+
+  /**
+   * The bytes a commit command puts in place: written inline when they fitted
+   * in one command, otherwise the staged file it moves, digest-checked exactly
+   * as the emitted `sha256sum` line checks it.
+   */
+  private committed(
+    shell: string,
+    target: string,
+  ): Uint8Array | "corrupt" | undefined {
+    const stage = quoted(shell, "STAGE");
+    if (stage) {
+      const expected = /f1\)" != '([0-9a-f]{64})'/.exec(shell)?.[1];
+      const bytes = this.files.get(stage) ?? new Uint8Array();
+      this.files.delete(stage);
+      return expected && sha256(bytes) !== expected ? "corrupt" : bytes;
+    }
+    const encoded = payload(shell, target);
+    if (encoded === undefined) return undefined;
+    return Uint8Array.from(Buffer.from(encoded, "base64"));
+  }
+
   private read(path: string, base64 = true): string {
     const bytes = this.files.get(path);
     if (!bytes) return "__MISSING__\n";
@@ -280,12 +358,10 @@ class FakeSyncSprite {
   }
 
   private materialize(root: string, relative: string, shell: string): string {
-    const bytes = payload(shell, "TMP") ?? "";
+    const bytes = this.committed(shell, "TMP");
+    if (bytes === "corrupt") return "__CORRUPT__\n";
     const meta = payload(shell, "MTMP") ?? "";
-    this.files.set(
-      `${root}/${relative}`,
-      Uint8Array.from(Buffer.from(bytes, "base64")),
-    );
+    this.files.set(`${root}/${relative}`, bytes ?? new Uint8Array());
     this.files.set(
       `${root}/.frockbot-generations/${relative}`,
       Uint8Array.from(Buffer.from(meta, "base64")),
@@ -316,10 +392,11 @@ class FakeSyncSprite {
   private preserve(root: string, relative: string, shell: string): string {
     const generationId =
       /conflicts\/\$REL\/([^"]*)"/.exec(shell)?.[1] ?? "unknown";
-    const bytes = payload(shell, "KEPT") ?? "";
+    const bytes = this.committed(shell, "TMP");
+    if (bytes === "corrupt") return "__CORRUPT__\n";
     this.files.set(
       `${root}/.frockbot-sync/conflicts/${relative}/${generationId}`,
-      Uint8Array.from(Buffer.from(bytes, "base64")),
+      bytes ?? new Uint8Array(),
     );
     return "__PRESERVED__\n";
   }
@@ -1409,6 +1486,69 @@ describe("the durable-root sync on the Computer handle", () => {
     expect(refused.status).toBe("refused");
   });
 
+  // Production, 2026-09-04: `applet build` wrote a 470 KB `dist/ui.html`, and
+  // every publish that followed failed, because one `base64` of the file was
+  // 627 KB of answer and the storage command may answer 500 KB. Both directions
+  // are checked at 700 KB, which is past that ceiling and past the point where
+  // one script could carry the base64 either.
+  test("pushes a file far larger than one storage command can answer, byte for byte", async () => {
+    const { sprite, store, open } = providerHarness([
+      APPLET_SOURCE_PACKAGE_ROOT,
+    ]);
+    const handle = await open();
+    const appletId = "pub-user-1.0123456789abcdef0123456789abcdef";
+    const page = largeText(700_000);
+    sprite.shellWrite(MOUNTS.appletSource, `${appletId}/dist/ui.html`, page);
+
+    const summary = await handle.sync!.reconcileRoot!(
+      appletSourceRoot,
+      "publish",
+      { requiredPaths: [`${appletId}/dist/ui.html`] },
+    );
+
+    expect(summary).toMatchObject({ status: "ok", pushed: 1, failures: 0 });
+    const stored = await store.read({
+      root: appletSourceRoot,
+      path: `${appletId}/dist/ui.html`,
+    });
+    expect(stored.status).toBe("ok");
+    if (stored.status === "ok") {
+      expect(stored.file.bytes.byteLength).toBe(page.length);
+      expect(decoder.decode(stored.file.bytes)).toBe(page);
+    }
+  });
+
+  // The other direction has the other ceiling: the bytes travel out as base64
+  // inside the script, and a script may be 1 MB, so 900 KB of file is 1.2 MB of
+  // script and the whole command was refused before it ran.
+  test("pulls a file far larger than one storage command can carry, byte for byte", async () => {
+    const { sprite, store, open } = providerHarness();
+    const page = largeText(900_000);
+    await writeToStore(store, skillsRoot, "reference.md", page, BOT_WRITER);
+
+    const handle = await open();
+    const summary = await handle.sync!.reconcile("open");
+
+    expect(summary).toMatchObject({ status: "ok", pulled: 1, failures: 0 });
+    expect(sprite.text(`${MOUNTS.skills}/reference.md`)).toBe(page);
+    // The staging file the chunks were assembled in is moved into place, never
+    // left behind for the next scan to find.
+    expect(sprite.keys(`${MOUNTS.skills}/.frockbot-sync/staging`)).toEqual([]);
+  });
+
+  test("carries a file that fits in one command in one command", async () => {
+    const { sprite, store, open } = providerHarness();
+    await writeToStore(store, skillsRoot, "small.md", "# small", BOT_WRITER);
+    const handle = await open();
+
+    await handle.sync!.reconcile("open");
+
+    expect(sprite.text(`${MOUNTS.skills}/small.md`)).toBe("# small");
+    expect(
+      sprite.scripts.filter((script) => script.includes("__STAGED__")),
+    ).toEqual([]);
+  });
+
   test("answers unavailable rather than throwing when the Sprite is paused", async () => {
     const { sprite, open } = providerHarness();
     const handle = await open();

package/src/sync.ts

@@ -103,6 +103,7 @@ import {
 import type { FlySpriteAgentComputer } from "./computer.js";
 import {
   SYNC_CONFLICTS_DIR,
+  SYNC_STAGING_DIR,
   SYNC_TOMBSTONES_DIR,
   WORKSPACE_EMPTY_SHA256,
   WORKSPACE_GENERATIONS_DIR,
@@ -145,6 +146,49 @@ export const WORKSPACE_SYNC_MANIFEST_MAX_BYTES_V1 = 400_000;
 /** Bounds work and rows even when unusually short paths fit under the bytes. */
 export const WORKSPACE_SYNC_MANIFEST_MAX_ENTRIES_V1 = 2_000;
 
+/**
+ * The most file bytes one storage command carries, in either direction.
+ *
+ * A command's answer travels as base64, so a chunk this size comes back as
+ * roughly 350 KB — inside the 500 KB an answer may be — and goes out inside a
+ * script well inside the 1 MB a script may be. A file larger than one chunk
+ * travels as several commands rather than as one command that would be refused
+ * for its size, which is the whole reason the sync reads and writes in chunks.
+ */
+export const WORKSPACE_SYNC_CHUNK_BYTES_V1 = 256 * 1024;
+
+/**
+ * The largest durable-root file the sync carries between the Computer and the
+ * store.
+ *
+ * It sits above `WORKSPACE_MAX_FILE_BYTES`, the bound the Workspace puts
+ * on one durable-root file, so the transport is never what decides: a file too
+ * large to keep is refused for its size by the Workspace, never for the shape
+ * of the commands that would have moved it.
+ */
+export const WORKSPACE_SYNC_MAX_FILE_BYTES_V1 = 4 * 1024 * 1024;
+
+/** Every chunk offset after the first, in bytes, for a file of this size. */
+function chunkOffsets(size: number): number[] {
+  const offsets: number[] = [];
+  for (
+    let offset = WORKSPACE_SYNC_CHUNK_BYTES_V1;
+    offset < size;
+    offset += WORKSPACE_SYNC_CHUNK_BYTES_V1
+  ) {
+    offsets.push(offset);
+  }
+  return offsets;
+}
+
+/** A staging file name that is one path segment whatever the id looks like. */
+function stagingName(generationId: string, kind: string): string {
+  const safe = generationId.replaceAll(/[^A-Za-z0-9._-]/g, "-").slice(0, 128);
+  return `${safe}.${kind}`;
+}
+
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+
 const ignoredDirectoryNames = new Set<string>(
   WORKSPACE_SYNC_IGNORED_DIRECTORIES_V1,
 );
@@ -1132,6 +1176,18 @@ export class FlySpriteSyncSurface implements ComputerSyncSurfaceV1 {
     };
   }
 
+  /**
+   * Pulls one file off the Computer, in bounded chunks.
+   *
+   * A command's answer has a hard ceiling, and base64 is a third larger than
+   * the bytes it carries, so one `base64` of a whole file stopped working long
+   * before a file got large: half a megabyte of built Applet page is two thirds
+   * of a megabyte of answer, and the command was refused rather than truncated.
+   * So the first command answers the size and digest and the first chunk, and
+   * one command per further chunk brings the rest. The digest is the proof the
+   * pieces are one file: a file rewritten between two chunks fails the check
+   * and is reported, never stitched together from two different versions.
+   */
   async read(
     root: WorkspaceRootV1,
     path: string,
@@ -1140,21 +1196,109 @@ export class FlySpriteSyncSurface implements ComputerSyncSurfaceV1 {
     if (typeof mount !== "string") return mount;
     const relative = this.relative(path);
     if (typeof relative !== "string") return relative;
-    const script = [
+    const prelude = [
+      "set -eu",
       `ROOT=${shellQuote(mount)}`,
       `REL=${shellQuote(relative)}`,
-      'if [ ! -f "$ROOT/$REL" ]; then echo __MISSING__; exit 0; fi',
-      'base64 -w0 "$ROOT/$REL"; echo',
-    ].join("\n");
-    const output = await this.run(script);
-    if (typeof output !== "string") return output;
-    if (output.includes("__MISSING__")) {
+      'FILE="$ROOT/$REL"',
+    ];
+    const head = await this.run(
+      [
+        ...prelude,
+        `CHUNK=${WORKSPACE_SYNC_CHUNK_BYTES_V1}`,
+        'if [ ! -f "$FILE" ]; then echo __MISSING__; exit 0; fi',
+        'SIZE=$(stat -c %s "$FILE")',
+        `if [ "$SIZE" -gt ${WORKSPACE_SYNC_MAX_FILE_BYTES_V1} ]; then echo __TOO_LARGE__; exit 0; fi`,
+        'printf "%s\\t%s\\n" "$SIZE" "$(sha256sum "$FILE" | cut -d" " -f1)"',
+        'head -c "$CHUNK" "$FILE" | base64 -w0; echo',
+      ].join("\n"),
+    );
+    if (typeof head !== "string") return head;
+    if (head.includes("__MISSING__")) {
       return failure("not-found", `No such Workspace file: ${relative}`);
     }
-    return {
-      status: "ok",
-      bytes: Uint8Array.from(Buffer.from(output.trim(), "base64")),
-    };
+    if (head.includes("__TOO_LARGE__")) {
+      return failure(
+        "refused",
+        `"${relative}" is past the ${WORKSPACE_SYNC_MAX_FILE_BYTES_V1}-byte limit on a synced Workspace file`,
+      );
+    }
+    const [header = "", first = ""] = head.split("\n");
+    const [declared = "", digest = ""] = header.split("\t");
+    const size = Number(declared.trim());
+    if (!Number.isSafeInteger(size) || size < 0 || !SHA256_HEX.test(digest)) {
+      return failure("unavailable", "Invalid Fly Workspace sync response");
+    }
+    const chunks = [Buffer.from(first.trim(), "base64")];
+    for (const offset of chunkOffsets(size)) {
+      const next = await this.run(
+        [
+          ...prelude,
+          // `tail -c +N` counts from one, so the offset is one past the bytes
+          // already carried.
+          `tail -c +${offset + 1} "$FILE" | head -c ${WORKSPACE_SYNC_CHUNK_BYTES_V1} | base64 -w0; echo`,
+        ].join("\n"),
+      );
+      if (typeof next !== "string") return next;
+      chunks.push(Buffer.from(next.trim(), "base64"));
+    }
+    const bytes = Buffer.concat(chunks);
+    if (
+      bytes.byteLength !== size ||
+      createHash("sha256").update(bytes).digest("hex") !== digest
+    ) {
+      return failure(
+        "unavailable",
+        `"${relative}" changed on the Computer while it was being read`,
+      );
+    }
+    return { status: "ok", bytes: Uint8Array.from(bytes) };
+  }
+
+  /**
+   * Puts bytes on the Computer under the sync's own staging directory, in
+   * bounded chunks, and answers where they landed.
+   *
+   * The push has the pull's problem in the other direction: a script carrying a
+   * whole file as base64 is refused for its length. Bytes that fit in one chunk
+   * take no staging file at all — the caller writes them inline, which is one
+   * command and the overwhelmingly common case. Anything larger is appended
+   * chunk by chunk and the caller's own command moves it into place, so a file
+   * only ever appears at its real path complete.
+   */
+  private async stage(
+    mount: string,
+    name: string,
+    bytes: Uint8Array,
+  ): Promise<string | WorkspaceFailureV1 | undefined> {
+    if (bytes.byteLength <= WORKSPACE_SYNC_CHUNK_BYTES_V1) return undefined;
+    const staged = `${mount}/${WORKSPACE_SYNC_DIR}/${SYNC_STAGING_DIR}/${name}`;
+    for (
+      let offset = 0;
+      offset < bytes.byteLength;
+      offset += WORKSPACE_SYNC_CHUNK_BYTES_V1
+    ) {
+      const chunk = bytes.subarray(
+        offset,
+        offset + WORKSPACE_SYNC_CHUNK_BYTES_V1,
+      );
+      const output = await this.run(
+        [
+          "set -eu",
+          `STAGE=${shellQuote(staged)}`,
+          'mkdir -p "$(dirname "$STAGE")"',
+          ...(offset === 0 ? ['rm -f "$STAGE"'] : []),
+          `printf %s ${shellQuote(Buffer.from(chunk).toString("base64"))} | base64 -d >> "$STAGE"`,
+          'chmod 600 "$STAGE"',
+          "echo __STAGED__",
+        ].join("\n"),
+      );
+      if (typeof output !== "string") return output;
+      if (!output.includes("__STAGED__")) {
+        return failure("unavailable", "Invalid Fly Workspace sync response");
+      }
+    }
+    return staged;
   }
 
   async materialize(
@@ -1167,6 +1311,14 @@ export class FlySpriteSyncSurface implements ComputerSyncSurfaceV1 {
     if (typeof mount !== "string") return mount;
     const relative = this.relative(path);
     if (typeof relative !== "string") return relative;
+    const oversized = this.oversized(relative, bytes);
+    if (oversized) return oversized;
+    const staged = await this.stage(
+      mount,
+      stagingName(generation.generationId, "pull"),
+      bytes,
+    );
+    if (staged && typeof staged !== "string") return staged;
     const script = [
       "set -eu",
       `ROOT=${shellQuote(mount)}`,
@@ -1176,7 +1328,7 @@ export class FlySpriteSyncSurface implements ComputerSyncSurfaceV1 {
       `GRAVE="$ROOT/${WORKSPACE_SYNC_DIR}/${SYNC_TOMBSTONES_DIR}/$REL"`,
       'mkdir -p "$(dirname "$TARGET")" "$(dirname "$META")"',
       'TMP=$(mktemp "${TARGET}.XXXXXX")',
-      `printf %s ${shellQuote(Buffer.from(bytes).toString("base64"))} | base64 -d > "$TMP"`,
+      ...this.assemble(staged, bytes, generation.contentHash),
       'chmod 600 "$TMP"',
       'mv "$TMP" "$TARGET"',
       'MTMP=$(mktemp "${META}.XXXXXX")',
@@ -1188,12 +1340,56 @@ export class FlySpriteSyncSurface implements ComputerSyncSurfaceV1 {
     ].join("\n");
     const output = await this.run(script);
     if (typeof output !== "string") return output;
+    if (output.includes("__CORRUPT__")) {
+      return this.corrupt(relative);
+    }
     if (!output.includes("__SYNCED__")) {
       return failure("unavailable", "Invalid Fly Workspace sync response");
     }
     return { status: "ok" };
   }
 
+  /** Refuses bytes the sync will not carry, before a command is composed. */
+  private oversized(
+    relative: string,
+    bytes: Uint8Array,
+  ): WorkspaceFailureV1 | undefined {
+    if (bytes.byteLength <= WORKSPACE_SYNC_MAX_FILE_BYTES_V1) return undefined;
+    return failure(
+      "refused",
+      `"${relative}" is past the ${WORKSPACE_SYNC_MAX_FILE_BYTES_V1}-byte limit on a synced Workspace file`,
+    );
+  }
+
+  private corrupt(relative: string): WorkspaceFailureV1 {
+    return failure(
+      "unavailable",
+      `"${relative}" did not reach the Computer intact`,
+    );
+  }
+
+  /**
+   * The lines that fill `$TMP` with the bytes: inline when they fitted in one
+   * command, otherwise the staged file, checked against its digest before it is
+   * used so a half-written staging file never becomes a durable-root file.
+   */
+  private assemble(
+    staged: string | undefined,
+    bytes: Uint8Array,
+    contentHash: string,
+  ): string[] {
+    if (!staged) {
+      return [
+        `printf %s ${shellQuote(Buffer.from(bytes).toString("base64"))} | base64 -d > "$TMP"`,
+      ];
+    }
+    return [
+      `STAGE=${shellQuote(staged)}`,
+      `if [ "$(sha256sum "$STAGE" | cut -d" " -f1)" != ${shellQuote(contentHash)} ]; then rm -f "$STAGE"; echo __CORRUPT__; exit 0; fi`,
+      'mv "$STAGE" "$TMP"',
+    ];
+  }
+
   async remove(
     root: WorkspaceRootV1,
     path: string,
@@ -1262,18 +1458,31 @@ export class FlySpriteSyncSurface implements ComputerSyncSurfaceV1 {
     if (typeof mount !== "string") return mount;
     const relative = this.relative(path);
     if (typeof relative !== "string") return relative;
+    const oversized = this.oversized(relative, bytes);
+    if (oversized) return oversized;
+    const staged = await this.stage(
+      mount,
+      stagingName(generation.generationId, "conflict"),
+      bytes,
+    );
+    if (staged && typeof staged !== "string") return staged;
     const script = [
       "set -eu",
       `ROOT=${shellQuote(mount)}`,
       `REL=${shellQuote(relative)}`,
       `KEPT="$ROOT/${WORKSPACE_SYNC_DIR}/${SYNC_CONFLICTS_DIR}/$REL/${generation.generationId}"`,
       'mkdir -p "$(dirname "$KEPT")"',
-      `printf %s ${shellQuote(Buffer.from(bytes).toString("base64"))} | base64 -d > "$KEPT"`,
-      'chmod 600 "$KEPT"',
+      'TMP=$(mktemp "${KEPT}.XXXXXX")',
+      ...this.assemble(staged, bytes, generation.contentHash),
+      'chmod 600 "$TMP"',
+      'mv "$TMP" "$KEPT"',
       "echo __PRESERVED__",
     ].join("\n");
     const output = await this.run(script);
     if (typeof output !== "string") return output;
+    if (output.includes("__CORRUPT__")) {
+      return this.corrupt(relative);
+    }
     if (!output.includes("__PRESERVED__")) {
       return failure("unavailable", "Invalid Fly Workspace sync response");
     }

package/src/workspace.ts

@@ -71,6 +71,11 @@ export const WORKSPACE_SYNC_DIR = ".frockbot-sync";
 export const SYNC_TOMBSTONES_DIR = "tombstones";
 /** Where a losing write is preserved on the Computer, under `WORKSPACE_SYNC_DIR`. */
 export const SYNC_CONFLICTS_DIR = "conflicts";
+/**
+ * Where a file too large for one command is assembled chunk by chunk before it
+ * is moved into place, under `WORKSPACE_SYNC_DIR`.
+ */
+export const SYNC_STAGING_DIR = "staging";
 const GENERATIONS_DIR = WORKSPACE_GENERATIONS_DIR;
 const LOCKS_DIR = ".frockbot-locks";
 /** The sha-256 of no bytes; a deletion tombstone's content address. */