@marimo-team/islands 0.25.3-dev169 → 0.25.3-dev170

package/src/core/edit-app.tsx

@@ -34,6 +34,7 @@ import {
   useCellActions,
 } from "./cells/cells";
 import type { AppConfig, UserConfig } from "./config/config-schema";
+import { DocumentProvider } from "./notebook/document";
 import { RuntimeState } from "./kernel/RuntimeState";
 import { getSessionId } from "./kernel/session";
 import { useTogglePresenting } from "./layout/useTogglePresenting";
@@ -83,7 +84,7 @@ export const EditApp: React.FC<AppProps> = ({
     };
   }, [sendComponentValues]);
 
-  const { connection, reconnect } = useNotebookSession({
+  const { connection, reconnect, documentModel } = useNotebookSession({
     autoInstantiate: userConfig.runtime.auto_instantiate,
     setCells: (cells, layout) => {
       setCells(cells);
@@ -174,7 +175,7 @@ export const EditApp: React.FC<AppProps> = ({
   );
 
   return (
-    <>
+    <DocumentProvider model={documentModel}>
       <SandboxController onReconnect={reconnect} />
       <AppContainer
         connection={connection}
@@ -228,6 +229,6 @@ export const EditApp: React.FC<AppProps> = ({
           />
         </TooltipProvider>
       )}
-    </>
+    </DocumentProvider>
   );
 };

package/src/core/export/layout.ts

@@ -1,9 +1,9 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { flushDocumentChanges } from "@/core/cells/document-changes";
+import { flushDocument } from "@/core/cells/document";
 import { getSerializedLayout } from "@/core/layout/layout";
 
 export async function getExportLayout() {
-  await flushDocumentChanges();
+  await flushDocument();
   return getSerializedLayout();
 }

package/src/core/islands/bridge.ts

@@ -347,7 +347,6 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   public saveAppConfig = throwNotImplemented;
   public saveCellConfig = throwNotImplemented;
   public sendRestart = throwNotImplemented;
-  public sendDocumentTransaction = throwNotImplemented;
   public readCode = throwNotImplemented;
   public readSnippets = throwNotImplemented;
   public previewDatasetColumn = throwNotImplemented;

package/src/core/network/requests-lazy.ts

@@ -144,7 +144,6 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   downloadStorage: "waitForConnectionOpen",
 
   // Sync operations that wait for connection
-  sendDocumentTransaction: "waitForConnectionOpen",
   sendCodeCompletionRequest: "waitForConnectionOpen",
 };
 

package/src/core/network/requests-network.ts

@@ -70,15 +70,6 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
-    sendDocumentTransaction: async (request) => {
-      await waitForConnectionOpen();
-      return getClient()
-        .POST("/api/document/transaction", {
-          body: request,
-          params: getParams(),
-        })
-        .then(handleResponseReturnNull);
-    },
     sendRename: (request) => {
       return getClient()
         .POST("/api/kernel/rename", {

package/src/core/network/requests-static.ts

@@ -40,7 +40,6 @@ export function createStaticRequests(): EditRequests & RunRequests {
       return null;
     },
     sendRestart: throwNotInEditMode,
-    sendDocumentTransaction: throwNotInEditMode,
     sendRun: throwNotInEditMode,
     sendRunScratchpad: throwNotInEditMode,
     sendRename: throwNotInEditMode,

package/src/core/network/requests-toasting.tsx

@@ -21,7 +21,6 @@ export function createErrorToastingRequests(
     sendInstantiate: "Failed to instantiate",
     sendFunctionRequest: "Failed to send function request",
     sendRestart: "Failed to restart",
-    sendDocumentTransaction: "Failed to sync document transaction",
     sendRun: "Failed to run",
     sendRunScratchpad: "Failed to run scratchpad",
     sendRename: "Failed to rename",

package/src/core/network/types.ts

@@ -117,8 +117,6 @@ export interface FileCreateInput {
 }
 export type UpdateUIElementRequest = schemas["UpdateUIElementRequest"];
 export type ModelRequest = schemas["ModelRequest"];
-export type NotebookDocumentTransactionRequest =
-  schemas["NotebookDocumentTransactionRequest"];
 export type UpdateUserConfigRequest = schemas["UpdateUserConfigRequest"];
 export type ShutdownSessionRequest = schemas["ShutdownSessionRequest"];
 export type Snippet = schemas["Snippet"];
@@ -179,9 +177,6 @@ export interface EditRequests {
   saveAppConfig: (request: SaveAppConfigurationRequest) => Promise<null>;
   saveCellConfig: (request: SetCellConfigRequest) => Promise<null>;
   sendRestart: () => Promise<null>;
-  sendDocumentTransaction: (
-    request: NotebookDocumentTransactionRequest,
-  ) => Promise<null>;
   sendInstallMissingPackages: (
     request: InstallPackagesRequest,
   ) => Promise<null>;

package/src/core/notebook/document/__tests__/codemirror.test.ts

@@ -84,14 +84,14 @@ function setup({
 } = {}) {
   const store = createStore();
   const source = atom(initial);
-  const controller = new AbortController();
-  lifetimes.push(controller);
   const model = createDocumentModel({
     store,
     documentAtom: source,
     backendAtom: atom(fakeBackend({ edit: () => new Promise(() => {}) })),
-    signal: controller.signal,
   });
+  const controller = new AbortController();
+  lifetimes.push(controller);
+  model.start({ signal: controller.signal });
   const editor = (text = doc) => {
     const view = new EditorView({
       state: EditorState.create({
@@ -326,7 +326,7 @@ describe("cellCodeBinding", () => {
       });
     });
 
-    it("switches language for host code without rewriting it", async () => {
+    it("keeps Python mode for host code without rewriting it", async () => {
       const { store, source, view, code, status } = setup({ adapters: true });
       await settle();
       expect(language(view)).toBe("python");
@@ -337,12 +337,58 @@ describe("cellCodeBinding", () => {
       );
       await settle();
 
-      expect(language(view)).toBe("markdown");
-      expect(view.state.doc.toString()).toBe("hi");
+      expect(language(view)).toBe("python");
+      expect(view.state.doc.toString()).toBe('mo.md("hi")');
       expect(code()).toBe('mo.md("hi")');
       expect(status()).toEqual({ status: "idle" });
     });
 
+    it("keeps Python mode while typing mo.md() and receiving its echo", async () => {
+      const { store, source, view, type } = setup({
+        adapters: true,
+        initial: withCells(document(), { c1: cell("c1", "") }),
+      });
+      await settle();
+      type("mo.md");
+      await settle();
+      type("()");
+      await settle();
+      store.set(source, withCells(document(), { c1: cell("c1", "mo.md()") }));
+      await settle();
+
+      expect(language(view)).toBe("python");
+      expect(view.state.doc.toString()).toBe("mo.md()");
+    });
+
+    it("falls back to Python when host code no longer fits Markdown", async () => {
+      const { store, source, view, code, status } = setup({
+        adapters: true,
+        initial: withCells(document(), { c1: cell("c1", 'mo.md("hi")') }),
+      });
+      await settle();
+      expect(language(view)).toBe("markdown");
+
+      store.set(source, withCells(document(), { c1: cell("c1", "x = 1") }));
+      await settle();
+
+      expect(language(view)).toBe("python");
+      expect(view.state.doc.toString()).toBe("x = 1");
+      expect(code()).toBe("x = 1");
+      expect(status()).toEqual({ status: "idle" });
+    });
+
+    it("preserves Python when typing before the initial pull", async () => {
+      const { view, type } = setup({
+        adapters: true,
+        initial: withCells(document(), { c1: cell("c1", "") }),
+      });
+      type("mo.md()");
+      await settle();
+
+      expect(language(view)).toBe("python");
+      expect(view.state.doc.toString()).toBe("mo.md()");
+    });
+
     it("writes changes to language metadata alone", async () => {
       const { view, code } = setup({
         adapters: true,
@@ -435,15 +481,12 @@ describe("cellCodeBinding", () => {
     });
 
     it("edits SQL as SQL and keeps its output name", async () => {
-      const { store, source, view, code, type } = setup({ adapters: true });
-      await settle();
-
-      store.set(
-        source,
-        withCells(document(), {
+      const { view, code, type } = setup({
+        adapters: true,
+        initial: withCells(document(), {
           c1: cell("c1", 'df = mo.sql(f"""SELECT 1""")'),
         }),
-      );
+      });
       await settle();
       expect(language(view)).toBe("sql");
       expect(view.state.doc.toString()).toBe("SELECT 1");
@@ -456,7 +499,12 @@ describe("cellCodeBinding", () => {
     });
 
     it("sets the SQL dialect from the host's engine", async () => {
-      const { store, source } = setup({ adapters: true });
+      const { store, source } = setup({
+        adapters: true,
+        initial: withCells(document(), {
+          c1: cell("c1", 'df = mo.sql("SELECT 1")'),
+        }),
+      });
       await settle();
       const dialect = vi.spyOn(SCHEMA_CACHE, "getDialect");
       try {
@@ -483,3 +531,17 @@ describe("cellCodeBinding", () => {
     });
   });
 });
+
+describe("cellCodeBinding before the cell has source", () => {
+  it("still infers the language when the source first arrives", async () => {
+    const { store, view, source, type } = setup({
+      initial: null,
+      adapters: true,
+    });
+    type("x");
+    await settle();
+    store.set(source, withCells(document(), { c1: cell("c1", 'mo.md("hi")') }));
+    await settle();
+    expect(view.state.field(languageAdapterState).type).toBe("markdown");
+  });
+});

package/src/core/notebook/document/__tests__/hold.test.ts

@@ -0,0 +1,88 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { atom, createStore } from "jotai";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { Document } from "../../replica/resources/document";
+import { createDocumentModel } from "..";
+import { type FakeEdit, fakeBackend } from "../../replica/__tests__/fixtures";
+import { document } from "./fixtures";
+
+const lifetimes: AbortController[] = [];
+
+afterEach(() => {
+  lifetimes.splice(0).forEach((controller) => controller.abort());
+});
+
+/** The document after the host accepts one edit. */
+function accepted(): Document {
+  const base = document();
+  return {
+    ...base,
+    revision: { ...base.revision, version: 2, etag: "document-2" },
+  };
+}
+
+function setup() {
+  const store = createStore();
+  const source = atom<Document | null>(document());
+  // Answer the edit, then publish the accepted document as the host would.
+  const edit = vi.fn<FakeEdit>().mockImplementation(async () => {
+    queueMicrotask(() => store.set(source, accepted()));
+    return {
+      ok: true,
+      status: 200,
+      data: { document: accepted().revision, cells: {} },
+    };
+  });
+  const model = createDocumentModel({
+    store,
+    documentAtom: source,
+    backendAtom: atom(fakeBackend({ edit })),
+  });
+  const controller = new AbortController();
+  lifetimes.push(controller);
+  model.start({ signal: controller.signal });
+  return { store, model, edit, controller };
+}
+
+describe("document sync hold", () => {
+  it("keeps an edit local until released, then lets a waiting flush send it", async () => {
+    const { store, model, edit } = setup();
+    const release = model.hold();
+    store.set(model.editAtom, (tx) => tx.setCode("c1", "x = 2"));
+    const flushing = model.flush();
+    await Promise.resolve();
+    expect(edit).not.toHaveBeenCalled();
+    expect(store.get(model.syncStatusAtom)).toEqual({ status: "pending" });
+
+    release();
+    await flushing;
+    expect(edit).toHaveBeenCalledTimes(1);
+  });
+
+  it("releases once the last of nested holds is released", async () => {
+    const { store, model, edit } = setup();
+    const outer = model.hold();
+    const inner = model.hold();
+    store.set(model.editAtom, (tx) => tx.setCode("c1", "x = 2"));
+    const flushing = model.flush();
+
+    inner();
+    inner();
+    await Promise.resolve();
+    expect(edit).not.toHaveBeenCalled();
+
+    outer();
+    await flushing;
+    expect(edit).toHaveBeenCalledTimes(1);
+  });
+
+  it("rejects a flush waiting on a hold when the model stops", async () => {
+    const { store, model, controller } = setup();
+    model.hold();
+    store.set(model.editAtom, (tx) => tx.setCode("c1", "x = 2"));
+    const flushing = model.flush();
+    controller.abort(new Error("session ended"));
+    await expect(flushing).rejects.toThrow("session ended");
+  });
+});

package/src/core/notebook/document/__tests__/hooks.test.tsx

@@ -32,14 +32,14 @@ function setup(
   const source = atom(initial);
   const detached = vi.fn();
   source.onMount = () => detached;
-  const controller = new AbortController();
-  lifetimes.push(controller);
   const model = createDocumentModel({
     store,
     documentAtom: source,
     backendAtom: atom(fakeBackend({ edit })),
-    signal: controller.signal,
   });
+  const controller = new AbortController();
+  lifetimes.push(controller);
+  model.start({ signal: controller.signal });
   const wrapper = ({ children }: PropsWithChildren) => (
     <Provider store={store}>
       <DocumentProvider model={model}>{children}</DocumentProvider>

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

@@ -13,7 +13,7 @@ test("closing a session before the debounce prevents submission", async ({
   await vi.advanceTimersByTimeAsync(1000);
   expect(notebook.edit).not.toHaveBeenCalled();
   expect(vi.getTimerCount()).toBe(0);
-  await expect(user.sync()).rejects.toBe(reason);
+  await expect(user.sync()).rejects.toThrow("not started");
 });
 
 test("closing a session before a queued flush starts prevents submission", async ({
@@ -55,7 +55,7 @@ test.for(["request", "confirmation", "retry"] as const)(
     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);
+    await expect(user.sync()).rejects.toThrow("not started");
+    await expect(user.retry()).rejects.toThrow("not started");
   },
 );

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

@@ -52,14 +52,14 @@ function setup({ connected = true } = {}) {
       sent({ notebookId, changes, ...options }),
   });
   const backendAtom = atom<NotebookBackend | null>(connected ? backend : null);
-  const controller = new AbortController();
-  lifetimes.push(controller);
   const model = createDocumentModel({
     store,
     documentAtom: source,
     backendAtom,
-    signal: controller.signal,
   });
+  const controller = new AbortController();
+  lifetimes.push(controller);
+  model.start({ signal: controller.signal });
   return {
     store,
     source,
@@ -85,28 +85,84 @@ afterEach(() => {
 });
 
 describe("document synchronization", () => {
-  it("rejects an aborted lifetime before subscribing or sending", () => {
+  it("subscribes to nothing until started", async () => {
     const store = createStore();
     const source = atom<Document | null>(document());
     const mounted = vi.fn();
     source.onMount = mounted;
-    const controller = new AbortController();
-    const reason = new Error("Session ended");
-    controller.abort(reason);
     const edit = vi.fn<FakeEdit>();
-    expect(() =>
-      createDocumentModel({
-        store,
-        documentAtom: source,
-        backendAtom: atom(fakeBackend({ edit })),
-        signal: controller.signal,
-      }),
-    ).toThrow(reason);
+    const model = createDocumentModel({
+      store,
+      documentAtom: source,
+      backendAtom: atom(fakeBackend({ edit })),
+    });
+    store.set(model.editAtom, (tx) => tx.setCode("c1", "local"));
+    await expect(model.flush()).rejects.toThrow("not started");
+    expect(store.get(model.documentAtom)).toBeNull();
+    expect(store.get(model.syncStatusAtom)).toEqual({ status: "unavailable" });
     expect(mounted).not.toHaveBeenCalled();
     expect(edit).not.toHaveBeenCalled();
     expect(vi.getTimerCount()).toBe(0);
   });
 
+  it("rejects an aborted signal before subscribing", () => {
+    const store = createStore();
+    const source = atom<Document | null>(document());
+    const mounted = vi.fn();
+    source.onMount = mounted;
+    const model = createDocumentModel({
+      store,
+      documentAtom: source,
+      backendAtom: atom(fakeBackend({ edit: vi.fn<FakeEdit>() })),
+    });
+    const reason = new Error("Session ended");
+    expect(() => model.start({ signal: AbortSignal.abort(reason) })).toThrow(
+      reason,
+    );
+    expect(mounted).not.toHaveBeenCalled();
+  });
+
+  it("starts again after a subscriber aborts during startup", async () => {
+    const store = createStore();
+    const model = createDocumentModel({
+      store,
+      documentAtom: atom(document()),
+      backendAtom: atom(null),
+    });
+    const controller = new AbortController();
+    lifetimes.push(controller);
+    const unsubscribe = store.sub(model.documentAtom, () => {
+      if (store.get(model.documentAtom)) {
+        controller.abort();
+      }
+    });
+    model.start({ signal: controller.signal });
+    unsubscribe();
+    expect(controller.signal.aborted).toBe(true);
+    expect(store.get(model.documentAtom)).toBeNull();
+    await expect(model.flush()).rejects.toThrow("not started");
+
+    const next = new AbortController();
+    lifetimes.push(next);
+    model.start({ signal: next.signal });
+    expect(store.get(model.documentAtom)?.cells.get("c1")?.code).toBe("x = 1");
+  });
+
+  it("starts again without the drafts of a stopped run", () => {
+    const { store, model, controller, edit, value } = setup();
+    expect(() => model.start({ signal: new AbortController().signal })).toThrow(
+      "already started",
+    );
+    edit("local");
+    controller.abort();
+    const next = new AbortController();
+    lifetimes.push(next);
+    model.start({ signal: next.signal });
+    expect(value()?.code).toBe("x = 1");
+    store.set(model.editAtom, (tx) => tx.setCode("c1", "restarted"));
+    expect(value()?.code).toBe("restarted");
+  });
+
   it("fails without repeating a request when the response names another notebook", async () => {
     const { sent, replies, edit, model, status } = setup();
     edit("local");

package/src/core/notebook/document/__tests__/scenario-fixture.ts

@@ -15,8 +15,8 @@ function createSession(initial: Document, controller: AbortController) {
     store,
     documentAtom: notebook.documentAtom,
     backendAtom: notebook.backendAtom,
-    signal: controller.signal,
   });
+  model.start({ signal: controller.signal });
   return {
     user: createUser(store, model),
     host: control,