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

package/src/core/cells/document.ts

@@ -0,0 +1,360 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+/**
+ * Keep the notebook state and the host document in step while cells live
+ * in both.
+ *
+ * TODO(MO-8028): Delete this module once components read cells from the
+ * document model and `notebookAtom` holds only runtime and editor state.
+ */
+
+import type * as Protocol from "@marimo-team/client/protocol";
+import { dequal as isEqual } from "dequal";
+import { createRef, type RefObject } from "react";
+import type { CellHandle } from "@/components/editor/notebook-cell";
+import type {
+  DocumentEdit,
+  DocumentEditor,
+  EditableCell,
+  EditableDocument,
+} from "@/core/notebook/document";
+import type { DispatchedActionOf } from "@/utils/createReducer";
+import { CollapsibleTree, MultiColumn } from "@/utils/id-tree";
+import { prepareCellCodeUpdate } from "../codemirror/language/cell-code";
+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 { groupByColumn } from "./columns";
+import type { CellId } from "./ids";
+import {
+  type CellData,
+  createCell,
+  createCellConfig,
+  createCellRuntimeState,
+  isEdited,
+} from "./types";
+
+type CellAction = DispatchedActionOf<CellActions>;
+
+// Following the document ----------------------------------------------------
+
+/** Rebuild the tree for `columns`, keeping column ids and collapsed sections. */
+function reconcileColumns(
+  current: MultiColumn<CellId>,
+  columns: CellId[][],
+): MultiColumn<CellId> {
+  const previous = current.getColumns();
+  // The document cannot hold an empty column, so keep the ones this client has.
+  while (previous[columns.length]?.length === 0) {
+    columns.push([]);
+  }
+  if (
+    columns.length === previous.length &&
+    columns.every((ids, index) => isEqual(ids, previous[index].inOrderIds))
+  ) {
+    return current;
+  }
+  return new MultiColumn(
+    columns.map((ids, index) =>
+      CollapsibleTree.fromWithPreviousShape(ids, previous[index]),
+    ),
+  );
+}
+
+/** The cell's data with the document's fields, and its editor brought along. */
+function followCell(
+  current: CellData,
+  cell: EditableCell,
+  handle: RefObject<CellHandle | null> | undefined,
+): CellData {
+  // Withheld source keeps the code this client has.
+  const code = cell.code ?? current.code;
+  const config = isEqual(current.config, cell.config)
+    ? current.config
+    : createCellConfig(cell.config);
+  if (
+    code === current.code &&
+    cell.name === current.name &&
+    config === current.config
+  ) {
+    return current;
+  }
+  if (code === current.code) {
+    return { ...current, name: cell.name, config };
+  }
+  // RTC cells follow Loro. Other editors take the host's code; one that
+  // shows it already, as the editor this client types in does, is left alone.
+  if (!isRtcEnabled() || !canUseRtc(current.id)) {
+    const view = handle?.current?.editorViewOrNull;
+    const update = view && prepareCellCodeUpdate(view.state, code);
+    if (update) {
+      view.dispatch(update);
+    }
+  }
+  return {
+    ...current,
+    code,
+    name: cell.name,
+    config,
+    edited: isEdited(current.lastCodeRun, code),
+  };
+}
+
+/**
+ * Make the notebook's cells and order follow the document.
+ *
+ * Returns the same state when nothing differs, so a local edit that the
+ * document already reflects changes nothing.
+ *
+ * TODO(MO-8028): Delete with `reconcileDocument` once cells are read from
+ * the document model.
+ */
+export function applyDocument(
+  state: NotebookState,
+  document: EditableDocument,
+): NotebookState {
+  const cellIds = reconcileColumns(state.cellIds, groupByColumn(document));
+  let { cellData, cellRuntime, cellHandles } = state;
+  for (const id of cellIds.inOrderIds) {
+    const cell = document.cells.get(id);
+    const current = state.cellData[id];
+    if (cell === undefined) {
+      continue;
+    }
+    if (current === undefined) {
+      // A new cell has no run to be edited from.
+      cellData = {
+        ...cellData,
+        [id]: createCell({
+          id,
+          code: cell.code ?? "",
+          name: cell.name,
+          config: createCellConfig(cell.config),
+        }),
+      };
+      cellRuntime = { ...cellRuntime, [id]: createCellRuntimeState() };
+      cellHandles = { ...cellHandles, [id]: createRef() };
+      continue;
+    }
+    const next = followCell(current, cell, state.cellHandles[id]);
+    if (next !== current) {
+      cellData = { ...cellData, [id]: next };
+    }
+  }
+  const present = new Set(cellIds.inOrderIds);
+  const removed = state.cellIds.inOrderIds.filter((id) => !present.has(id));
+  if (removed.length > 0) {
+    const gone = new Set(removed);
+    const keep = <V>(record: Record<CellId, V>): Record<CellId, V> =>
+      Object.fromEntries(
+        Object.entries(record).filter(([id]) => !gone.has(id as CellId)),
+      ) as Record<CellId, V>;
+    cellData = keep(cellData);
+    cellRuntime = keep(cellRuntime);
+    cellHandles = keep(cellHandles);
+  }
+  if (
+    cellIds === state.cellIds &&
+    cellData === state.cellData &&
+    removed.length === 0
+  ) {
+    return state;
+  }
+  return { ...state, cellIds, cellData, cellRuntime, cellHandles };
+}
+
+// Editing the document ------------------------------------------------------
+
+const CONFIG_FIELDS = ["disabled", "hide_code", "expand_output"] as const;
+
+/** The fields of `after` that differ from `before`, leaving `column` to the tree. */
+function configPatch(
+  before: CellConfig,
+  after: CellConfig,
+): Partial<Protocol.CellConfig> | null {
+  const patch: Partial<Protocol.CellConfig> = {};
+  for (const field of CONFIG_FIELDS) {
+    if (before[field] !== after[field]) {
+      patch[field] = after[field] ?? false;
+    }
+  }
+  return Object.keys(patch).length === 0 ? null : patch;
+}
+
+/**
+ * The `column` configs that make the document's columns match the tree's.
+ *
+ * A cell without a column follows the cell before it, so only cells whose
+ * resolved column differs from their position need one.
+ */
+function columnFixes(state: NotebookState): Array<[CellId, number | null]> {
+  const fixes: Array<[CellId, number | null]> = [];
+  const columns = state.cellIds.getColumns();
+  if (columns.length === 1) {
+    for (const id of columns[0].inOrderIds) {
+      const column = state.cellData[id].config.column;
+      if (column != null && column !== 0) {
+        fixes.push([id, null]);
+      }
+    }
+    return fixes;
+  }
+  let inherited = 0;
+  columns.forEach((column, target) => {
+    for (const id of column.inOrderIds) {
+      const configured = state.cellData[id].config.column;
+      const resolved =
+        configured != null && configured >= 0 ? configured : inherited;
+      if (resolved !== target) {
+        fixes.push([id, target]);
+      }
+      inherited = target;
+    }
+  });
+  return fixes;
+}
+
+/** The edit that makes the document match `next`, or null when it already does. */
+function diffNotebook(
+  prev: NotebookState,
+  next: NotebookState,
+): DocumentEdit | null {
+  const steps: Array<(tx: DocumentEditor) => void> = [];
+  const prevOrder = prev.cellIds.inOrderIds;
+  const nextOrder = next.cellIds.inOrderIds;
+  const prevIds = new Set(prevOrder);
+  const nextIds = new Set(nextOrder);
+  for (const id of prevOrder) {
+    if (!nextIds.has(id)) {
+      steps.push((tx) => tx.deleteCell(id));
+    }
+  }
+  const created: CellId[] = [];
+  for (const id of nextOrder) {
+    const cell = next.cellData[id];
+    const before = prev.cellData[id];
+    if (!prevIds.has(id) || before === undefined) {
+      created.push(id);
+      steps.push((tx) =>
+        tx.createCell({
+          id,
+          code: cell.code,
+          name: cell.name,
+          config: cell.config,
+        }),
+      );
+      continue;
+    }
+    if (before === cell) {
+      continue;
+    }
+    if (before.code !== cell.code) {
+      steps.push((tx) => tx.setCode(id, cell.code));
+    }
+    if (before.name !== cell.name) {
+      steps.push((tx) => tx.setName(id, cell.name));
+    }
+    const patch = configPatch(before.config, cell.config);
+    if (patch !== null) {
+      steps.push((tx) => tx.updateConfig(id, patch));
+    }
+  }
+  for (const [id, column] of columnFixes(next)) {
+    steps.push((tx) => tx.updateConfig(id, { column }));
+  }
+  // Created cells go to the end, so the order is set when they belong elsewhere.
+  const survivors = prevOrder.filter((id) => nextIds.has(id));
+  if (!isEqual(nextOrder, [...survivors, ...created])) {
+    steps.push((tx) => tx.setOrder(nextOrder));
+  }
+  if (steps.length === 0) {
+    return null;
+  }
+  return (tx) => {
+    for (const step of steps) {
+      step(tx);
+    }
+  };
+}
+
+/**
+ * Middleware for the notebook reducer. Writes what an action changed about
+ * the cells and their order into the document model as one edit.
+ *
+ * TODO(MO-8028): Each action family that moves onto the model removes its
+ * part of `diffNotebook`. The middleware goes with the last one, code.
+ */
+export function documentEditMiddleware(
+  prev: NotebookState,
+  next: NotebookState,
+  action: CellAction,
+): void {
+  // The kernel's cells replace the notebook rather than edit it.
+  if (action.type === "setCells") {
+    return;
+  }
+  if (prev.cellIds === next.cellIds && prev.cellData === next.cellData) {
+    return;
+  }
+  const model = store.get(activeDocumentModelAtom);
+  if (model === null) {
+    return;
+  }
+  const edit = diffNotebook(prev, next);
+  if (edit !== null) {
+    store.set(model.editAtom, edit);
+  }
+}
+
+// Commands that read the document on the host -------------------------------
+
+/**
+ * Send this client's edits to the host before a command that reads them
+ * there. Without a document or a backend, as on a static page, there is
+ * nothing to send and the command proceeds.
+ */
+export async function flushDocument(): Promise<void> {
+  const model = store.get(activeDocumentModelAtom);
+  if (
+    model === null ||
+    store.get(model.syncStatusAtom).status === "unavailable"
+  ) {
+    return;
+  }
+  await model.flush();
+}
+
+/**
+ * Run a legacy save after this client's edits reach the host, and keep
+ * later edits local until it finishes. The save carries the whole
+ * notebook and the host takes it as the document, so an edit sent
+ * meanwhile would be overwritten. When the edits cannot be sent the save
+ * still runs, and the model resumes against the saved document.
+ *
+ * TODO(MO-8028): Goes with the legacy save, along with the hold.
+ */
+export async function withDocumentSave<T>(save: () => Promise<T>): Promise<T> {
+  const model = store.get(activeDocumentModelAtom);
+  if (model === null) {
+    return save();
+  }
+  let flushed = true;
+  try {
+    await model.flush();
+  } catch {
+    flushed = false;
+  }
+  const release = model.hold();
+  let result: T;
+  try {
+    result = await save();
+  } finally {
+    release();
+  }
+  if (!flushed) {
+    void model.retry().catch(() => undefined);
+  }
+  return result;
+}

package/src/core/cells/pending-delete-service.ts

@@ -134,12 +134,8 @@ export function usePendingDeleteService() {
       submit({ cellIds, deleteCell, deleteManyCells, store });
     },
     clear,
-    get idle() {
-      return entries.size === 0;
-    },
-    get shouldConfirmDelete() {
-      return entries.size > 1;
-    },
+    idle: entries.size === 0,
+    shouldConfirmDelete: entries.size > 1,
   };
 }
 

package/src/core/cells/session.ts

@@ -56,7 +56,7 @@ function mergeSessionAndNotebookCells(
     return {
       cellIds,
       sessionCellData: new Map(
-        cellIds.map((id, idx) => [id, null] as [CellId, SessionCell | null]),
+        cellIds.map((id) => [id, null] as [CellId, SessionCell | null]),
       ),
       notebookCellData: new Map(
         cellIds.map(

package/src/core/cells/types.ts

@@ -8,6 +8,18 @@ import type { CellId } from "./ids";
 import { DEFAULT_CELL_NAME } from "./names";
 import type { Outline } from "./outline";
 
+/**
+ * Whether a cell's code has changed since it last ran. A cell that never ran
+ * is edited once it has code. Whitespace at the ends does not count.
+ *
+ * TODO(MO-8028): Temporary until staleness comes from the host's executions.
+ */
+export function isEdited(lastCodeRun: string | null, code: string): boolean {
+  return lastCodeRun === null
+    ? code.trim().length > 0
+    : lastCodeRun.trim() !== code.trim();
+}
+
 /**
  * Create a new cell with default state.
  */
@@ -95,7 +107,7 @@ export interface CellRuntimeState {
   /** TOC outline */
   outline: Outline | null;
   /** messages encoding the cell's console outputs. */
-  consoleOutputs: WithResponse<OutputMessage>[];
+  consoleOutputs: ConsoleOutputMessage[];
   /** current status of the cell */
   status: RuntimeState;
   /** whether the cell has stale inputs*/
@@ -130,3 +142,12 @@ export type WithResponse<T> = T & {
    */
   response?: string;
 };
+
+/**
+ * A console output as held by the frontend. The id is assigned when the
+ * output arrives and never changes, so it can identify the output while
+ * neighboring outputs collapse, truncate, or receive a stdin response.
+ */
+export type ConsoleOutputMessage = WithResponse<OutputMessage> & {
+  id?: number;
+};

package/src/core/codemirror/__tests__/setup.test.ts

@@ -100,7 +100,7 @@ function getDuplicateKeymaps(state: EditorState) {
     (keymap) => keymap,
   );
   const duplicates = Objects.fromEntries(
-    Object.entries(groupBy).filter(([key, value]) => value.length > 1),
+    Object.entries(groupBy).filter(([_key, value]) => value.length > 1),
   );
   return duplicates;
 }
@@ -198,22 +198,22 @@ test("go to definition falls through to lower-priority LSP keymap", () => {
 test("placeholder adds another extension", () => {
   const opts = getOpts();
   const withAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "marimo-import",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "marimo-import",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   const withoutAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "none",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "none",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   expect(withAI.length - 1).toBe(withoutAI.length);
 });
@@ -221,22 +221,22 @@ test("placeholder adds another extension", () => {
 test("ai adds more extensions", () => {
   const opts = getOpts();
   const withAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "ai",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "ai",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   const withoutAI = new PythonLanguageAdapter()
-    .getExtension(
-      opts.cellId,
-      opts.completionConfig,
-      opts.hotkeys,
-      "none",
-      opts.lspConfig,
-    )
+    .getExtension({
+      cellId: opts.cellId,
+      completionConfig: opts.completionConfig,
+      hotkeys: opts.hotkeys,
+      placeholderType: "none",
+      lspConfig: opts.lspConfig,
+    })
     .flat();
   expect(withAI.length - 2).toBe(withoutAI.length);
 });

package/src/core/codemirror/ai/__tests__/resources.test.ts

@@ -0,0 +1,117 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { markdownLanguage } from "@codemirror/lang-markdown";
+import { hoverResource, type Resource } from "@marimo-team/codemirror-mcp";
+import { createStore } from "jotai";
+import { assert, beforeEach, describe, expect, it, vi } from "vitest";
+import { MockNotebook } from "@/__mocks__/notebook";
+import { getAIContextRegistry } from "@/core/ai/context/context";
+import { ErrorContextProvider } from "@/core/ai/context/providers/error";
+import { AIContextRegistry } from "@/core/ai/context/registry";
+import { notebookAtom } from "@/core/cells/cells";
+import { CellId } from "@/core/cells/ids";
+import { resourceExtension } from "../resources";
+
+vi.mock("@marimo-team/codemirror-mcp", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@marimo-team/codemirror-mcp")>()),
+  hoverResource: vi.fn(() => []),
+}));
+
+vi.mock("@/core/ai/context/context", () => ({
+  getAIContextRegistry: vi.fn(),
+}));
+
+describe("resource tooltips", () => {
+  const message = '<b>Unexpected response</b> &amp; "details"';
+  let provider: ErrorContextProvider;
+  let resource: Resource;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const store = createStore();
+    store.set(
+      notebookAtom,
+      MockNotebook.notebookStateWithErrors([
+        {
+          cellId: CellId.create(),
+          cellName: "Cell 1",
+          errorData: [MockNotebook.errors.exception(message)],
+        },
+      ]),
+    );
+    provider = new ErrorContextProvider(store);
+    resource = provider.getItems()[1];
+    vi.mocked(getAIContextRegistry).mockReturnValue(
+      new AIContextRegistry().register(provider),
+    );
+    resourceExtension({ language: markdownLanguage, store });
+  });
+
+  function renderTooltip(item = resource) {
+    const options = vi.mocked(hoverResource).mock.calls[0][0];
+    assert(options.createTooltip);
+    return options.createTooltip(item).dom;
+  }
+
+  it("preserves literal text in cell error descriptions", () => {
+    const dom = renderTooltip();
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal descriptions when a provider is unavailable", () => {
+    const dom = renderTooltip({ ...resource, type: "unknown" });
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("falls back to the literal resource name", () => {
+    const dom = renderTooltip({
+      ...resource,
+      description: undefined,
+      name: message,
+    });
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal text in completion info strings", () => {
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: message,
+    });
+    const dom = renderTooltip({ ...resource, description: "Fallback" });
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal fallback text when an info renderer returns null", () => {
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: () => null,
+    });
+    const dom = renderTooltip();
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it("preserves literal fallback text for async info renderers", () => {
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: async () => document.createElement("div"),
+    });
+    const dom = renderTooltip();
+    expect(dom.textContent).toBe(message);
+    expect(dom.childElementCount).toBe(0);
+  });
+
+  it.each(["element", "tooltip"])("preserves custom %s renderers", (kind) => {
+    const dom = document.createElement("strong");
+    dom.textContent = "Details";
+    vi.spyOn(provider, "formatCompletion").mockReturnValue({
+      label: "Error",
+      info: () => (kind === "element" ? dom : { dom }),
+    });
+    expect(renderTooltip()).toBe(dom);
+  });
+});

package/src/core/codemirror/ai/resources.ts

@@ -142,7 +142,7 @@ export function resourceExtension(opts: {
 
 function asDom(value: string): TooltipView {
   const tooltip = document.createElement("div");
-  tooltip.innerHTML = value;
+  tooltip.textContent = value;
   return {
     dom: tooltip,
   };

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

@@ -11,7 +11,8 @@ import { formattingChangeEffect } from "../../format";
 import { loroSyncAnnotation } from "../../rtc/loro/sync";
 import { exportedForTesting } from "../extensions";
 
-const { shouldAutorunMarkdownUpdate } = exportedForTesting;
+const { isCollaboratorUpdate, shouldAutorunMarkdownUpdate } =
+  exportedForTesting;
 
 function createTransaction(spec: TransactionSpec) {
   return EditorState.create({ doc: "" }).update(spec);
@@ -68,6 +69,21 @@ describe("shouldAutorunMarkdownUpdate", () => {
     ).toBe(false);
   });
 
+  it("ignores remote transactions while focused", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [Transaction.remote.of(true)],
+    });
+
+    expect(
+      shouldAutorunMarkdownUpdate({
+        docChanged: transaction.docChanged,
+        transactions: [transaction],
+        hasFocus: true,
+      }),
+    ).toBe(false);
+  });
+
   it("ignores programmatic doc changes without a user event", () => {
     const transaction = createTransaction({
       changes: { from: 0, insert: "#" },
@@ -110,3 +126,28 @@ describe("shouldAutorunMarkdownUpdate", () => {
     ).toBe(false);
   });
 });
+
+describe("isCollaboratorUpdate", () => {
+  it("recognizes an update made only of Loro sync transactions", () => {
+    const transaction = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [loroSyncAnnotation.of(true)],
+    });
+
+    expect(isCollaboratorUpdate([transaction])).toBe(true);
+  });
+
+  it("treats typing beside a Loro sync transaction as local", () => {
+    const remote = createTransaction({
+      changes: { from: 0, insert: "#" },
+      annotations: [loroSyncAnnotation.of(true)],
+    });
+    const local = createTransaction({
+      changes: { from: 0, insert: "x" },
+      annotations: [Transaction.userEvent.of("input.type")],
+    });
+
+    expect(isCollaboratorUpdate([remote, local])).toBe(false);
+    expect(isCollaboratorUpdate([])).toBe(false);
+  });
+});