@marimo-team/islands 0.25.3-dev173 → 0.25.3-dev175

package/src/core/cells/document.ts

@@ -27,7 +27,7 @@ import type { CellConfig } from "../network/types";
 import { canUseRtc, isRtcEnabled } from "../rtc/state";
 import { store } from "../state/jotai";
 import { activeDocumentModelAtom } from "../session/active-notebook";
-import type { CellActions, NotebookState } from "./cells";
+import type { NotebookState, ReducerCellActions } from "./cells";
 import { groupByColumn } from "./columns";
 import type { CellId } from "./ids";
 import {
@@ -38,7 +38,7 @@ import {
   isEdited,
 } from "./types";
 
-type CellAction = DispatchedActionOf<CellActions>;
+type CellAction = DispatchedActionOf<ReducerCellActions>;
 
 // Following the document ----------------------------------------------------
 
@@ -126,14 +126,17 @@ export function applyDocument(
       continue;
     }
     if (current === undefined) {
-      // A new cell has no run to be edited from.
+      // A new cell with code is stale until it runs. The kernel's last run
+      // settles it on kernel-ready.
+      const code = cell.code ?? "";
       cellData = {
         ...cellData,
         [id]: createCell({
           id,
-          code: cell.code ?? "",
+          code,
           name: cell.name,
           config: createCellConfig(cell.config),
+          edited: code.trim().length > 0,
         }),
       };
       cellRuntime = { ...cellRuntime, [id]: createCellRuntimeState() };

package/src/core/cells/outputs.ts

@@ -1,15 +1,15 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { useAtomValue } from "jotai";
-import { selectAtom } from "jotai/utils";
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useState } from "react";
 import { useEvent } from "@/hooks/useEvent";
-import { Logger } from "@/utils/Logger";
+import {
+  useNotebookCellConfig,
+  useNotebookDocumentEdit,
+} from "../notebook/document";
 import type { OutputMessage } from "../kernel/messages";
 import { viewStateAtom } from "../mode";
-import { getRequestClient } from "../network/requests";
-import { cellDataAtom, useCellActions } from "./cells";
-import type { CellId } from "./ids";
+import { type CellId, SCRATCH_CELL_ID } from "./ids";
 
 // This does not need to be overcomplicated. We can just store the expanded
 // state in a global map instead of Jotai since state is not shared between cells.
@@ -27,20 +27,9 @@ const expandedConsoleOutputs: Record<CellId, boolean> = {};
  */
 export function useExpandedOutput(cellId: CellId) {
   const { mode } = useAtomValue(viewStateAtom);
-  const { updateCellConfig } = useCellActions();
-  // Select just the flag: every output would otherwise re-render on each
-  // keystroke in its cell.
-  const isConfigExpanded = useAtomValue(
-    useMemo(
-      () =>
-        selectAtom(
-          cellDataAtom(cellId),
-          (data) => data?.config.expand_output ?? false,
-          Object.is,
-        ),
-      [cellId],
-    ),
-  );
+  const edit = useNotebookDocumentEdit();
+  const isConfigExpanded =
+    useNotebookCellConfig(cellId)?.expand_output ?? false;
   const [isSessionExpanded, setIsSessionExpanded] = useState(
     () => expandedOutputs[cellId] ?? isConfigExpanded,
   );
@@ -55,16 +44,11 @@ export function useExpandedOutput(cellId: CellId) {
 
   const setIsExpanded = useEvent((expanded: boolean) => {
     setIsSessionExpanded(expanded);
-    if (!isEditable) {
+    // The scratchpad is not in the document.
+    if (!isEditable || cellId === SCRATCH_CELL_ID) {
       return;
     }
-    const config = { expand_output: expanded };
-    updateCellConfig({ cellId, config });
-    getRequestClient()
-      .saveCellConfig({ configs: { [cellId]: config } })
-      .catch((error) => {
-        Logger.error("Failed to save expand_output config", error);
-      });
+    edit((tx) => tx.updateConfig(cellId, { expand_output: expanded }));
   });
 
   return [isExpanded, setIsExpanded] as const;

package/src/core/codemirror/cells/extensions.ts

@@ -190,7 +190,7 @@ function cellKeymaps({
 
           if (isAtStartOfEditor(ev)) {
             const actions = ev.state.facet(cellActionsState);
-            actions.moveToNextCell({ cellId, before: true, noCreate: true });
+            actions.moveToNextCell({ cellId, before: true, create: false });
             return true;
           }
           return false;
@@ -207,7 +207,7 @@ function cellKeymaps({
 
           if (isAtEndOfEditor(ev)) {
             const actions = ev.state.facet(cellActionsState);
-            actions.moveToNextCell({ cellId, before: false, noCreate: true });
+            actions.moveToNextCell({ cellId, before: false, create: false });
             return true;
           }
           return false;
@@ -219,7 +219,7 @@ function cellKeymaps({
         stopPropagation: true,
         run: (ev) => {
           const actions = ev.state.facet(cellActionsState);
-          actions.moveToNextCell({ cellId, before: false, noCreate: true });
+          actions.moveToNextCell({ cellId, before: false, create: false });
           return true;
         },
       },
@@ -229,7 +229,7 @@ function cellKeymaps({
         stopPropagation: true,
         run: (ev) => {
           const actions = ev.state.facet(cellActionsState);
-          actions.moveToNextCell({ cellId, before: true, noCreate: true });
+          actions.moveToNextCell({ cellId, before: true, create: false });
           return true;
         },
       },
@@ -260,7 +260,7 @@ function cellKeymaps({
         run: (ev) => {
           ev.contentDOM.blur();
           const actions = ev.state.facet(cellActionsState);
-          actions.createNewCell({ cellId, before: true });
+          actions.createCell({ before: cellId });
           return true;
         },
       },
@@ -271,7 +271,7 @@ function cellKeymaps({
         run: (ev) => {
           ev.contentDOM.blur();
           const actions = ev.state.facet(cellActionsState);
-          actions.createNewCell({ cellId, before: false });
+          actions.createCell({ after: cellId });
           return true;
         },
       },

package/src/core/codemirror/cells/state.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { Facet } from "@codemirror/state";
-import type { CellActions } from "@/core/cells/cells";
+import type { CellActions } from "@/core/cells/actions";
 import type { CellId } from "@/core/cells/ids";
 
 export interface CodemirrorCellActions extends CellActions {

package/src/core/codemirror/keymaps/vim.ts

@@ -37,7 +37,7 @@ export function vimKeymapExtension(): Extension[] {
           if (isAtEndOfEditor(ev, true) && isInVimNormalMode(ev)) {
             const actions = ev.state.facet(cellActionsState);
             const cellId = ev.state.facet(cellIdState);
-            actions.moveToNextCell({ cellId, before: false, noCreate: true });
+            actions.moveToNextCell({ cellId, before: false, create: false });
             return true;
           }
           return false;
@@ -51,7 +51,7 @@ export function vimKeymapExtension(): Extension[] {
           if (isAtStartOfEditor(ev) && isInVimNormalMode(ev)) {
             const actions = ev.state.facet(cellActionsState);
             const cellId = ev.state.facet(cellIdState);
-            actions.moveToNextCell({ cellId, before: true, noCreate: true });
+            actions.moveToNextCell({ cellId, before: true, create: false });
             return true;
           }
           return false;

package/src/core/edit-app.tsx

@@ -5,8 +5,8 @@ import { Tooltip } from "radix-ui";
 
 const TooltipProvider = Tooltip.Provider;
 
-import { useAtomValue, useSetAtom, useStore } from "jotai";
-import { useEffect } from "react";
+import { useAtomValue } from "jotai";
+import { lazy, useEffect } from "react";
 import { NotStartedConnectionAlert } from "@/components/editor/alerts/connecting-alert";
 import { Controls } from "@/components/editor/controls/Controls";
 import { SandboxController } from "@/components/editor/chrome/panels/sandbox-controller";
@@ -29,24 +29,23 @@ import { CellsRenderer } from "../components/editor/renderers/cells-renderer";
 import { useHotkey } from "../hooks/useHotkey";
 import {
   hasCellsAtom,
-  notebookAtom,
   notebookIsRunningAtom,
   numColumnsAtom,
-  useCellActions,
 } from "./cells/cells";
-import { notebookCells } from "./cells/utils";
+import { useCellActions } from "./cells/actions";
 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";
 import { viewStateAtom } from "./mode";
 import { useRequestClient } from "./network/requests";
 import { useFilename } from "./saving/filename";
-import { lastSavedNotebookAtom } from "./saving/state";
-import { useNotebookSession } from "./session/useNotebookSession";
+import type { ConnectionStatus } from "./session/types";
 
-interface AppProps {
+const LazyCommandPalette = lazy(
+  () => import("../components/editor/controls/command-palette"),
+);
+
+export interface EditAppProps {
   /**
    * The user config.
    */
@@ -59,20 +58,24 @@ interface AppProps {
    * If true, the floating controls will be hidden.
    */
   hideControls?: boolean;
+  /** The session's connection, which the page owns with the document model. */
+  connection: ConnectionStatus;
+  reconnect: () => Promise<void>;
 }
 
-export const EditApp: React.FC<AppProps> = ({
+/** The notebook editor. Rendered inside the page's `DocumentProvider`. */
+export const EditApp: React.FC<EditAppProps> = ({
   userConfig,
   appConfig,
   hideControls = false,
+  connection,
+  reconnect,
 }) => {
   const { mergeAllColumns, collapseAllCells, expandAllCells } =
     useCellActions();
-  const store = useStore();
   const viewState = useAtomValue(viewStateAtom);
   const numColumns = useAtomValue(numColumnsAtom);
   const filename = useFilename();
-  const setLastSavedNotebook = useSetAtom(lastSavedNotebookAtom);
   const { sendComponentValues, sendInterrupt } = useRequestClient();
 
   const isEditing = viewState.mode === "edit";
@@ -87,18 +90,6 @@ export const EditApp: React.FC<AppProps> = ({
     };
   }, [sendComponentValues]);
 
-  const { connection, reconnect, documentModel } = useNotebookSession({
-    autoInstantiate: userConfig.runtime.auto_instantiate,
-    onKernelReady: (layout) => {
-      const cells = notebookCells(store.get(notebookAtom));
-      const names = cells.map((cell) => cell.name);
-      const codes = cells.map((cell) => cell.code);
-      const configs = cells.map((cell) => cell.config);
-      setLastSavedNotebook({ names, codes, configs, layout });
-    },
-    sessionId: getSessionId(),
-  });
-
   // Update document title whenever filename or app_title changes
   useEffect(() => {
     // Set document title: app_title takes precedence, then filename, then default
@@ -178,7 +169,7 @@ export const EditApp: React.FC<AppProps> = ({
   );
 
   return (
-    <DocumentProvider model={documentModel}>
+    <>
       <SandboxController onReconnect={reconnect} />
       <AppContainer
         connection={connection}
@@ -232,6 +223,7 @@ export const EditApp: React.FC<AppProps> = ({
           />
         </TooltipProvider>
       )}
-    </DocumentProvider>
+      <LazyCommandPalette />
+    </>
   );
 };

package/src/core/islands/bridge.ts

@@ -383,12 +383,10 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   public sendInterrupt = throwNotImplemented;
   public sendShutdown = throwNotImplemented;
   public sendFormat = throwNotImplemented;
-  public sendDeleteCell = throwNotImplemented;
   public sendInstallMissingPackages = throwNotImplemented;
   public sendCodeCompletionRequest = throwNotImplemented;
   public saveUserConfig = throwNotImplemented;
   public saveAppConfig = throwNotImplemented;
-  public saveCellConfig = throwNotImplemented;
   public sendRestart = throwNotImplemented;
   public readCode = throwNotImplemented;
   public readSnippets = throwNotImplemented;

package/src/core/kernel/handlers.ts

@@ -3,7 +3,7 @@ import type { LayoutType } from "@/components/editor/renderers/types";
 import { Logger } from "@/utils/Logger";
 import { Objects } from "@/utils/objects";
 import type { UIElementId } from "../cells/ids";
-import type { CellActions } from "../cells/cells";
+import type { ReducerCellActions } from "../cells/cells";
 import type { CellData } from "../cells/types";
 import { type AppConfig, AppConfigSchema } from "../config/config-schema";
 import { UI_ELEMENT_REGISTRY } from "../dom/uiregistry";
@@ -63,8 +63,8 @@ export function handleKernelReady(
     autoInstantiate: boolean;
     /** The notebook's cells, as the host document provided them. */
     cells: CellData[];
-    setLastRun: CellActions["setLastRun"];
-    resetCellRuntimes: CellActions["resetCellRuntimes"];
+    setLastRun: ReducerCellActions["setLastRun"];
+    resetCellRuntimes: ReducerCellActions["resetCellRuntimes"];
     setLayoutData: (payload: {
       layoutView: LayoutType;
       data: LayoutData;

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

@@ -53,7 +53,6 @@ describe("createLazyRequests", () => {
       sendInstantiate: vi.fn().mockResolvedValue({ instantiated: true }),
       sendFunctionRequest: vi.fn().mockResolvedValue({ result: "data" }),
       sendRestart: vi.fn().mockResolvedValue({ restarted: true }),
-      sendDeleteCell: vi.fn().mockResolvedValue({ deleted: true }),
       sendInterrupt: vi.fn().mockResolvedValue({ interrupted: true }),
       sendPdb: vi.fn().mockResolvedValue({ pdb: true }),
       sendRunScratchpad: vi.fn().mockResolvedValue({ run: true }),
@@ -320,7 +319,6 @@ describe("createLazyRequests", () => {
         cellIds: [cellId("cell1")],
         codes: ["code"],
       });
-      await lazyRequests.sendDeleteCell({ cellId: cellId("cell2") });
       await lazyRequests.sendInstantiate({
         objectIds: [uiElementId("obj1")],
         values: [],
@@ -328,7 +326,7 @@ describe("createLazyRequests", () => {
 
       // Init should only be called once
       expect(mockInit).toHaveBeenCalledTimes(1);
-      expect(mockGetRuntimeManager).toHaveBeenCalledTimes(3);
+      expect(mockGetRuntimeManager).toHaveBeenCalledTimes(2);
     });
   });
 });

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

@@ -52,10 +52,8 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   sendModelValue: "startConnection",
   sendInstantiate: "startConnectionWithoutKernel",
   sendRun: "startConnection",
-  sendDeleteCell: "startConnection",
   sendRunScratchpad: "startConnection",
   saveAppConfig: "startConnection",
-  saveCellConfig: "startConnection",
   discoverDataSources: "startConnection",
 
   // Export operations start a connection

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

@@ -142,14 +142,6 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
-    sendDeleteCell: (request) => {
-      return getClient()
-        .POST("/api/kernel/delete", {
-          body: request,
-          params: getParams(),
-        })
-        .then(handleResponseReturnNull);
-    },
     sendCodeCompletionRequest: async (request) => {
       await waitForConnectionOpen();
       return getClient()
@@ -175,14 +167,6 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
-    saveCellConfig: (request) => {
-      return getClient()
-        .POST("/api/kernel/set_cell_config", {
-          body: request,
-          params: getParams(),
-        })
-        .then(handleResponseReturnNull);
-    },
     sendFunctionRequest: (request) => {
       return getClient()
         .POST("/api/kernel/function_call", {

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

@@ -48,11 +48,9 @@ export function createStaticRequests(): EditRequests & RunRequests {
     sendInterrupt: throwNotInEditMode,
     sendShutdown: throwNotInEditMode,
     sendFormat: throwNotInEditMode,
-    sendDeleteCell: throwNotInEditMode,
     sendCodeCompletionRequest: throwNotInEditMode,
     saveUserConfig: throwNotInEditMode,
     saveAppConfig: throwNotInEditMode,
-    saveCellConfig: throwNotInEditMode,
     sendStdin: throwNotInEditMode,
     readCode: throwNotInEditMode,
     readSnippets: throwNotInEditMode,

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

@@ -29,11 +29,9 @@ export function createErrorToastingRequests(
     sendInterrupt: "Failed to interrupt",
     sendShutdown: "Failed to shutdown",
     sendFormat: "Failed to format",
-    sendDeleteCell: "Failed to delete cell",
     sendCodeCompletionRequest: "Failed to complete code",
     saveUserConfig: "Failed to save user config",
     saveAppConfig: "Failed to save app config",
-    saveCellConfig: "Failed to save cell config",
     sendStdin: "Failed to send stdin",
     readCode: "Failed to read code",
     readSnippets: "Failed to fetch snippets",

package/src/core/network/types.ts

@@ -1,6 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import type { components, paths } from "@marimo-team/marimo-api";
-import type { CellId } from "../cells/ids";
 
 export type schemas = components["schemas"];
 export type AiCompletionRequest = schemas["AiCompletionRequest"];
@@ -16,7 +15,6 @@ export type CellConfig = schemas["CellConfig"];
  */
 export type RuntimeState = schemas["CellNotification"]["status"];
 export type CodeCompletionRequest = schemas["CodeCompletionRequest"];
-export type DeleteCellRequest = schemas["DeleteCellRequest"];
 export type AutoExportAsIPYNBRequest = schemas["AutoExportAsIPYNBRequest"];
 export type AutoExportAsMarkdownRequest =
   schemas["AutoExportAsMarkdownRequest"];
@@ -101,9 +99,6 @@ export type SaveNotebookRequest = schemas["SaveNotebookRequest"];
 export type CopyNotebookRequest = schemas["CopyNotebookRequest"];
 export type SaveUserConfigurationRequest =
   schemas["SaveUserConfigurationRequest"];
-export interface SetCellConfigRequest {
-  configs: Record<CellId, Partial<CellConfig>>;
-}
 /**
  * Client-side shape for creating a file/directory/notebook. The HTTP
  * transport sends this as multipart/form-data; the WASM bridge base64-encodes
@@ -171,11 +166,9 @@ export interface EditRequests {
   sendInterrupt: () => Promise<null>;
   sendShutdown: () => Promise<null>;
   sendFormat: (request: FormatCellsRequest) => Promise<FormatResponse>;
-  sendDeleteCell: (request: DeleteCellRequest) => Promise<null>;
   sendCodeCompletionRequest: (request: CodeCompletionRequest) => Promise<null>;
   saveUserConfig: (request: SaveUserConfigurationRequest) => Promise<null>;
   saveAppConfig: (request: SaveAppConfigurationRequest) => Promise<null>;
-  saveCellConfig: (request: SetCellConfigRequest) => Promise<null>;
   sendRestart: () => Promise<null>;
   sendInstallMissingPackages: (
     request: InstallPackagesRequest,

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

@@ -60,6 +60,11 @@ function languages(id: CellId) {
       aiCellCompletion: () => false,
       createManyBelow: vi.fn(),
       addOrAppendSetupCell: vi.fn(),
+      createCell: vi.fn(),
+      moveToNextCell: vi.fn(),
+      addSetupCell: vi.fn(),
+      deleteCells: vi.fn(),
+      undoDeleteCell: vi.fn(),
       onRun: vi.fn(),
       deleteCell: vi.fn(),
       afterToggleMarkdown: vi.fn(),

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

@@ -9,6 +9,7 @@ import {
   type EditableCell,
   editCell,
   EMPTY_DRAFT,
+  restoreCell,
   setOrder,
   toChanges,
   viewDocument,
@@ -99,6 +100,46 @@ describe("createCell and deleteCell", () => {
     expect(toChanges(confirmed, draft)).toEqual([]);
     expect(viewDocument(confirmed, draft).order).toEqual(["c1", "c2"]);
   });
+
+  it("restores a deleted cell as an edit at the requested place", () => {
+    const deleted = deleteCell(EMPTY_DRAFT, "c1");
+    const back = { id: "c1", code: "back" };
+    const put = {
+      kind: "put_cell",
+      base_etag: "c1-etag",
+      cell: { ...back, name: "_", config: CONFIG },
+    };
+    const inPlace = restoreCell(confirmed, deleted, back, { before: "c2" });
+    const moved = restoreCell(confirmed, deleted, back, { after: "c2" });
+    expect(viewDocument(confirmed, inPlace).cells.get("c1")?.code).toBe("back");
+    expect(viewDocument(confirmed, inPlace).order).toEqual(["c1", "c2"]);
+    expect(toChanges(confirmed, inPlace)).toEqual([put]);
+    expect(viewDocument(confirmed, moved).order).toEqual(["c2", "c1"]);
+    expect(toChanges(confirmed, moved)).toEqual([
+      put,
+      { kind: "set_order", base_etag: "order-1", order: ["c2", "c1"] },
+    ]);
+  });
+
+  it("recreates a cell whose deletion is in flight once the host removes it", () => {
+    const sent = deleteCell(EMPTY_DRAFT, "c1");
+    const back = { id: "c1", code: "back" };
+    const draft = restoreCell(confirmed, sent, back, { before: "c2" }, sent);
+    expect(viewDocument(confirmed, draft).cells.get("c1")?.code).toBe("back");
+    expect(viewDocument(confirmed, draft).order).toEqual(["c1", "c2"]);
+
+    const removed = withCells(confirmed, { c1: null });
+    const settled = acknowledge(draft, sent);
+    expect(viewDocument(removed, settled).order).toEqual(["c1", "c2"]);
+    expect(toChanges(removed, settled)).toEqual([
+      {
+        kind: "put_cell",
+        base_etag: null,
+        cell: { ...back, name: "_", config: CONFIG },
+        before: "c2",
+      },
+    ]);
+  });
 });
 
 describe("viewDocument", () => {

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

@@ -124,6 +124,27 @@ describe("document model", () => {
     },
   );
 
+  it("brings back a cell deleted earlier in the draft with new content", () => {
+    const { store, cellAtom, orderAtom, changesAtom, edit } = setup();
+    edit((tx) => tx.deleteCell("c1"));
+    edit((tx) => tx.createCell({ id: "c1", code: "back" }, { after: "c2" }));
+    expect(store.get(cellAtom("c1"))?.code).toBe("back");
+    expect(store.get(orderAtom)).toEqual(["c2", "c1"]);
+    expect(store.get(changesAtom)).toEqual([
+      {
+        kind: "put_cell",
+        base_etag: "c1-etag",
+        cell: {
+          id: "c1",
+          code: "back",
+          name: "_",
+          config: cell("c1", "").config,
+        },
+      },
+      { kind: "set_order", base_etag: "order-1", order: ["c2", "c1"] },
+    ]);
+  });
+
   it("publishes the visible order when an anchor is deleted later in the draft", () => {
     const { store, orderAtom, changesAtom, edit } = setup();
     edit((tx) => {

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

@@ -253,17 +253,47 @@ export function createCell(
   input: Protocol.CellInput,
   placement: Placement = {},
 ): Draft {
+  const cell = parseCell(input);
+  const next = withCell(draft, cell.id, { kind: "create", cell, placement });
+  return draft.order === null
+    ? next
+    : { ...next, order: insertAt(draft.order, cell.id, placement) };
+}
+
+/**
+ * Bring back a cell this draft deletes, with the given content.
+ *
+ * A deletion not yet sent is withdrawn and the cell edited in place. One in
+ * flight is superseded by a creation, so the cell returns once the host has
+ * removed it. Either way the cell takes the requested placement.
+ */
+export function restoreCell(
+  confirmed: Document,
+  draft: Draft,
+  input: Protocol.CellInput,
+  placement: Placement = {},
+  sent: Draft = EMPTY_DRAFT,
+): Draft {
+  const { id, code, name, config } = parseCell(input);
+  const withdrawn = withCell(draft, id, undefined);
+  const next =
+    sent.cells.get(id)?.kind === "delete"
+      ? createCell(withdrawn, input, placement)
+      : editCell(confirmed, withdrawn, id, { code, name, config });
+  const { order } = viewDocument(confirmed, next);
+  const placed = insertAt(order, id, placement);
+  return sameOrder(order, placed) ? next : setOrder(next, placed);
+}
+
+/** A cell input with the protocol's defaults filled in. */
+function parseCell(input: Protocol.CellInput): CellWithSource {
   const parsed = Protocol.CellInput.parse(input);
-  const cell: CellWithSource = {
+  return {
     id: parsed.id,
     code: parsed.code,
     name: parsed.name,
     config: parsed.config ?? Protocol.CellConfigInput.parse({}),
   };
-  const next = withCell(draft, cell.id, { kind: "create", cell, placement });
-  return draft.order === null
-    ? next
-    : { ...next, order: insertAt(draft.order, cell.id, placement) };
 }
 
 /** Forget an unsent creation; otherwise retain the deletion until confirmed. */

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

@@ -21,3 +21,4 @@ export {
   type EditableCell,
   type EditableDocument,
 } from "./model";
+export type { Placement } from "./draft";

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

@@ -13,6 +13,7 @@ import {
   type CellEdit,
   createCell,
   deleteCell,
+  restoreCell,
   type Draft,
   type EditableDocument,
   editCell,
@@ -30,6 +31,7 @@ export interface DocumentEditor {
   setCode(id: Protocol.CellId, code: string): void;
   setName(id: Protocol.CellId, name: string): void;
   updateConfig(id: Protocol.CellId, patch: Partial<Protocol.CellConfig>): void;
+  /** Create a cell, or bring back one this draft deletes with this content. */
   createCell(cell: Protocol.CellInput, placement?: Placement): void;
   deleteCell(id: Protocol.CellId): void;
   /** A permutation of the cells present at this point in the transaction. */
@@ -330,7 +332,7 @@ function editDocument(
       updateCell(id, { config: Protocol.CellConfig.partial().parse(patch) }),
     createCell: (cell, placement = {}) => {
       assertActive();
-      if (confirmed.cells.has(cell.id) || hasCell(cell.id)) {
+      if (hasCell(cell.id)) {
         throw new Error(`Cell ${cell.id} already exists`);
       }
       if (placement.after !== undefined && placement.before !== undefined) {
@@ -340,7 +342,9 @@ function editDocument(
       if (anchor !== undefined) {
         requireCell(anchor);
       }
-      next = createCell(next, cell, { ...placement });
+      next = confirmed.cells.has(cell.id)
+        ? restoreCell(confirmed, next, cell, { ...placement }, sent)
+        : createCell(next, cell, { ...placement });
     },
     deleteCell: (id) => {
       requireCell(id);