@marimo-team/islands 0.25.3-dev31 → 0.25.3-dev311

package/src/core/cells/utils.ts

@@ -1,31 +1,30 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import type { EditorView } from "@codemirror/view";
+import {
+  type CellExecutionInputs,
+  type CellExecutionView,
+  type CellFreshness,
+  type CellFreshnessLookup,
+  cellExecutionView,
+} from "@/core/executions";
+import type { Executions } from "@/core/notebook/replica";
 import { Objects } from "@/utils/objects";
 import type { MarimoError, OutputMessage } from "../kernel/messages";
 import { isErrorMime } from "../mime";
-import type { RuntimeState } from "../network/types";
 import type { NotebookState } from "./cells";
 import type { CellId } from "./ids";
 
-export function notebookIsRunning(state: NotebookState) {
-  return Object.values(state.cellRuntime).some(
-    (cell) => cell.status === "running",
-  );
-}
-
-export function notebookQueueOrRunningCount(state: NotebookState) {
-  return Object.values(state.cellRuntime).filter(
-    (cell) => cell.status === "running" || cell.status === "queued",
-  ).length;
-}
-
-export function notebookNeedsRun(state: NotebookState) {
-  return staleCellIds(state).length > 0;
+export function notebookNeedsRun(
+  state: NotebookState,
+  executions: CellExecutionInputs,
+  freshness: CellFreshnessLookup,
+) {
+  return staleCellIds(state, executions, freshness).length > 0;
 }
 
 export function notebookCells(state: NotebookState) {
-  return state.cellIds.inOrderIds.map((cellId) => state.cellData[cellId]);
+  return state.cellIds.map((cellId) => state.cellData[cellId]);
 }
 
 export function notebookCellEditorViews({ cellHandles }: NotebookState) {
@@ -42,7 +41,7 @@ export function notebookCellEditorViews({ cellHandles }: NotebookState) {
 export function disabledCellIds(state: NotebookState) {
   const { cellIds, cellData } = state;
   const disabledCells: CellId[] = [];
-  for (const cellId of cellIds.inOrderIds) {
+  for (const cellId of cellIds) {
     const cell = cellData[cellId];
     if (cell.config.disabled) {
       disabledCells.push(cellId);
@@ -54,7 +53,7 @@ export function disabledCellIds(state: NotebookState) {
 export function enabledCellIds(state: NotebookState) {
   const { cellIds, cellData } = state;
   const enabledCells: CellId[] = [];
-  for (const cellId of cellIds.inOrderIds) {
+  for (const cellId of cellIds) {
     const cell = cellData[cellId];
     if (!cell.config.disabled) {
       enabledCells.push(cellId);
@@ -79,19 +78,21 @@ export function getUndoLabel(state: NotebookState): string {
 }
 
 /**
- * Get the status of the descendants of the given cell.
+ * Summarize the run state of the given descendants, whether any is stale,
+ * errored, or running.
  */
-export function getDescendantsStatus(state: NotebookState, cellId: CellId) {
-  const column = state.cellIds.findWithId(cellId);
-  const descendants = column.getDescendants(cellId);
+export function getDescendantsStatus(
+  executions: CellExecutionInputs,
+  freshness: CellFreshnessLookup,
+  descendants: readonly CellId[],
+) {
+  const views = descendants.map((id) => cellExecutionView(executions, id));
   const stale = descendants.some(
-    (id) => state.cellRuntime[id]?.staleInputs || state.cellData[id]?.edited,
+    (id) => freshness(id).sourceChanged || freshness(id).inputsChanged,
   );
-  const errored = descendants.some((id) => state.cellRuntime[id]?.errored);
-  const runningOrQueued = descendants.some(
-    (id) =>
-      state.cellRuntime[id]?.status === "running" ||
-      state.cellRuntime[id]?.status === "queued",
+  const errored = views.some((view) => view.outcome === "error");
+  const runningOrQueued = views.some(
+    (view) => view.status === "running" || view.status === "queued",
   );
 
   return {
@@ -104,77 +105,74 @@ export function getDescendantsStatus(state: NotebookState, cellId: CellId) {
 /**
  * Cells that are stale and can be run.
  */
-export function staleCellIds(state: NotebookState) {
-  const { cellIds, cellData, cellRuntime } = state;
-  return cellIds.inOrderIds.filter(
-    (cellId) =>
-      isUninstantiated({
-        // runElapstedTimeMs is what we've seen in this session
-        executionTime:
-          cellRuntime[cellId].runElapsedTimeMs ??
-          // lastExecutionTime is what was seen on session start/resume
-          cellData[cellId].lastExecutionTime,
-        status: cellRuntime[cellId].status,
-        errored: cellRuntime[cellId].errored,
-        interrupted: cellRuntime[cellId].interrupted,
-        stopped: cellRuntime[cellId].stopped,
-      }) ||
-      cellData[cellId].edited ||
-      cellRuntime[cellId].interrupted ||
-      (cellRuntime[cellId].staleInputs &&
-        // if a cell is disabled, it can't be run ...
-        !(
-          cellRuntime[cellId].status === "disabled-transitively" ||
-          cellData[cellId].config.disabled
-        )),
-  );
+export function staleCellIds(
+  state: NotebookState,
+  executions: CellExecutionInputs,
+  freshness: CellFreshnessLookup,
+) {
+  const { cellIds, cellData } = state;
+  return cellIds.filter((cellId) => {
+    const execution = cellExecutionView(executions, cellId);
+    if (execution.status !== "idle") {
+      // A run in progress covers the source it was asked for. Only an edit
+      // since then, visible once the host has planned the run, needs another.
+      return (
+        inFlight(executions.executions, cellId) &&
+        freshness(cellId).sourceChanged
+      );
+    }
+    return (
+      isUninstantiated(execution) ||
+      cellNeedsRun({
+        freshness: freshness(cellId),
+        interrupted: execution.outcome === "interrupted",
+        disabled: cellData[cellId].config.disabled,
+        blocked: execution.blocked,
+      })
+    );
+  });
+}
+
+/** Whether the host holds a planned or started execution of the cell that has not completed. */
+function inFlight(executions: Executions, cellId: CellId): boolean {
+  const latest = executions.latest.get(cellId);
+  const record =
+    latest === undefined
+      ? undefined
+      : executions.executions.get(latest)?.record;
+  return record !== undefined && record.status !== "completed";
 }
 
+/** Whether a cell has never run: no result to show and nothing in flight. */
 export function isUninstantiated({
-  executionTime,
   status,
-  errored,
-  interrupted,
-  stopped,
-}: {
-  executionTime: number | null;
-  status: RuntimeState;
-  errored: boolean;
-  interrupted: boolean;
-  stopped: boolean;
-}) {
-  return (
-    // hasn't run ...
-    executionTime === null &&
-    // isn't currently queued/running &&
-    status !== "queued" &&
-    status !== "running" &&
-    // and isn't in an error state.
-    !(errored || interrupted || stopped)
-  );
+  outcome,
+}: Pick<CellExecutionView, "status" | "outcome">) {
+  return outcome === null && status !== "queued" && status !== "running";
 }
 
 /**
- * Whether a cell needs to be run given its edited / interrupted / stale
- * inputs, while accounting for ancestor-disabled cells (which should not be
- * flagged as needing a run until re-enabled).
+ * Whether a cell needs to be run: its source changed, its last run was
+ * interrupted, or an input changed and the cell can run. A disabled cell,
+ * or one blocked by a disabled ancestor, is not flagged for changed inputs
+ * until it can run again.
  */
 export function cellNeedsRun({
-  edited,
+  freshness,
   interrupted,
-  staleInputs,
   disabled,
-  status,
+  blocked,
 }: {
-  edited: boolean;
+  freshness: CellFreshness;
   interrupted: boolean;
-  staleInputs: boolean;
   disabled: boolean | undefined;
-  status: RuntimeState;
+  blocked: boolean;
 }): boolean {
-  const disabledOrAncestorDisabled =
-    disabled || status === "disabled-transitively";
-  return edited || interrupted || (staleInputs && !disabledOrAncestorDisabled);
+  return (
+    freshness.sourceChanged ||
+    interrupted ||
+    (freshness.inputsChanged && !(disabled || blocked))
+  );
 }
 
 export function cellStatusClasses({
@@ -182,20 +180,20 @@ export function cellStatusClasses({
   errored,
   stopped,
   disabled,
-  status,
+  blocked,
 }: {
   needsRun: boolean;
   errored: boolean;
   stopped: boolean;
   disabled: boolean | undefined;
-  status: RuntimeState;
+  blocked: boolean;
 }) {
   return {
     "needs-run": needsRun,
     "has-error": errored,
     stopped,
     disabled: disabled ?? false,
-    stale: status === "disabled-transitively",
+    stale: blocked,
   };
 }
 

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

@@ -1,5 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import { defaultUserConfig } from "@/core/config/config-schema";
+
 import { python } from "@codemirror/lang-python";
 import { EditorState } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
@@ -17,7 +19,6 @@ import { OverridingHotkeyProvider } from "@/core/hotkeys/hotkeys";
 import { requestClientAtom } from "@/core/network/requests";
 import type { MarimoConfig } from "@/core/network/types";
 import { store } from "@/core/state/jotai";
-import { type CodemirrorCellActions, cellActionsState } from "../cells/state";
 import { cellIdState } from "../config/extension";
 import { formatAll, formatEditorViews, formatSQL } from "../format";
 import {
@@ -44,7 +45,6 @@ vi.mock("@/core/config/config", () => ({
   }),
 }));
 
-const updateCellCode = vi.fn();
 const createdViews: EditorView[] = [];
 
 function createEditor(content: string, cellId: CellId) {
@@ -55,6 +55,7 @@ function createEditor(content: string, cellId: CellId) {
       adaptiveLanguageConfiguration({
         cellId,
         completionConfig: {
+          ...defaultUserConfig().completion,
           activate_on_typing: true,
           signature_hint_on_typing: false,
           copilot: false,
@@ -62,12 +63,9 @@ function createEditor(content: string, cellId: CellId) {
         },
         hotkeys: new OverridingHotkeyProvider({}),
         placeholderType: "marimo-import",
-        lspConfig: {},
+        lspConfig: { ...defaultUserConfig().language_servers },
       }),
       cellIdState.of(cellId),
-      cellActionsState.of({
-        updateCellCode,
-      } as unknown as CodemirrorCellActions),
     ],
   });
 
@@ -85,7 +83,6 @@ const mockConfig = {
 } as MarimoConfig;
 
 beforeEach(() => {
-  updateCellCode.mockClear();
   vi.clearAllMocks();
   // Set the mock request client in the atom
   store.set(requestClientAtom, mockRequestClient);
@@ -131,16 +128,6 @@ describe("format", () => {
 
       expect(views[cid1].state.doc.toString()).toBe(formattedCode1);
       expect(views[cid2].state.doc.toString()).toBe(formattedCode2);
-      expect(updateCellCode).toHaveBeenCalledWith({
-        cellId: cid1,
-        code: formattedCode1,
-        formattingChange: true,
-      });
-      expect(updateCellCode).toHaveBeenCalledWith({
-        cellId: cid2,
-        code: formattedCode2,
-        formattingChange: true,
-      });
     });
 
     it("should not update editor if formatted code is same as original", async () => {
@@ -161,7 +148,6 @@ describe("format", () => {
       await formatEditorViews(views);
 
       expect(views[cid].state.doc.toString()).toBe(originalCode);
-      expect(updateCellCode).not.toHaveBeenCalled();
     });
   });
 
@@ -194,12 +180,6 @@ describe("format", () => {
         },
         lineLength: 88,
       });
-
-      expect(updateCellCode).toHaveBeenCalledWith({
-        cellId: cid1,
-        code: "import numpy as np",
-        formattingChange: true,
-      });
     });
   });
 
@@ -220,11 +200,6 @@ describe("format", () => {
         WHERE
           id = 1"
       `);
-      expect(updateCellCode).toHaveBeenCalledWith({
-        cellId: cid,
-        code: editor.state.doc.toString(),
-        formattingChange: true,
-      });
     });
 
     it("should not format if language adapter is not SQL", async () => {
@@ -238,7 +213,6 @@ describe("format", () => {
       expect(editor.state.doc.toString()).toBe(
         "SELECT * FROM table WHERE id = 1",
       );
-      expect(updateCellCode).not.toHaveBeenCalled();
     });
   });
 
@@ -257,10 +231,5 @@ describe("format", () => {
       WHERE
         id = 1"
     `);
-    expect(updateCellCode).toHaveBeenCalledWith({
-      cellId: cid,
-      code: editor.state.doc.toString(),
-      formattingChange: true,
-    });
   });
 });

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

@@ -1,5 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import { defaultUserConfig } from "@/core/config/config-schema";
+
 import { EditorState, type Extension } from "@codemirror/state";
 import { EditorView, keymap } from "@codemirror/view";
 import { describe, expect, test, vi } from "vitest";
@@ -40,6 +42,7 @@ function getOpts() {
     enableAI: false,
     cellActions: {
       toggleHideCode: namedFunction("toggleHideCode"),
+      askAiAboutCell: namedFunction("askAiAboutCell"),
       aiCellCompletion: namedFunction("aiCellCompletion"),
       createManyBelow: namedFunction("createManyBelow"),
       onRun: namedFunction("onRun"),
@@ -48,6 +51,7 @@ function getOpts() {
       afterToggleSQL: namedFunction("afterToggleSQL"),
     } as unknown as CodemirrorCellActions,
     completionConfig: {
+      ...defaultUserConfig().completion,
       activate_on_typing: false,
       signature_hint_on_typing: false,
       copilot: false,
@@ -59,13 +63,12 @@ function getOpts() {
     },
     lspConfig: {
       pylsp: {
+        ...defaultUserConfig().language_servers.pylsp,
         enabled: false,
       },
-      diagnostics: {
-        enabled: false,
-      },
+      diagnostics: { ...defaultUserConfig().diagnostics, enabled: false },
     },
-    diagnosticsConfig: {},
+    diagnosticsConfig: { ...defaultUserConfig().diagnostics },
     hotkeys: new OverridingHotkeyProvider({}),
     theme: "light",
     displayConfig: { reference_highlighting: false, code_lens: true },
@@ -100,7 +103,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 +201,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 +224,53 @@ 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);
 });
+
+test("empty-cell AI action opens chat without invoking the local refactor prompt", () => {
+  const askAiAboutCell = vi.fn();
+  const aiCellCompletion = vi.fn();
+  const view = new EditorView({
+    state: EditorState.create({
+      doc: "",
+      extensions: setup({
+        showPlaceholder: true,
+        enableAI: false,
+        enableAIChat: true,
+        cellActions: {
+          ...getOpts().cellActions,
+          askAiAboutCell,
+          aiCellCompletion,
+        },
+      }),
+    }),
+  });
+  try {
+    const button = view.dom.querySelector<HTMLButtonElement>(
+      ".cm-clickable-placeholder",
+    );
+    expect(button?.textContent).toBe("generate with AI");
+    button?.click();
+    expect(askAiAboutCell).toHaveBeenCalledOnce();
+    expect(aiCellCompletion).not.toHaveBeenCalled();
+  } finally {
+    view.destroy();
+  }
+});

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

@@ -8,7 +8,6 @@ import {
 } from "@codemirror/state";
 import { describe, expect, it } from "vitest";
 import { formattingChangeEffect } from "../../format";
-import { loroSyncAnnotation } from "../../rtc/loro/sync";
 import { exportedForTesting } from "../extensions";
 
 const { shouldAutorunMarkdownUpdate } = exportedForTesting;
@@ -50,13 +49,10 @@ describe("shouldAutorunMarkdownUpdate", () => {
     ).toBe(false);
   });
 
-  it("ignores RTC sync transactions", () => {
+  it("ignores remote transactions while focused", () => {
     const transaction = createTransaction({
       changes: { from: 0, insert: "#" },
-      annotations: [
-        Transaction.userEvent.of("input.type"),
-        loroSyncAnnotation.of(true),
-      ],
+      annotations: [Transaction.remote.of(true)],
     });
 
     expect(