@marimo-team/islands 0.25.3-dev30 → 0.25.3-dev302

package/src/core/config/feature-flag.tsx

@@ -8,7 +8,6 @@ import { getResolvedMarimoConfig } from "./config";
 export interface ExperimentalFeatures {
   markdown: boolean; // Used in playground (community cloud)
   wasm_layouts: boolean; // Used in playground (community cloud)
-  rtc_v2: boolean;
   cache_panel: boolean;
   external_agents: boolean;
   debugger: boolean; // Live frame-watching debugger (gutter breakpoints + pdb)
@@ -19,7 +18,6 @@ export interface ExperimentalFeatures {
 const defaultValues: ExperimentalFeatures = {
   markdown: true,
   wasm_layouts: false,
-  rtc_v2: false,
   cache_panel: import.meta.env.DEV,
   external_agents: import.meta.env.DEV,
   debugger: false,

package/src/core/datasets/__tests__/data-source-discovery.test.ts

@@ -4,7 +4,7 @@ import { requestId } from "@/__tests__/branded";
 import type { DataSourceDiscoveryResult } from "@/core/kernel/messages";
 import { connectionAtom } from "@/core/network/connection";
 import { store } from "@/core/state/jotai";
-import { ConnectionState } from "@/core/websocket/types";
+import { ConnectionState } from "@/core/session/types";
 import {
   fetchDataSourceDiscovery,
   invalidateDataSourceDiscovery,
@@ -185,8 +185,8 @@ describe("isDetectedSourceConnected", () => {
   });
   const emptySnapshot = {
     dialects: [] as string[],
-    storageProtocols: [] as string[],
-    storageBackendTypes: [] as string[],
+    storageProtocols: new Set<string>(),
+    storageBackendTypes: new Set<string>(),
   };
 
   it("does not hide a source when nothing is connected", () => {
@@ -242,7 +242,7 @@ describe("isDetectedSourceConnected", () => {
     expect(
       isDetectedSourceConnected(s3, {
         ...emptySnapshot,
-        storageProtocols: ["s3"],
+        storageProtocols: new Set(["s3"]),
       }),
     ).toBe(true);
   });
@@ -262,7 +262,7 @@ describe("isDetectedSourceConnected", () => {
     expect(
       isDetectedSourceConnected(hf, {
         ...emptySnapshot,
-        storageBackendTypes: ["huggingface"],
+        storageBackendTypes: new Set(["huggingface"]),
       }),
     ).toBe(true);
   });

package/src/core/datasets/data-source-discovery.ts

@@ -27,8 +27,8 @@ export function matchesDiscoveryGroup(
  */
 export interface LiveConnectionSnapshot {
   dialects: readonly string[];
-  storageProtocols: readonly string[];
-  storageBackendTypes: readonly string[];
+  storageProtocols: ReadonlySet<string>;
+  storageBackendTypes: ReadonlySet<string>;
 }
 
 /**
@@ -47,15 +47,13 @@ export function isDetectedSourceConnected(
   }
 
   if (
-    match.protocols.some((protocol) =>
-      snapshot.storageProtocols.includes(protocol),
-    )
+    match.protocols.some((protocol) => snapshot.storageProtocols.has(protocol))
   ) {
     return true;
   }
 
   return match.backendTypes.some((backendType) =>
-    snapshot.storageBackendTypes.includes(backendType),
+    snapshot.storageBackendTypes.has(backendType),
   );
 }
 

package/src/core/documentation/doc-lookup.ts

@@ -17,7 +17,7 @@ export async function requestOutputDocumentation(
   qualifiedName: string,
 ): Promise<void> {
   // We need any valid cell_id for the completion request.
-  const cellId = getCells().inOrderIds.at(0);
+  const cellId = getCells().at(0);
   if (!cellId) {
     return;
   }

package/src/core/dom/outline.ts

@@ -4,6 +4,7 @@ import { sanitizeHtml } from "@/plugins/core/sanitize-html";
 import { invariant } from "@/utils/invariant";
 import { Logger } from "@/utils/Logger";
 import type { Outline, OutlineItem } from "../cells/outline";
+import type { CellOutput } from "@/core/executions/output";
 import type { OutputMessage } from "../kernel/messages";
 
 // Tags that we don't want to include in the outline
@@ -101,7 +102,9 @@ export function mergeOutlines(outlines: (Outline | null)[]): Outline {
   };
 }
 
-export function parseOutline(output: OutputMessage | null): Outline | null {
+export function parseOutline(
+  output: OutputMessage | CellOutput | null,
+): Outline | null {
   if (output == null) {
     return null;
   }

package/src/core/edit-app.tsx

@@ -5,8 +5,8 @@ import { Tooltip } from "radix-ui";
 
 const TooltipProvider = Tooltip.Provider;
 
-import { useAtomValue, useSetAtom } 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";
@@ -27,23 +27,23 @@ import { useSetOutputsExpanded } from "../components/editor/actions/useSetOutput
 import { CellArray } from "../components/editor/renderers/cell-array";
 import { CellsRenderer } from "../components/editor/renderers/cells-renderer";
 import { useHotkey } from "../hooks/useHotkey";
-import {
-  hasCellsAtom,
-  notebookIsRunningAtom,
-  numColumnsAtom,
-  useCellActions,
-} from "./cells/cells";
+import { hasCellsAtom } from "./cells/cells";
+import { notebookIsRunningAtom } from "./executions";
+import { numColumnsAtom } from "./cells/layout";
+import { useCellActions } from "./cells/actions";
 import type { AppConfig, UserConfig } from "./config/config-schema";
 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 "./websocket/useNotebookSession";
+import type { ConnectionStatus } from "./session/types";
+
+const LazyCommandPalette = lazy(
+  () => import("../components/editor/controls/command-palette"),
+);
 
-interface AppProps {
+export interface EditAppProps {
   /**
    * The user config.
    */
@@ -56,19 +56,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 { setCells, mergeAllColumns, collapseAllCells, expandAllCells } =
+  const { mergeAllColumns, collapseAllCells, expandAllCells } =
     useCellActions();
   const viewState = useAtomValue(viewStateAtom);
   const numColumns = useAtomValue(numColumnsAtom);
   const filename = useFilename();
-  const setLastSavedNotebook = useSetAtom(lastSavedNotebookAtom);
   const { sendComponentValues, sendInterrupt } = useRequestClient();
 
   const isEditing = viewState.mode === "edit";
@@ -81,19 +86,7 @@ export const EditApp: React.FC<AppProps> = ({
     return () => {
       RuntimeState.INSTANCE.stop();
     };
-  }, []);
-
-  const { connection, reconnect } = useNotebookSession({
-    autoInstantiate: userConfig.runtime.auto_instantiate,
-    setCells: (cells, layout) => {
-      setCells(cells);
-      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(),
-  });
+  }, [sendComponentValues]);
 
   // Update document title whenever filename or app_title changes
   useEffect(() => {
@@ -228,6 +221,7 @@ export const EditApp: React.FC<AppProps> = ({
           />
         </TooltipProvider>
       )}
+      <LazyCommandPalette />
     </>
   );
 };

package/src/core/errors/__tests__/error-entries.test.ts

@@ -1,8 +1,15 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import { createStore } from "jotai";
 import { describe, expect, it } from "vitest";
+import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
-import { type CellErrorEntry, formatCellError } from "../error-entries";
+import { notebookAtom } from "@/core/cells/cells";
+import {
+  type CellErrorEntry,
+  formatCellError,
+  getCellErrorEntries,
+} from "../error-entries";
 
 describe("formatCellError", () => {
   it("formats current tracebacks without notebook source", () => {
@@ -23,3 +30,35 @@ describe("formatCellError", () => {
     expect(text).not.toContain("<span");
   });
 });
+
+describe("getCellErrorEntries", () => {
+  it("pairs an error with the source that raised it, not a later edit", () => {
+    const id = cellId("c1");
+    const store = createStore();
+    store.set(
+      notebookAtom,
+      MockNotebook.notebookState({
+        cellData: { [id]: { code: "print('fixed')" } },
+        cellRuntime: {
+          [id]: {
+            output: {
+              channel: "marimo-error",
+              mimetype: "application/vnd.marimo+error",
+              data: [
+                {
+                  type: "exception",
+                  exception_type: "ZeroDivisionError",
+                  msg: "division by zero",
+                },
+              ],
+              timestamp: 0,
+              code: "1 / 0",
+            },
+          },
+        },
+      }),
+    );
+
+    expect(getCellErrorEntries(store)[0]?.cellCode).toBe("1 / 0");
+  });
+});

package/src/core/errors/error-entries.ts

@@ -80,7 +80,7 @@ export function getCellErrorEntries(store: JotaiStore): CellErrorEntry[] {
   const { cellIds, cellRuntime, cellData } = store.get(notebookAtom);
   const entries: CellErrorEntry[] = [];
 
-  for (const [cellIndex, cellId] of cellIds.inOrderIds.entries()) {
+  for (const [cellIndex, cellId] of cellIds.entries()) {
     const cell = cellRuntime[cellId];
     const output = cell.output;
     if (!output || !isErrorMime(output.mimetype)) {
@@ -93,9 +93,8 @@ export function getCellErrorEntries(store: JotaiStore): CellErrorEntry[] {
     }
 
     const cellName = displayCellName(cellData[cellId].name, cellIndex);
-    // Prefer the code from the last execution: runtime errors correspond to
-    // the previous run, while `code` may already contain unsaved edits.
-    const cellCode = cellData[cellId].lastCodeRun ?? cellData[cellId].code;
+    // The source that raised, since the cell may have been edited since.
+    const cellCode = output.code ?? cellData[cellId].code;
 
     entries.push({
       cellId,
@@ -122,6 +121,9 @@ export function describeError(error: MarimoError): string {
   if (error.type === "import-star") {
     return error.msg;
   }
+  if (error.type === "lazy-import") {
+    return error.msg;
+  }
   if (error.type === "ancestor-stopped") {
     return error.msg;
   }

package/src/core/executions/__tests__/atoms.test.ts

@@ -0,0 +1,98 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { createStore } from "jotai";
+import { describe, expect, it } from "vitest";
+import { MockExecutions } from "@/__mocks__/executions";
+import { cellId } from "@/__tests__/branded";
+import type { CellMessage } from "@/core/kernel/messages";
+import {
+  cellExecutionInputsAtom,
+  notebookQueuedOrRunningCountAtom,
+  observeCellMessage,
+  submitCells,
+} from "../atoms";
+import { cellExecutionView } from "../select";
+
+const C1 = cellId("c1");
+
+function cellOp(status: CellMessage["status"]): CellMessage {
+  return {
+    cell_id: C1,
+    output: null,
+    console: null,
+    status,
+    timestamp: 1,
+  };
+}
+
+describe("observeCellMessage", () => {
+  it("withdraws a submission once the kernel reports the cell blocked", () => {
+    const store = createStore();
+    MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+    expect(
+      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
+    ).toBe("queued");
+
+    observeCellMessage(store, cellOp("disabled-transitively"));
+
+    const view = cellExecutionView(store.get(cellExecutionInputsAtom), C1);
+    expect(view.status).toBe("idle");
+    expect(view.blocked).toBe(true);
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+
+  it("forgets submissions and blocked cells with the replica they were made for", () => {
+    const store = createStore();
+    MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+    observeCellMessage(store, cellOp("disabled-transitively"));
+
+    MockExecutions.seed(store, []);
+
+    const view = cellExecutionView(store.get(cellExecutionInputsAtom), C1);
+    expect(view.status).toBe("idle");
+    expect(view.blocked).toBe(false);
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+
+  it("keeps a submission while the cell is merely queued", () => {
+    const store = createStore();
+    MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+
+    observeCellMessage(store, cellOp("queued"));
+
+    expect(
+      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
+    ).toBe("queued");
+  });
+
+  it("forgets acknowledged submissions and blocked cells when the replica follows a new notebook", () => {
+    const store = createStore();
+    const replica = MockExecutions.seed(store, []);
+    submitCells(store, [C1]);
+    observeCellMessage(store, {
+      ...cellOp("disabled-transitively"),
+      cell_id: cellId("c2"),
+    });
+
+    const completed = MockExecutions.inputs([MockExecutions.completed(C1)]);
+    store.set(replica.executionsAtom, completed.executions);
+    store.set(replica.resultsAtom, completed.results);
+    expect(
+      cellExecutionView(store.get(cellExecutionInputsAtom), C1).status,
+    ).toBe("idle");
+
+    const empty = MockExecutions.inputs([]);
+    store.set(replica.executionsAtom, empty.executions);
+    store.set(replica.resultsAtom, empty.results);
+    store.set(replica.notebookAtom, {
+      ...store.get(replica.notebookAtom),
+      id: "n2",
+    });
+
+    expect(store.get(cellExecutionInputsAtom)).toEqual(empty);
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(0);
+  });
+});