@marimo-team/frontend 0.25.3-dev100 → 0.25.3-dev101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/frontend",
-  "version": "0.25.3-dev100",
+  "version": "0.25.3-dev101",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/core/document/__tests__/lifecycle-scenarios.test.ts

@@ -0,0 +1,61 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { vi } from "vitest";
+import { test } from "./scenario-fixture";
+
+test("closing a session before the debounce prevents submission", async ({
+  expect,
+  session: { user, notebook, controller },
+}) => {
+  user.changeCode("c3", "local");
+  const reason = new Error("Editing session ended");
+  controller.abort(reason);
+  await vi.advanceTimersByTimeAsync(1000);
+  expect(notebook.edit).not.toHaveBeenCalled();
+  expect(vi.getTimerCount()).toBe(0);
+  await expect(user.sync()).rejects.toBe(reason);
+});
+
+test("closing a session before a queued flush starts prevents submission", async ({
+  expect,
+  session: { user, notebook, controller },
+}) => {
+  user.changeCode("c3", "local");
+  const flushed = user.sync();
+  const reason = new Error("Editing session ended");
+  controller.abort(reason);
+  await expect(flushed).rejects.toBe(reason);
+  expect(notebook.edit).not.toHaveBeenCalled();
+  expect(vi.getTimerCount()).toBe(0);
+});
+
+test.for(["request", "confirmation", "retry"] as const)(
+  "closing a session during %s stops synchronization",
+  async (phase, { expect, session: { user, host, notebook, controller } }) => {
+    user.changeCode("c3", "local");
+    const flushed = user.sync();
+    const request = await host.nextRequest();
+    if (phase === "confirmation") {
+      request.process();
+      request.deliverResponse();
+    } else if (phase === "retry") {
+      request.loseResponse();
+    }
+    await vi.advanceTimersByTimeAsync(0);
+    const reason = new Error("Editing session ended");
+    controller.abort(reason);
+    await expect(flushed).rejects.toBe(reason);
+    if (phase === "request") {
+      expect(request.signal.aborted).toBe(true);
+    }
+
+    host.changeCell("c1", { code: "later" });
+    host.deliverSnapshot();
+    user.changeCode("c3", "after closing");
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(notebook.edit).toHaveBeenCalledOnce();
+    expect(vi.getTimerCount()).toBe(0);
+    await expect(user.sync()).rejects.toBe(reason);
+    await expect(user.retry()).rejects.toBe(reason);
+  },
+);

package/src/core/document/__tests__/model.test.ts

@@ -101,69 +101,6 @@ describe("document synchronization", () => {
     expect(vi.getTimerCount()).toBe(0);
   });
 
-  it("releases unsent reversals and flushes an unchanged document without a request", async () => {
-    const { store, source, sent, edit, model, state, value } = setup();
-    edit("temporary");
-    edit("x = 1");
-    expect(state()).toEqual({ status: "idle" });
-    const remote = withCells(document(), { c1: cell("c1", "remote") });
-    store.set(source, remote);
-    expect(value()?.code).toBe("remote");
-    await expect(model.flush()).resolves.toEqual(remote.revision);
-    await vi.advanceTimersByTimeAsync(1000);
-    expect(sent).not.toHaveBeenCalled();
-  });
-
-  it("flushes edits made after an earlier drain finishes but before its promise settles", async () => {
-    const { store, source, sent, replies, edit, model } = setup();
-    const first = model.flush();
-    await Promise.resolve();
-    edit("new code");
-    const second = model.flush();
-    const settled = vi.fn();
-    void second.then(settled, settled);
-
-    await vi.advanceTimersByTimeAsync(0);
-    expect(sent).toHaveBeenCalledOnce();
-    expect(settled).not.toHaveBeenCalled();
-    expect(sent.mock.calls[0][0].changes).toMatchObject([
-      { cell: { id: "c1", code: "new code" } },
-    ]);
-
-    const accepted = withCells(document(), {
-      c1: cell("c1", "new code", { etag: "accepted", version: 2 }),
-    });
-    replies[0].resolve(response(accepted));
-    store.set(source, accepted);
-    await expect(second).resolves.toEqual(accepted.revision);
-    await expect(first).resolves.toEqual(document().revision);
-  });
-
-  it("manually retries an uncertain request with its original identity", async () => {
-    const { store, source, sent, replies, edit, model } = setup();
-    edit("local");
-    const flushed = model.flush();
-    expect(model.flush()).toBe(flushed);
-    const rejected = expectFailure(flushed, "offline");
-    await vi.advanceTimersByTimeAsync(0);
-    replies[0].reject(new Error("offline"));
-    await vi.advanceTimersByTimeAsync(500);
-    replies[1].reject(new Error("offline"));
-    await vi.advanceTimersByTimeAsync(1000);
-    replies[2].reject(new Error("offline"));
-    await rejected;
-    const retried = model.retry();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(sent.mock.calls[3][0]).toMatchObject({
-      idempotencyKey: sent.mock.calls[0][0].idempotencyKey,
-      changes: sent.mock.calls[0][0].changes,
-    });
-    const accepted = withCells(document(), { c1: cell("c1", "local") });
-    replies[3].resolve(response(accepted));
-    store.set(source, accepted);
-    await expect(retried).resolves.toEqual(accepted.revision);
-  });
-
   it("fails without repeating a request when the response names another notebook", async () => {
     const { sent, replies, edit, model, state } = setup();
     edit("local");
@@ -176,257 +113,6 @@ describe("document synchronization", () => {
     expect(state()).toMatchObject({ status: "error" });
   });
 
-  it("debounces typing and waits for streamed confirmation before sending newer edits", async () => {
-    const { store, source, sent, replies, edit, model, state, value } = setup();
-    edit("first");
-    await vi.advanceTimersByTimeAsync(300);
-    edit("sent");
-    await vi.advanceTimersByTimeAsync(399);
-    expect(sent).not.toHaveBeenCalled();
-    await vi.advanceTimersByTimeAsync(1);
-    expect(sent).toHaveBeenCalledOnce();
-    expect(sent.mock.calls[0][0].changes[0]).toMatchObject({
-      cell: { code: "sent" },
-    });
-    edit("newer");
-    const accepted = withCells(document(), {
-      c1: cell("c1", "sent", { etag: "accepted" }),
-    });
-    replies[0].resolve(response(accepted));
-    await vi.advanceTimersByTimeAsync(0);
-    expect(state()).toEqual({ status: "confirming" });
-    await vi.advanceTimersByTimeAsync(1000);
-    expect(sent).toHaveBeenCalledOnce();
-    store.set(source, accepted);
-    await vi.advanceTimersByTimeAsync(0);
-    expect(sent).toHaveBeenCalledTimes(2);
-    expect(sent.mock.calls[1][0].changes[0]).toMatchObject({
-      base_etag: "accepted",
-      cell: { code: "newer" },
-    });
-    const latest = withCells(accepted, { c1: cell("c1", "newer") });
-    const flushed = model.flush();
-    replies[1].resolve(response(latest));
-    store.set(source, latest);
-    await expect(flushed).resolves.toEqual(latest.revision);
-    expect(state()).toEqual({ status: "idle" });
-    expect(value()?.code).toBe("newer");
-  });
-
-  it.each(["response", "snapshot"] as const)(
-    "confirms a reset when %s arrives first without opening a stream",
-    async (first) => {
-      const { store, source, sent, replies, edit, model } = setup();
-      edit("sent");
-      const flushed = model.flush();
-      await vi.advanceTimersByTimeAsync(0);
-      store.set(source, null);
-      const accepted = withCells(document(), { c1: cell("c1", "sent") });
-      const later = withCells(accepted, { c2: cell("c2", "remote") });
-      if (first === "response") {
-        replies[0].resolve(response(accepted));
-      } else {
-        store.set(source, later);
-      }
-      await vi.advanceTimersByTimeAsync(0);
-      expect(store.get(model.syncStateAtom)).toEqual({
-        status: first === "response" ? "confirming" : "sending",
-      });
-      if (first === "response") {
-        store.set(source, later);
-      } else {
-        replies[0].resolve(response(accepted));
-      }
-      await expect(flushed).resolves.toEqual(later.revision);
-      expect(sent).toHaveBeenCalledOnce();
-      expect(store.get(model.syncStateAtom)).toEqual({ status: "idle" });
-    },
-  );
-
-  it("retries a lost response with the captured body and key, preserving subsequent typing", async () => {
-    const { store, source, sent, replies, edit, model, value } = setup();
-    edit("sent");
-    const flushed = model.flush();
-    await vi.advanceTimersByTimeAsync(0);
-    const accepted = withCells(document(), {
-      c1: cell("c1", "sent", { etag: "accepted" }),
-    });
-    store.set(source, accepted);
-    edit("newer");
-    replies[0].reject(new Error("response lost"));
-    await vi.advanceTimersByTimeAsync(500);
-    expect(sent).toHaveBeenCalledTimes(2);
-    const original = sent.mock.calls[0][0];
-    const retry = sent.mock.calls[1][0];
-    expect(retry.idempotencyKey).toBe(original.idempotencyKey);
-    expect(retry.changes).toBe(original.changes);
-    replies[1].resolve(response(accepted));
-    await vi.advanceTimersByTimeAsync(0);
-    expect(sent).toHaveBeenCalledTimes(3);
-    expect(sent.mock.calls[2][0].idempotencyKey).not.toBe(
-      original.idempotencyKey,
-    );
-    const latest = withCells(accepted, { c1: cell("c1", "newer") });
-    store.set(source, latest);
-    replies[2].resolve(response(latest));
-    await expect(flushed).resolves.toEqual(latest.revision);
-    expect(value()?.code).toBe("newer");
-  });
-
-  it("exposes conflicts and only retries explicitly against a fresh confirmed revision", async () => {
-    const { store, source, sent, replies, edit, model, state, value } = setup();
-    edit("local");
-    const flushed = model.flush();
-    const rejected = expectFailure(flushed, "conflict");
-    await vi.advanceTimersByTimeAsync(0);
-    const remote = withCells(document(), {
-      c1: cell("c1", "remote", { etag: "remote" }),
-    });
-    const problem: Protocol.Problem = {
-      type: "tag:marimo.io,2026:host/conflict",
-      title: "conflict",
-      status: 409,
-      edit: {
-        change: 0,
-        cell: remote.cells.get("c1")!,
-        document: remote.revision,
-      },
-    };
-    replies[0].resolve({ ok: false, status: 409, problem });
-    await rejected;
-    expect(state()).toMatchObject({
-      status: "error",
-      problem,
-      retryable: true,
-    });
-    await expect(model.retry()).rejects.toThrow("Wait for the host");
-    edit("updated local");
-    store.set(source, remote);
-    await vi.advanceTimersByTimeAsync(2000);
-    expect(sent).toHaveBeenCalledOnce();
-    expect(value()?.code).toBe("updated local");
-    const retry = model.retry();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(sent.mock.calls[1][0].changes[0]).toMatchObject({
-      base_etag: "remote",
-      cell: { code: "updated local" },
-    });
-    const accepted = withCells(remote, { c1: cell("c1", "updated local") });
-    replies[1].resolve(response(accepted));
-    store.set(source, accepted);
-    await expect(retry).resolves.toEqual(accepted.revision);
-  });
-
-  it("retains a draft after remote deletion and never sends the other edits alone", async () => {
-    const { store, source, model, sent, replies, edit } = setup();
-    edit("keep this");
-    const flushed = model.flush();
-    const rejected = expectFailure(flushed, "removed");
-    await vi.advanceTimersByTimeAsync(0);
-    const removed = withCells(document(), { c1: null });
-    store.set(source, removed);
-    replies[0].resolve({
-      ok: false,
-      status: 409,
-      problem: {
-        type: "tag:marimo.io,2026:host/conflict",
-        title: "removed",
-        status: 409,
-        edit: { change: 0, cell: null, document: removed.revision },
-      },
-    });
-    await rejected;
-    store.set(model.editAtom, (tx) => tx.setCode("c2", "other edit"));
-    await expect(model.retry()).rejects.toThrow("unavailable");
-    expect(sent).toHaveBeenCalledOnce();
-    store.set(source, withCells(removed, { c1: cell("c1", "restored") }));
-    expect(store.get(model.cellAtom("c1"))?.code).toBe("keep this");
-  });
-
-  it("bounds retries and never replays an uncertain write after receipt expiry", async () => {
-    const { sent, replies, edit, model, state } = setup();
-    edit("local");
-    const flushed = model.flush();
-    const rejected = expectFailure(flushed, "offline");
-    await vi.advanceTimersByTimeAsync(0);
-    replies[0].reject(new Error("offline"));
-    await vi.advanceTimersByTimeAsync(500);
-    replies[1].reject(new Error("offline"));
-    await vi.advanceTimersByTimeAsync(1000);
-    replies[2].reject(new Error("offline"));
-    await rejected;
-    expect(state()).toMatchObject({ status: "error", retryable: true });
-    await vi.advanceTimersByTimeAsync(60_000);
-    await expect(model.retry()).rejects.toThrow("retry window expired");
-    expect(sent).toHaveBeenCalledTimes(3);
-    expect(state()).toMatchObject({ status: "error", retryable: false });
-  });
-
-  it("times out a hung attempt, aborts it, and retries the same request", async () => {
-    const { store, source, sent, replies, edit, model } = setup();
-    edit("local");
-    const flushed = model.flush();
-    await vi.advanceTimersByTimeAsync(10_500);
-    expect(sent).toHaveBeenCalledTimes(2);
-    expect(sent.mock.calls[0][0].signal.aborted).toBe(true);
-    expect(sent.mock.calls[1][0].idempotencyKey).toBe(
-      sent.mock.calls[0][0].idempotencyKey,
-    );
-    const accepted = withCells(document(), { c1: cell("c1", "local") });
-    replies[1].resolve(response(accepted));
-    store.set(source, accepted);
-    await expect(flushed).resolves.toEqual(accepted.revision);
-  });
-
-  it("aborts before the debounce without sending any edits", async () => {
-    const { sent, edit, model, controller } = setup();
-    edit("local");
-    controller.abort();
-    await vi.advanceTimersByTimeAsync(1000);
-    expect(sent).not.toHaveBeenCalled();
-    expect(vi.getTimerCount()).toBe(0);
-    await expect(model.flush()).rejects.toThrow("aborted");
-  });
-
-  it.each(["request", "confirmation", "retry"] as const)(
-    "aborts during %s without leaving work or subscriptions",
-    async (phase) => {
-      const {
-        store,
-        source,
-        sent,
-        replies,
-        edit,
-        model,
-        controller,
-        unmounted,
-      } = setup();
-      edit("local");
-      const flushed = model.flush();
-      const reason = new Error("Editing session ended");
-      const rejected = expectAbort(flushed, reason);
-      await vi.advanceTimersByTimeAsync(0);
-      if (phase === "confirmation") {
-        replies[0].resolve(
-          response(withCells(document(), { c1: cell("c1", "local") })),
-        );
-      }
-      if (phase === "retry") {
-        replies[0].reject(new Error("offline"));
-      }
-      await vi.advanceTimersByTimeAsync(0);
-      controller.abort(reason);
-      await rejected;
-      expect(unmounted).toHaveBeenCalledOnce();
-      expect(sent).toHaveBeenCalledOnce();
-      store.set(source, withCells(document(), { c1: cell("c1", "later") }));
-      edit("after disposal");
-      expect(vi.getTimerCount()).toBe(0);
-      await expect(model.flush()).rejects.toBe(reason);
-      await expect(model.retry()).rejects.toBe(reason);
-    },
-  );
-
   it("ignores a late response and source update after its lifetime ends", async () => {
     const {
       store,
@@ -458,17 +144,6 @@ describe("document synchronization", () => {
     expect(vi.getTimerCount()).toBe(0);
   });
 
-  it("rejects a queued flush when aborted before submission", async () => {
-    const { model, edit, sent, controller } = setup();
-    edit("local");
-    const reason = new Error("Editing session ended");
-    const rejected = expectAbort(model.flush(), reason);
-    controller.abort(reason);
-    await rejected;
-    expect(sent).not.toHaveBeenCalled();
-    expect(vi.getTimerCount()).toBe(0);
-  });
-
   it("aborts an in-flight edit when notebook identity changes", async () => {
     const { store, source, sent, edit, model, state } = setup();
     edit("local");

package/src/core/document/__tests__/protocol-fixtures.ts

@@ -0,0 +1,38 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { readFileSync } from "node:fs";
+import NodeUrl from "node:url";
+import type * as Protocol from "@marimo-team/client/protocol";
+import { invariant } from "@/utils/invariant";
+import { fixtureEvents } from "../../host/__tests__/fixtures";
+import type { Document } from "../../host/resources/document";
+
+export function protocolFixture(name: string): unknown {
+  return JSON.parse(
+    readFileSync(
+      new NodeUrl.URL(
+        `../../../../../protocols/host/fixtures/${name}`,
+        import.meta.url,
+      ),
+      "utf8",
+    ),
+  );
+}
+
+export function initialDocument(): Document {
+  const cells = new Map<Protocol.CellId, Protocol.Cell>();
+  let revision: Protocol.Document | undefined;
+  for (const event of fixtureEvents("notebook-events.sse")) {
+    if (event.event === "ready") {
+      break;
+    }
+    if (event.event === "cell") {
+      cells.set(event.data.cell.id, event.data.cell);
+    }
+    if (event.event === "document") {
+      revision = event.data.document;
+    }
+  }
+  invariant(revision !== undefined, "Fixture has no document");
+  return { revision, cells };
+}

package/src/core/document/__tests__/recovery-scenarios.test.ts

@@ -0,0 +1,230 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { vi } from "vitest";
+import { test } from "./scenario-fixture";
+
+test.for(["response", "document"] as const)(
+  "keeps a conflicting batch intact and retries explicitly with %s first",
+  async (first, { expect, session: { user, host, notebook } }) => {
+    // The first change is valid; the second conflicts. Neither may commit.
+    user.changeCells({
+      c1: { code: "other local edit" },
+      c3: { code: "local" },
+    });
+    const synced = user.sync();
+    const request = await host.nextRequest();
+    host.changeCell("c3", { code: "remote", name: "remote name" });
+    const remote = host.document();
+    expect(user.cell("c3")?.code).toBe("local");
+    request.process();
+    expect(host.document()).toEqual(remote);
+    user.changeCode("c3", "updated local");
+
+    if (first === "document") {
+      host.deliverDocument();
+    }
+    request.deliverResponse();
+    await expect(synced).rejects.toThrow("conflict");
+    expect(user.status()).toMatchObject({ status: "error", retryable: true });
+    if (first === "response") {
+      host.deliverDocument();
+    }
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(notebook.edit).toHaveBeenCalledOnce();
+    expect(user.cell("c3")?.code).toBe("updated local");
+    expect(user.cell("c1")?.code).toBe("other local edit");
+
+    const retried = user.retry();
+    const retry = await host.nextRequest();
+    expect(retry.idempotencyKey).not.toBe(request.idempotencyKey);
+    retry.process();
+    retry.deliverResponse();
+    host.deliverDocument();
+    await expect(retried).resolves.toEqual(host.document().revision);
+    expect(host.document().cells.get("c1")?.code).toBe("other local edit");
+    expect(host.document().cells.get("c3")).toMatchObject({
+      code: "updated local",
+      name: "remote name",
+    });
+    expect(user.cell("c3")).toMatchObject({
+      code: "updated local",
+      name: "remote name",
+    });
+    expect(user.status()).toEqual({ status: "idle" });
+  },
+);
+
+test("waits for the conflicting revision before allowing a retry", async ({
+  expect,
+  session: { user, host, notebook },
+}) => {
+  user.changeCode("c3", "local");
+  const synced = user.sync();
+  const request = await host.nextRequest();
+  host.changeCell("c3", { code: "remote" });
+  request.process();
+  request.deliverResponse();
+  await expect(synced).rejects.toThrow("conflict");
+  await expect(user.retry()).rejects.toThrow("Wait for the host");
+  expect(notebook.edit).toHaveBeenCalledOnce();
+  expect(user.cell("c3")?.code).toBe("local");
+
+  host.deliverDocument();
+  const retried = user.retry();
+  const retry = await host.nextRequest();
+  retry.process();
+  retry.deliverResponse();
+  host.deliverDocument();
+  await expect(retried).resolves.toEqual(host.document().revision);
+  expect(host.document().cells.get("c3")?.code).toBe("local");
+  expect(user.status()).toEqual({ status: "idle" });
+});
+
+test("replays a lost response without committing twice or losing newer typing", async ({
+  expect,
+  session: { user, host },
+}) => {
+  user.changeCode("c3", "sent");
+  const flushed = user.sync();
+  const request = await host.nextRequest();
+  request.process();
+  const committed = host.document();
+  host.deliverDocument();
+  user.changeCode("c3", "newer");
+  request.loseResponse();
+
+  await vi.advanceTimersByTimeAsync(500);
+  const retry = await host.nextRequest();
+  expect(retry.idempotencyKey).toBe(request.idempotencyKey);
+  expect(retry.changes).toEqual(request.changes);
+  retry.process();
+  expect(host.document()).toEqual(committed);
+  retry.deliverResponse();
+
+  const next = await host.nextRequest();
+  expect(next.idempotencyKey).not.toBe(request.idempotencyKey);
+  next.process();
+  next.deliverResponse();
+  host.deliverDocument();
+  await expect(flushed).resolves.toEqual(host.document().revision);
+  expect(host.document().revision.version).toBe(committed.revision.version + 1);
+  expect(host.document().cells.get("c3")?.code).toBe("newer");
+  expect(user.cell("c3")?.code).toBe("newer");
+});
+
+test("ignores a timed-out attempt that completes after its retry", async ({
+  expect,
+  session: { user, host, notebook },
+}) => {
+  user.changeCode("c3", "local");
+  const flushed = user.sync();
+  const first = await host.nextRequest();
+  await vi.advanceTimersByTimeAsync(10_500);
+  const retry = await host.nextRequest();
+  expect(first.signal.aborted).toBe(true);
+  expect(retry.idempotencyKey).toBe(first.idempotencyKey);
+  retry.process();
+  const committed = host.document();
+  retry.deliverResponse();
+  host.deliverDocument();
+  await expect(flushed).resolves.toEqual(committed.revision);
+  first.process();
+  first.deliverResponse();
+  await vi.advanceTimersByTimeAsync(0);
+  expect(host.document()).toEqual(committed);
+  expect(user.cell("c3")?.code).toBe("local");
+  expect(notebook.edit).toHaveBeenCalledTimes(2);
+});
+
+test("a manual retry reuses the committed edit after automatic retries give up", async ({
+  expect,
+  session: { user, host, notebook },
+}) => {
+  user.changeCode("c3", "sent");
+  const synced = user.sync();
+  const request = await host.nextRequest();
+  request.process();
+  const committed = host.document();
+  request.loseResponse();
+  for (const delay of [500, 1000]) {
+    await vi.advanceTimersByTimeAsync(delay);
+    const retry = await host.nextRequest();
+    retry.process();
+    retry.loseResponse();
+  }
+  await expect(synced).rejects.toThrow("Connection lost");
+  expect(user.status()).toMatchObject({ status: "error", retryable: true });
+  expect(notebook.edit).toHaveBeenCalledTimes(3);
+  expect(host.document()).toEqual(committed);
+
+  const retried = user.retry();
+  const retry = await host.nextRequest();
+  expect(retry.idempotencyKey).toBe(request.idempotencyKey);
+  expect(retry.changes).toEqual(request.changes);
+  retry.process();
+  retry.deliverResponse();
+  host.deliverDocument();
+  await expect(retried).resolves.toEqual(committed.revision);
+  expect(host.document()).toEqual(committed);
+  expect(user.status()).toEqual({ status: "idle" });
+  expect(notebook.edit).toHaveBeenCalledTimes(4);
+});
+
+test("refuses a manual retry after the safe retry window while retaining the draft", async ({
+  expect,
+  session: { user, host, notebook },
+}) => {
+  user.changeCode("c3", "sent");
+  const synced = user.sync();
+  const request = await host.nextRequest();
+  request.process();
+  const committed = host.document();
+  request.loseResponse();
+  for (const delay of [500, 1000]) {
+    await vi.advanceTimersByTimeAsync(delay);
+    const retry = await host.nextRequest();
+    retry.process();
+    retry.loseResponse();
+  }
+  await expect(synced).rejects.toThrow("Connection lost");
+  expect(user.status()).toMatchObject({ status: "error", retryable: true });
+
+  await vi.advanceTimersByTimeAsync(60_000);
+  await expect(user.retry()).rejects.toThrow("retry window expired");
+  expect(user.status()).toMatchObject({ status: "error", retryable: false });
+  expect(notebook.edit).toHaveBeenCalledTimes(3);
+  expect(host.document()).toEqual(committed);
+  expect(user.cell("c3")?.code).toBe("sent");
+});
+
+test("keeps the whole draft when another writer deletes an edited cell", async ({
+  expect,
+  session: { user, host, notebook },
+}) => {
+  user.changeCode("c3", "keep this");
+  const synced = user.sync();
+  const request = await host.nextRequest();
+  host.deleteCell("c3");
+  request.process();
+  request.deliverResponse();
+  host.deliverDocument();
+  await expect(synced).rejects.toThrow("conflict");
+
+  user.changeCode("c1", "other edit");
+  await expect(user.retry()).rejects.toThrow("unavailable");
+  await vi.advanceTimersByTimeAsync(1000);
+  expect(notebook.edit).toHaveBeenCalledOnce();
+  expect(host.document().cells.get("c1")?.code).toBe("import marimo as mo");
+
+  host.createCell({ id: "c3", code: "restored" });
+  host.deliverDocument();
+  expect(user.cell("c3")?.code).toBe("keep this");
+  const retried = user.retry();
+  const retry = await host.nextRequest();
+  retry.process();
+  retry.deliverResponse();
+  host.deliverDocument();
+  await expect(retried).resolves.toEqual(host.document().revision);
+  expect(host.document().cells.get("c3")?.code).toBe("keep this");
+  expect(host.document().cells.get("c1")?.code).toBe("other edit");
+});