@marimo-team/islands 0.25.3-dev201 → 0.25.3-dev202

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

@@ -43,7 +43,7 @@ export function createStaticRequests(): EditRequests & RunRequests {
     sendRun: throwNotInEditMode,
     sendRunScratchpad: throwNotInEditMode,
     sendRename: throwNotInEditMode,
-    sendSave: throwNotInEditMode,
+    saveLayout: throwNotInEditMode,
     sendCopy: throwNotInEditMode,
     sendInterrupt: throwNotInEditMode,
     sendShutdown: throwNotInEditMode,

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

@@ -24,7 +24,7 @@ export function createErrorToastingRequests(
     sendRun: "Failed to run",
     sendRunScratchpad: "Failed to run scratchpad",
     sendRename: "Failed to rename",
-    sendSave: "Failed to save",
+    saveLayout: "", // The save reports it
     sendCopy: "Failed to copy",
     sendInterrupt: "Failed to interrupt",
     sendShutdown: "Failed to shutdown",

package/src/core/network/types.ts

@@ -95,7 +95,7 @@ export type ExecuteCellsRequest = schemas["ExecuteCellsRequest"];
 export type ExecuteScratchpadRequest = schemas["ExecuteScratchpadRequest"];
 export type SaveAppConfigurationRequest =
   schemas["SaveAppConfigurationRequest"];
-export type SaveNotebookRequest = schemas["SaveNotebookRequest"];
+export type SaveLayoutRequest = schemas["SaveLayoutRequest"];
 export type CopyNotebookRequest = schemas["CopyNotebookRequest"];
 export type SaveUserConfigurationRequest =
   schemas["SaveUserConfigurationRequest"];
@@ -158,7 +158,11 @@ export interface RunRequests {
  */
 export interface EditRequests {
   sendRename: (request: RenameNotebookRequest) => Promise<null>;
-  sendSave: (request: SaveNotebookRequest) => Promise<null>;
+  /**
+   * Write the notebook's layout beside it. The host protocol carries no
+   * layout yet, so this stays a request to the host serving the page.
+   */
+  saveLayout: (request: SaveLayoutRequest) => Promise<null>;
   sendCopy: (request: CopyNotebookRequest) => Promise<null>;
   sendStdin: (request: StdinRequest) => Promise<null>;
   sendRun: (request: ExecuteCellsRequest) => Promise<null>;

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

@@ -31,8 +31,6 @@ export interface DocumentModel {
   flush(): Promise<Protocol.Document>;
   /** Retry a rejection against fresh state, or repeat an uncertain request exactly. */
   retry(): Promise<Protocol.Document>;
-  /** Keep edits local until the returned release is called. A no-op while stopped. */
-  hold(): () => void;
   /**
    * Edit and synchronize until the signal aborts, which discards local drafts.
    * The model can start again once stopped.
@@ -80,7 +78,6 @@ export function createDocumentModel({
     }),
     flush: () => store.get(runningAtom)?.sync.flush() ?? stopped(),
     retry: () => store.get(runningAtom)?.sync.retry() ?? stopped(),
-    hold: () => store.get(runningAtom)?.sync.hold() ?? (() => undefined),
     start({ signal }) {
       signal.throwIfAborted();
       if (store.get(runningAtom)) {

package/src/core/notebook/document/sync.ts

@@ -97,13 +97,6 @@ export function createDocumentSync({
   let failure: Extract<DocumentSyncStatus, { status: "error" }> | null = null;
   let timer: ReturnType<typeof setTimeout> | undefined;
   let refreshing = false;
-  // Holds keep edits local, as a legacy save needs while it writes the
-  // notebook the flush before it produced.
-  let holds = 0;
-  let releaseWaiters: Array<{
-    resolve: () => void;
-    reject: (reason: unknown) => void;
-  }> = [];
 
   function clearTimer() {
     clearTimeout(timer);
@@ -146,11 +139,9 @@ export function createDocumentSync({
         store.set(statusAtom, { status: "idle" });
       } else {
         store.set(statusAtom, { status: "pending" });
-        if (holds === 0) {
-          timer = setTimeout(() => {
-            void flush().catch(() => undefined);
-          }, DEBOUNCE_MS);
-        }
+        timer = setTimeout(() => {
+          void flush().catch(() => undefined);
+        }, DEBOUNCE_MS);
       }
     } finally {
       refreshing = false;
@@ -323,11 +314,6 @@ export function createDocumentSync({
     if (running) {
       return running;
     }
-    if (holds > 0) {
-      return new Promise<void>((resolve, reject) => {
-        releaseWaiters.push({ resolve, reject });
-      }).then(flush);
-    }
     const notebookId =
       active?.submission.notebookId ?? store.get(source)?.revision.notebook_id;
     if (notebookId === undefined) {
@@ -367,52 +353,17 @@ export function createDocumentSync({
     return flush();
   }
 
-  /**
-   * Keep edits local until the returned release is called. Flushes
-   * requested meanwhile wait for it. Holds nest, and a release is
-   * idempotent.
-   *
-   * TODO(MO-8028): Only the legacy save needs this, since the host takes
-   * the notebook it writes as the document. Saving through the host
-   * removes both.
-   */
-  function hold(): () => void {
-    holds += 1;
-    let held = true;
-    return () => {
-      if (!held) {
-        return;
-      }
-      held = false;
-      holds -= 1;
-      if (holds > 0) {
-        return;
-      }
-      const waiters = releaseWaiters;
-      releaseWaiters = [];
-      for (const waiter of waiters) {
-        waiter.resolve();
-      }
-      refresh();
-    };
-  }
-
   const unsubscribe = store.sub(observed, refresh);
   function stop() {
     clearTimer();
     unsubscribe();
     signal.removeEventListener("abort", stop);
     active?.controller.abort(signal.reason);
-    const waiters = releaseWaiters;
-    releaseWaiters = [];
-    for (const waiter of waiters) {
-      waiter.reject(signal.reason);
-    }
   }
   signal.addEventListener("abort", stop, { once: true });
   if (signal.aborted) {
     stop();
   }
   refresh();
-  return { statusAtom, flush, retry, hold };
+  return { statusAtom, flush, retry };
 }

package/src/core/saving/__tests__/document.test.tsx

@@ -0,0 +1,123 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type * as Protocol from "@marimo-team/client/protocol";
+import { renderHook } from "@testing-library/react";
+import { atom, createStore } from "jotai";
+import type { PropsWithChildren } from "react";
+import { describe, expect, it, vi } from "vitest";
+import { DocumentWrapper } from "@/__mocks__/document";
+import { partial } from "@/__mocks__/partial";
+import type {
+  DocumentModel,
+  DocumentSyncStatus,
+} from "@/core/notebook/document";
+import type { NotebookReplica } from "@/core/notebook/replica";
+import {
+  type FakeSave,
+  fakeBackend,
+} from "@/core/notebook/replica/__tests__/fixtures";
+import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
+import { Deferred } from "@/utils/Deferred";
+import { useNotebookDocumentSave } from "../document";
+
+const confirmed: Protocol.Document = {
+  notebook_id: "n1",
+  order: [],
+  app_config: {},
+  etag: "e1",
+  saved_etag: null,
+  order_etag: "o1",
+  app_config_etag: "a1",
+  version: 1,
+};
+
+const saved: FakeSave = async () => ({
+  ok: true,
+  status: 200,
+  data: { document: confirmed, cells: {} },
+});
+
+function setup({
+  flush = vi.fn(async () => confirmed),
+  save = vi.fn(saved),
+  connected = true,
+}: {
+  flush?: DocumentModel["flush"];
+  save?: FakeSave;
+  connected?: boolean;
+} = {}) {
+  const store = createStore();
+  const model = partial<DocumentModel>(
+    {
+      flush,
+      retry: vi.fn(),
+      syncStatusAtom: atom<DocumentSyncStatus>({ status: "idle" }),
+    },
+    "model",
+  );
+  if (connected) {
+    store.set(
+      activeNotebookReplicaAtom,
+      partial<NotebookReplica>(
+        { backendAtom: atom(fakeBackend({ save })) },
+        "replica",
+      ),
+    );
+  }
+  const wrapper = ({ children }: PropsWithChildren) => (
+    <DocumentWrapper store={store} model={model}>
+      {children}
+    </DocumentWrapper>
+  );
+  const { result } = renderHook(() => useNotebookDocumentSave(), { wrapper });
+  return { saveDocument: result.current, flush, save };
+}
+
+describe("useNotebookDocumentSave", () => {
+  it("flushes this client's edits, then saves the flushed notebook", async () => {
+    const flushed = new Deferred<Protocol.Document>();
+    const save = vi.fn(saved);
+    const { saveDocument } = setup({ flush: () => flushed.promise, save });
+    const saving = saveDocument();
+    await Promise.resolve();
+    expect(save).not.toHaveBeenCalled();
+    flushed.resolve(confirmed);
+    await saving;
+    expect(save).toHaveBeenCalledWith("n1");
+  });
+
+  it("does not save when flushing fails", async () => {
+    const save = vi.fn(saved);
+    const { saveDocument } = setup({
+      flush: () => Promise.reject(new Error("unsynchronized edit")),
+      save,
+    });
+    await expect(saveDocument()).rejects.toThrow("unsynchronized edit");
+    expect(save).not.toHaveBeenCalled();
+  });
+
+  it("reports the host's refusal", async () => {
+    const { saveDocument } = setup({
+      save: async () => ({
+        ok: false,
+        status: 409,
+        problem: {
+          type: "about:blank",
+          title: "Conflict",
+          status: 409,
+          detail: "storage full",
+        },
+      }),
+    });
+    await expect(saveDocument()).rejects.toThrow("storage full");
+  });
+
+  it("does not save while no notebook is connected", async () => {
+    const flush = vi.fn(async () => confirmed);
+    const { saveDocument } = setup({ flush, connected: false });
+    await expect(saveDocument()).rejects.toThrow(
+      "The notebook is not connected",
+    );
+    expect(flush).not.toHaveBeenCalled();
+  });
+});

package/src/core/saving/document.ts

@@ -0,0 +1,33 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+/** Save the host's document from React. */
+
+import { useAtomValue } from "jotai";
+import { useCallback } from "react";
+import { useNotebookDocumentSync } from "@/core/notebook/document";
+import { activeNotebookBackendAtom } from "../session/active-notebook";
+
+/**
+ * Save the notebook's document through its host. This client's edits are
+ * flushed first, so the host writes nothing older than what the editor
+ * shows, and a failure at either step rejects.
+ *
+ * ```ts
+ * const saveDocument = useNotebookDocumentSave();
+ * await saveDocument();
+ * ```
+ */
+export function useNotebookDocumentSave() {
+  const { flush } = useNotebookDocumentSync();
+  const backend = useAtomValue(activeNotebookBackendAtom);
+  return useCallback(async () => {
+    if (backend === null) {
+      throw new Error("The notebook is not connected");
+    }
+    const { notebook_id } = await flush();
+    const result = await backend.notebook(notebook_id).save();
+    if (!result.ok) {
+      throw new Error(result.problem.detail ?? result.problem.title);
+    }
+  }, [flush, backend]);
+}

package/src/core/saving/save-component.tsx

@@ -20,8 +20,8 @@ import {
 import { Label } from "../../components/ui/label";
 import { useEvent } from "../../hooks/useEvent";
 import { Logger } from "../../utils/Logger";
-import { getCellConfigs, getNotebook } from "../cells/cells";
-import { flushDocument, withDocumentSave } from "../cells/document";
+import { toast } from "@/components/ui/use-toast";
+import { getNotebook } from "../cells/cells";
 import { notebookCells } from "../cells/utils";
 import { formatAll } from "../codemirror/format";
 import { autoSaveConfigAtom } from "../config/config";
@@ -32,9 +32,9 @@ import { connectionAtom } from "../network/connection";
 import { canEditAtom } from "@/core/notebook";
 import { useRequestClient } from "../network/requests";
 import { ConnectionState } from "../session/types";
-import { isWasm } from "../wasm/utils";
 import { filenameAtom } from "./file-state";
 import { useFilename, useUpdateFilename } from "./filename";
+import { useNotebookDocumentSave } from "./document";
 import { documentVersionAtom, needsSaveAtom, savedLayoutAtom } from "./state";
 import { useAutoSave } from "./useAutoSave";
 
@@ -99,13 +99,14 @@ export const SaveComponent = () => {
 };
 
 export function useSaveNotebook() {
-  const { sendSave } = useRequestClient();
+  const { saveLayout } = useRequestClient();
+  const saveDocument = useNotebookDocumentSave();
   const { openModal, closeModal, openAlert } = useImperativeModal();
   const updateFilename = useUpdateFilename();
   const store = useStore();
 
-  // Save the notebook with the given filename
-  const saveNotebook = useEvent((filename: string, userInitiated: boolean) =>
+  // Save the notebook the host has a file for.
+  const saveNotebook = useEvent((userInitiated: boolean) =>
     enqueueNotebookSave(async () => {
       const connection = store.get(connectionAtom);
       const autoSaveConfig = store.get(autoSaveConfigAtom);
@@ -121,8 +122,6 @@ export function useSaveNotebook() {
         return;
       }
 
-      Logger.log("saving to ", filename);
-
       if (userInitiated && autoSaveConfig.format_on_save) {
         Logger.log("formatting notebook (onSave)");
         await formatAll();
@@ -132,34 +131,22 @@ export function useSaveNotebook() {
         return;
       }
 
-      const save = async () => {
-        // Grab the latest notebook state after formatting and after every
-        // earlier document transaction has reached the server.
-        const notebook = getNotebook();
-        const cells = notebookCells(notebook);
-        const cellIds = cells.map((cell) => cell.id);
-        const codes = cells.map((cell) => cell.code);
-        const cellNames = cells.map((cell) => cell.name);
-        const configs = getCellConfigs(notebook);
-        const layout = store.get(layoutStateAtom);
-
-        await sendSave({
-          cellIds: cellIds,
-          codes,
-          names: cellNames,
-          filename,
-          configs,
-          layout: getSerializedLayout(),
-          persist: true,
+      // The notebook is the host's document plus a layout the editor keeps
+      // beside it. TODO: fold the layout into the host document.
+      const layout = store.get(layoutStateAtom);
+      try {
+        await saveLayout({ layout: getSerializedLayout() });
+        await saveDocument();
+      } catch (error) {
+        Logger.error("Failed to save notebook", error);
+        toast({
+          title: "Failed to save",
+          description: error instanceof Error ? error.message : String(error),
+          variant: "danger",
         });
-        return layout;
-      };
-      // TODO(MO-7955): Remove this conditional once all frontend saves use
-      // the host protocol. Host saves cannot recover edits from an editor snapshot.
-      const savedLayout = isWasm()
-        ? await flushDocument().then(save)
-        : await withDocumentSave(save);
-      store.set(savedLayoutAtom, savedLayout);
+        return;
+      }
+      store.set(savedLayoutAtom, layout);
     }),
   );
 
@@ -171,14 +158,14 @@ export function useSaveNotebook() {
       isNamedPersistentFile(filename) &&
       connection.state === ConnectionState.OPEN
     ) {
-      saveNotebook(filename, userInitiated);
+      saveNotebook(userInitiated);
     }
   });
 
   const handleSaveDialog = (pythonFilename: string) => {
     updateFilename(pythonFilename).then((name) => {
       if (name !== null) {
-        saveNotebook(name, true);
+        saveNotebook(true);
       }
     });
   };

package/src/core/session/active-notebook.ts

@@ -10,6 +10,12 @@ export const activeNotebookReplicaAtom = atom<NotebookReplica | null>(null);
 /** The document model owned by the mounted notebook session. */
 export const activeDocumentModelAtom = atom<DocumentModel | null>(null);
 
+/** The backend of the connected notebook, or null while none is. */
+export const activeNotebookBackendAtom = atom((get) => {
+  const replica = get(activeNotebookReplicaAtom);
+  return replica === null ? null : get(replica.backendAtom);
+});
+
 /**
  * The document the host last confirmed, or null while no notebook is
  * connected. Facts the host owns read this one, such as permission, the

package/src/core/wasm/__tests__/bridge.test.ts

@@ -1,7 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { cellId } from "@/__tests__/branded";
 import { Deferred } from "@/utils/Deferred";
 
 const {
@@ -11,7 +10,6 @@ const {
   mockWriteNotebook,
   mockNotebookCall,
   mockSetNotebookLayout,
-  mockFlush,
   parentRequests,
   mockBootstrap,
   rpcListeners,
@@ -24,7 +22,6 @@ const {
   mockWriteNotebook: vi.fn(),
   mockNotebookCall: vi.fn(),
   mockSetNotebookLayout: vi.fn(),
-  mockFlush: vi.fn(),
   parentRequests: {} as {
     persistNotebook?: (snapshot: {
       filename: string;
@@ -101,18 +98,9 @@ vi.mock("@/core/wasm/store", () => ({
   notebookFileStore: { readFile: mockNotebookReadFile, saveFile: vi.fn() },
 }));
 
-vi.mock("@/core/cells/document", async (importOriginal) => ({
-  ...(await importOriginal<typeof import("@/core/cells/document")>()),
-  flushDocument: mockFlush,
-}));
-
 // Import after all mocks are set up
 import { store } from "@/core/state/jotai";
 import { initialModeAtom } from "@/core/mode";
-import { fixtureEvents } from "@/core/notebook/replica/__tests__/fixtures";
-import { createNotebookReplica } from "@/core/notebook/replica";
-import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
-import { createEditorBackend } from "@/core/session/backend";
 import { fallbackFileStore, notebookFileStore } from "../store";
 import { getWasmWorkerName, PyodideBridge } from "../bridge";
 
@@ -200,130 +188,18 @@ describe("PyodideBridge.exportAsScript", () => {
   });
 });
 
-describe("PyodideBridge.sendSave", () => {
-  let disconnect: () => void;
-  const request = {
-    cellIds: [cellId("cell-1")],
-    codes: ['value = "NEW"'],
-    names: ["_"],
-    filename: "notebook.py",
-    configs: [{}],
-    layout: null,
-    persist: true,
-  };
-
-  beforeEach(async () => {
+describe("PyodideBridge notebook persistence", () => {
+  beforeEach(() => {
     vi.clearAllMocks();
     store.set(initialModeAtom, "edit");
     rpcListeners.initialized();
-    mockFlush.mockResolvedValue(undefined);
     mockWriteNotebook.mockResolvedValue(undefined);
-    mockNotebookUnsubscribe.mockResolvedValue(undefined);
-    const document = fixtureEvents("notebook-events.sse").find(
-      (event) => event.event === "document",
-    )?.data.document;
-    mockNotebookCall.mockResolvedValue({
-      status: 200,
-      body: { document, cells: {} },
-    });
-    mockNotebookSubscribe.mockImplementation(async ({ id }) => {
-      for (const event of fixtureEvents("notebook-events.sse")) {
-        rpcListeners.notebookEvent({ id, event: JSON.stringify(event) });
-      }
-    });
-    const replica = createNotebookReplica(store);
-    store.set(activeNotebookReplicaAtom, replica);
-    const backend = createEditorBackend({
-      static: false,
-      snapshot: null,
-      transportType: "sse",
-      url: () => "http://localhost/",
-      headers: () => ({}),
-      notebookUrl: (id) => new URL(`http://localhost/notebooks/${id}`),
-      waitUntilReady: async () => undefined,
-      checkHealth: async () => true,
-    });
-    disconnect = replica.connect(backend, { onNotification: vi.fn() });
-    await vi.waitFor(() =>
-      expect(store.get(replica.notebookAtom)?.id).toBe("n1"),
-    );
   });
 
   afterEach(() => {
-    disconnect();
-    store.set(activeNotebookReplicaAtom, null);
     store.set(initialModeAtom, undefined);
   });
 
-  it("saves through the connected backend using the stream's notebook ID", async () => {
-    const bridge = PyodideBridge.INSTANCE;
-    const createBackend = vi.spyOn(bridge, "createNotebookBackend");
-    await bridge.sendSave(request);
-    expect(createBackend).not.toHaveBeenCalled();
-    expect(mockNotebookCall).toHaveBeenCalledWith(
-      expect.objectContaining({
-        operation: "notebook.save",
-        params: { notebook_id: "n1" },
-        body: {},
-      }),
-    );
-  });
-
-  it.each(["unmounted", "not ready", "disconnected"])(
-    "does not save when the notebook is %s",
-    async (state) => {
-      if (state === "unmounted") {
-        store.set(activeNotebookReplicaAtom, null);
-      } else if (state === "not ready") {
-        store.set(activeNotebookReplicaAtom, createNotebookReplica(store));
-      } else {
-        disconnect();
-      }
-      await expect(PyodideBridge.INSTANCE.sendSave(request)).rejects.toThrow(
-        "The notebook is not connected",
-      );
-      expect(mockNotebookCall).not.toHaveBeenCalled();
-    },
-  );
-
-  it("flushes edits before asking the host to save without an editor snapshot", async () => {
-    const flushed = new Deferred<void>();
-    mockFlush.mockReturnValueOnce(flushed.promise);
-    const saving = PyodideBridge.INSTANCE.sendSave(request);
-    await Promise.resolve();
-    expect(mockNotebookCall).not.toHaveBeenCalled();
-    flushed.resolve();
-    await saving;
-    expect(mockSetNotebookLayout).toHaveBeenCalledWith(null);
-    expect(mockNotebookCall).toHaveBeenCalledWith(
-      expect.objectContaining({ operation: "notebook.save", body: {} }),
-    );
-    expect(mockWriteNotebook).not.toHaveBeenCalled();
-  });
-
-  it("does not save when flushing fails", async () => {
-    mockFlush.mockRejectedValueOnce(new Error("unsynchronized edit"));
-    await expect(PyodideBridge.INSTANCE.sendSave(request)).rejects.toThrow(
-      "unsynchronized edit",
-    );
-    expect(mockNotebookCall).not.toHaveBeenCalled();
-  });
-
-  it("reports host persistence failures", async () => {
-    mockNotebookCall.mockResolvedValueOnce({
-      status: 409,
-      body: {
-        type: "tag:marimo.io,2026:host/conflict",
-        title: "Conflict",
-        status: 409,
-        detail: "storage full",
-      },
-    });
-    await expect(PyodideBridge.INSTANCE.sendSave(request)).rejects.toThrow(
-      "storage full",
-    );
-  });
-
   it("persists exactly the host's content before acknowledging storage", async () => {
     const durable = new Deferred<void>();
     const snapshot = { filename: "notebook.py", contents: "# host revision" };

package/src/core/wasm/bridge.ts

@@ -42,7 +42,6 @@ import type {
 } from "../network/types";
 import { filenameAtom } from "../saving/file-state";
 import { store } from "../state/jotai";
-import { activeNotebookReplicaAtom } from "../session/active-notebook";
 import { PyodideRouter } from "./router";
 import { getWorkerRPC, type PersistNotebookRequest } from "./rpc";
 import { getWasmRuntimeConfig } from "./runtime-config";
@@ -266,23 +265,8 @@ export class PyodideBridge implements RunRequests, EditRequests {
     return null;
   };
 
-  private async saveHostNotebook() {
-    const replica = store.get(activeNotebookReplicaAtom);
-    const notebook = replica && store.get(replica.notebookAtom);
-    const backend = replica && store.get(replica.backendAtom);
-    if (!notebook || !backend) {
-      throw new Error("The notebook is not connected");
-    }
-    const result = await backend.notebook(notebook.id).save();
-    if (!result.ok) {
-      throw new Error(result.problem.detail ?? result.problem.title);
-    }
-  }
-
-  public sendSave: EditRequests["sendSave"] = async ({ layout }) => {
-    await flushDocument();
+  public saveLayout: EditRequests["saveLayout"] = async ({ layout }) => {
     await this.rpc.proxy.request.setNotebookLayout(layout ?? null);
-    await this.saveHostNotebook();
     return null;
   };
 
@@ -391,7 +375,6 @@ export class PyodideBridge implements RunRequests, EditRequests {
       functionName: "save_app_config",
       payload: request,
     });
-    await this.saveHostNotebook();
     return null;
   };
 

package/src/core/wasm/worker/worker.ts

@@ -12,7 +12,7 @@ import type { UserConfig } from "@/core/config/config-schema";
 import type {
   ListPackagesResponse,
   PackageOperationResponse,
-  SaveNotebookRequest,
+  SaveLayoutRequest,
 } from "@/core/network/types";
 import { decodeUtf8 } from "@/utils/strings";
 import { Deferred } from "../../../utils/Deferred";
@@ -301,7 +301,7 @@ const requestHandler = createRPCRequestHandler({
     };
   },
 
-  setNotebookLayout: async (layout: SaveNotebookRequest["layout"]) => {
+  setNotebookLayout: async (layout: SaveLayoutRequest["layout"]) => {
     const notebook = await getNotebook();
     try {
       await notebook.set_layout(JSON.stringify(layout));