@marimo-team/frontend 0.25.3-dev104 → 0.25.3-dev108

package/src/core/codemirror/language/__tests__/sql.test.ts

@@ -42,12 +42,14 @@ const adapter = new SQLLanguageAdapter();
 const TEST_ENGINE = "test_engine" as ConnectionName;
 
 const TEST_EXTENSION_ARGS = [
-  {} as CellId,
-  {} as CompletionConfig,
-  {} as HotkeyProvider,
-  {} as PlaceholderType,
-  {} as LSPConfig & {
-    diagnostics: DiagnosticsConfig;
+  {
+    cellId: {} as CellId,
+    completionConfig: {} as CompletionConfig,
+    hotkeys: {} as HotkeyProvider,
+    placeholderType: {} as PlaceholderType,
+    lspConfig: {} as LSPConfig & {
+      diagnostics: DiagnosticsConfig;
+    },
   },
 ] as const;
 
@@ -930,15 +932,15 @@ describe("SQL analysis features", () => {
 
   it("reports semantic diagnostics as warnings", async () => {
     const adapter = new SQLLanguageAdapter();
-    const extensions = adapter.getExtension(
-      {} as CellId,
-      {} as CompletionConfig,
-      {} as HotkeyProvider,
-      {} as PlaceholderType,
-      {
+    const extensions = adapter.getExtension({
+      cellId: {} as CellId,
+      completionConfig: {} as CompletionConfig,
+      hotkeys: {} as HotkeyProvider,
+      placeholderType: {} as PlaceholderType,
+      lspConfig: {
         diagnostics: { sql_linter: true },
       } as LSPConfig & { diagnostics: DiagnosticsConfig },
-    );
+    });
     const state = EditorState.create({
       doc: "SELECT missing FROM users",
       extensions: [languageMetadataField.init(() => metadata), ...extensions],
@@ -963,15 +965,15 @@ describe("SQL analysis features", () => {
 
   it("does not report unknown tables", async () => {
     const adapter = new SQLLanguageAdapter();
-    const extensions = adapter.getExtension(
-      {} as CellId,
-      {} as CompletionConfig,
-      {} as HotkeyProvider,
-      {} as PlaceholderType,
-      {
+    const extensions = adapter.getExtension({
+      cellId: {} as CellId,
+      completionConfig: {} as CompletionConfig,
+      hotkeys: {} as HotkeyProvider,
+      placeholderType: {} as PlaceholderType,
+      lspConfig: {
         diagnostics: { sql_linter: true },
       } as LSPConfig & { diagnostics: DiagnosticsConfig },
-    );
+    });
     const state = EditorState.create({
       doc: "SELECT missing FROM users; SELECT * FROM unknown_table",
       extensions: [languageMetadataField.init(() => metadata), ...extensions],

package/src/core/codemirror/language/extension.ts

@@ -167,13 +167,13 @@ function updateLanguageAdapterAndCode({
       setLanguageAdapter.of(nextLanguage),
       setLanguageMetadata.of(metadata),
       languageCompartment.reconfigure(
-        nextLanguage.getExtension(
+        nextLanguage.getExtension({
           cellId,
           completionConfig,
-          hotkeysProvider,
+          hotkeys: hotkeysProvider,
           placeholderType,
           lspConfig,
-        ),
+        }),
       ),
       // Clear history
       historyCompartment.reconfigure([]),
@@ -218,13 +218,13 @@ export function adaptiveLanguageConfiguration(opts: {
     // Language adapter
     languageToggleKeymaps(),
     languageCompartment.of(
-      LanguageAdapters.python.getExtension(
+      LanguageAdapters.python.getExtension({
         cellId,
         completionConfig,
         hotkeys,
         placeholderType,
         lspConfig,
-      ),
+      }),
     ),
     languageAdapterState,
     languageMetadataField,
@@ -323,12 +323,12 @@ export function reconfigureLanguageEffect(
   }
 
   return languageCompartment.reconfigure(
-    language.getExtension(
+    language.getExtension({
       cellId,
       completionConfig,
-      hotkeysProvider,
+      hotkeys: hotkeysProvider,
       placeholderType,
       lspConfig,
-    ),
+    }),
   );
 }

package/src/core/codemirror/language/languages/markdown.ts

@@ -69,12 +69,14 @@ export class MarkdownLanguageAdapter implements LanguageAdapter<MarkdownLanguage
     return this.parser.isSupported(pythonCode);
   }
 
-  public getExtension(
-    _cellId: CellId,
-    _completionConfig: CompletionConfig,
-    hotkeys: HotkeyProvider,
-    _placeholderType: PlaceholderType,
-  ): Extension[] {
+  public getExtension({
+    hotkeys,
+  }: {
+    cellId: CellId;
+    completionConfig: CompletionConfig;
+    hotkeys: HotkeyProvider;
+    placeholderType: PlaceholderType;
+  }): Extension[] {
     const markdownLanguageData = markdown().language.data;
     let view: EditorView | undefined;
 

package/src/core/codemirror/language/languages/python.ts

@@ -279,13 +279,19 @@ export class PythonLanguageAdapter implements LanguageAdapter<{}> {
     return this.parser.isSupported(code);
   }
 
-  public getExtension(
-    cellId: CellId,
-    completionConfig: CompletionConfig,
-    hotkeys: HotkeyProvider,
-    placeholderType: PlaceholderType,
-    lspConfig: LSPConfig & { diagnostics: DiagnosticsConfig },
-  ): Extension[] {
+  public getExtension({
+    cellId,
+    completionConfig,
+    hotkeys,
+    placeholderType,
+    lspConfig,
+  }: {
+    cellId: CellId;
+    completionConfig: CompletionConfig;
+    hotkeys: HotkeyProvider;
+    placeholderType: PlaceholderType;
+    lspConfig: LSPConfig & { diagnostics: DiagnosticsConfig };
+  }): Extension[] {
     const getCompletionsExtension = () => {
       const autocompleteOptions = {
         // We remove the default keymap because we use our own which

package/src/core/codemirror/language/languages/sql/sql.ts

@@ -155,13 +155,15 @@ export class SQLLanguageAdapter implements LanguageAdapter<SQLLanguageAdapterMet
     return this.parser.isSupported(pythonCode);
   }
 
-  public getExtension(
-    _cellId: CellId,
-    _completionConfig: CompletionConfig,
-    _hotkeys: HotkeyProvider,
-    _placeholderType: PlaceholderType,
-    lspConfig: LSPConfig & { diagnostics: DiagnosticsConfig },
-  ): Extension[] {
+  public getExtension({
+    lspConfig,
+  }: {
+    cellId: CellId;
+    completionConfig: CompletionConfig;
+    hotkeys: HotkeyProvider;
+    placeholderType: PlaceholderType;
+    lspConfig: LSPConfig & { diagnostics: DiagnosticsConfig };
+  }): Extension[] {
     const analysis = createSQLAnalysis();
     const extensions = [
       // This can be updated with a dispatch effect

package/src/core/codemirror/language/types.ts

@@ -26,13 +26,13 @@ export interface LanguageAdapter<M = Record<string, any>> {
   transformIn(code: string): [string, number, M];
   transformOut(code: string, metadata: M): [string, number];
   isSupported(code: string): boolean;
-  getExtension(
-    cellId: CellId,
-    completionConfig: CompletionConfig,
-    hotkeys: HotkeyProvider,
-    placeholderType: PlaceholderType,
-    lspConfig: LSPConfig & { diagnostics?: DiagnosticsConfig },
-  ): Extension[];
+  getExtension(options: {
+    cellId: CellId;
+    completionConfig: CompletionConfig;
+    hotkeys: HotkeyProvider;
+    placeholderType: PlaceholderType;
+    lspConfig: LSPConfig & { diagnostics?: DiagnosticsConfig };
+  }): Extension[];
 }
 
 export type LanguageMetadataOf<T extends LanguageAdapter> =

package/src/core/codemirror/rtc/extension.ts

@@ -207,7 +207,13 @@ export function realTimeCollaboration(
     extension: [
       languageObserverExtension(cellId),
       languageListenerExtension(cellId),
-      loroAwarenessPlugin(doc, awareness, userState, () => loroText, cellId),
+      loroAwarenessPlugin({
+        doc,
+        awareness,
+        user: userState,
+        getTextFromDoc: () => loroText,
+        cellId,
+      }),
       loroSyncPlugin(doc, ["codes", cellId], () => {
         return loroText;
       }),
@@ -419,14 +425,21 @@ function languageListenerExtension(cellId: CellId) {
 /**
  * Create a plugin to observe awareness changes
  */
-function loroAwarenessPlugin(
-  doc: LoroDoc,
-  awareness: Awareness<AwarenessState>,
-  user: UserState,
-  getTextFromDoc: (doc: LoroDoc) => LoroText,
-  cellId: CellId,
-  getUserId?: () => Uid,
-): Extension[] {
+function loroAwarenessPlugin({
+  doc,
+  awareness,
+  user,
+  getTextFromDoc,
+  cellId,
+  getUserId,
+}: {
+  doc: LoroDoc;
+  awareness: Awareness<AwarenessState>;
+  user: UserState;
+  getTextFromDoc: (doc: LoroDoc) => LoroText;
+  cellId: CellId;
+  getUserId?: () => Uid;
+}): Extension[] {
   const scopeId = `loro:cell:${cellId}` as ScopeId;
 
   return [
@@ -435,15 +448,14 @@ function loroAwarenessPlugin(
     createSelectionLayer(),
     ViewPlugin.define(
       (view) =>
-        new AwarenessPlugin(
-          view,
+        new AwarenessPlugin(view, {
           doc,
           user,
           awareness,
           getTextFromDoc,
           scopeId,
           getUserId,
-        ),
+        }),
     ),
     ViewPlugin.define(
       (view) => new RemoteAwarenessPlugin(view, doc, awareness, scopeId),

package/src/core/codemirror/rtc/loro/awareness.ts

@@ -208,13 +208,19 @@ export class RemoteCursorMarker implements LayerMarker {
   private name: string;
   private colorClassName: string;
 
-  public constructor(
-    left: number,
-    top: number,
-    height: number,
-    name: string,
-    colorClassName: string,
-  ) {
+  public constructor({
+    left,
+    top,
+    height,
+    name,
+    colorClassName,
+  }: {
+    left: number;
+    top: number;
+    height: number;
+    name: string;
+    colorClassName: string;
+  }) {
     this.left = left;
     this.top = top;
     this.height = height;
@@ -271,13 +277,13 @@ export class RemoteCursorMarker implements LayerMarker {
     const baseLeft = left - view.scrollDOM.scrollLeft;
     const baseTop = rect.top - view.scrollDOM.scrollTop;
     return [
-      new RemoteCursorMarker(
-        absolutePosition.left - baseLeft,
-        absolutePosition.top - baseTop,
-        absolutePosition.bottom - absolutePosition.top,
-        displayName,
+      new RemoteCursorMarker({
+        left: absolutePosition.left - baseLeft,
+        top: absolutePosition.top - baseTop,
+        height: absolutePosition.bottom - absolutePosition.top,
+        name: displayName,
         colorClassName,
-      ),
+      }),
     ];
   }
 
@@ -375,12 +381,21 @@ export class AwarenessPlugin implements PluginValue {
 
   public constructor(
     view: EditorView,
-    doc: LoroDoc,
-    user: UserState,
-    awareness: Awareness<AwarenessState>,
-    getTextFromDoc: (doc: LoroDoc) => LoroText,
-    scopeId: ScopeId,
-    getUserId?: () => Uid,
+    {
+      doc,
+      user,
+      awareness,
+      getTextFromDoc,
+      scopeId,
+      getUserId,
+    }: {
+      doc: LoroDoc;
+      user: UserState;
+      awareness: Awareness<AwarenessState>;
+      getTextFromDoc: (doc: LoroDoc) => LoroText;
+      scopeId: ScopeId;
+      getUserId?: () => Uid;
+    },
   ) {
     this.view = view;
     this.doc = doc;

package/src/core/codemirror/rtc/loro/sync.ts

@@ -148,6 +148,7 @@ export class LoroSyncPluginValue implements PluginValue {
       return;
     }
     let adj = 0;
+    // oxlint-disable-next-line marimo/prefer-object-params -- CodeMirror supplies positional change ranges and inserted text.
     update.changes.iterChanges((fromA, toA, fromB, toB, insert) => {
       const insertText = insert.sliceString(0, insert.length, "\n");
       if (fromA !== toA) {

package/src/core/codemirror/utils.ts

@@ -122,6 +122,7 @@ export function hasNewLines(tr: Transaction | ViewUpdate): boolean {
 
   let hasNewLines = false;
   // Iterate through all changes in the transaction
+  // oxlint-disable-next-line marimo/prefer-object-params -- CodeMirror supplies positional change ranges and inserted text.
   tr.changes.iterChanges((fromA, toA, fromB, toB, inserted) => {
     // Check if the inserted text contains line breaks
     if (inserted.toString().includes("\n")) {

package/src/core/host/__tests__/static.test.ts

@@ -0,0 +1,167 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { createNotebookReducer, NotebookEvents } from "@marimo-team/client";
+import * as Protocol from "@marimo-team/client/protocol";
+import { afterEach, assert, describe, expect, it, vi } from "vitest";
+import { document as documentResource } from "../resources/document";
+import {
+  createStaticNotebookBackend,
+  type StaticNotebookSnapshot,
+} from "../static";
+import { fixtureEvents } from "./fixtures";
+
+function snapshot(): StaticNotebookSnapshot {
+  const events = fixtureEvents("notebook-events.sse");
+  const notebook = events.find((event) => event.event === "notebook")?.data
+    .notebook;
+  const document = events.find((event) => event.event === "document")?.data
+    .document;
+  assert(notebook && document);
+  return {
+    notebook,
+    document,
+    cells: events.flatMap((event) =>
+      event.event === "cell" ? [event.data.cell] : [],
+    ),
+  };
+}
+
+const streams: NotebookEvents[] = [];
+afterEach(async () => {
+  const closed = streams.splice(0);
+  closed.forEach((stream) => stream.close());
+  await Promise.all(closed.map((stream) => stream.closed));
+  vi.useRealTimers();
+});
+
+async function read(
+  backend: ReturnType<typeof createStaticNotebookBackend>,
+  cursor?: string,
+) {
+  const stream = new NotebookEvents(backend.transport, { cursor });
+  streams.push(stream);
+  const events: Protocol.EventOutput[] = [];
+  await new Promise<void>((resolve, reject) => {
+    stream.subscribe((event) => {
+      events.push(Protocol.Event.parse(event));
+      if (event.event === "ready") {
+        resolve();
+      }
+    }, reject);
+  });
+  return { stream, events };
+}
+
+describe("static notebook backend", () => {
+  it("supplies a complete document through the normal event reader and reducer", async () => {
+    const source = snapshot();
+    const { stream, events } = await read(createStaticNotebookBackend(source));
+    const reducer = createNotebookReducer({ document: documentResource });
+    const state = events.reduce(reducer.reduce, reducer.initial);
+    expect(events.map((event) => event.event)).toEqual([
+      "notebook",
+      "cell",
+      "cell",
+      "cell",
+      "document",
+      "ready",
+    ]);
+    expect(state.notebook).toEqual({ ...source.notebook, operations: [] });
+    expect(state.resources.document.current).toEqual({
+      revision: source.document,
+      cells: new Map(source.cells.map((cell) => [cell.id, cell])),
+    });
+    expect(stream.status).toBe("connected");
+  });
+
+  it("preserves withheld source and its revision metadata", async () => {
+    const source = snapshot();
+    const cells = source.cells.map((cell) => ({ ...cell, code: null }));
+    const { events } = await read(
+      createStaticNotebookBackend({ ...source, cells }),
+    );
+    expect(
+      events
+        .filter((event) => event.event === "cell")
+        .map((event) => event.data.cell),
+    ).toEqual(cells);
+    expect(
+      events.find((event) => event.event === "document")?.data.document,
+    ).toEqual(source.document);
+  });
+
+  it("serves an empty document as available", async () => {
+    const source = snapshot();
+    const document = { ...source.document, order: [] };
+    const { events } = await read(
+      createStaticNotebookBackend({ ...source, document, cells: [] }),
+    );
+    const reducer = createNotebookReducer({ document: documentResource });
+    expect(
+      events.reduce(reducer.reduce, reducer.initial).resources.document.current,
+    ).toEqual({
+      revision: document,
+      cells: new Map(),
+    });
+  });
+
+  it("keeps independent readers open without polling or reconnecting", async () => {
+    vi.useFakeTimers();
+    const backend = createStaticNotebookBackend(snapshot());
+    const first = await read(backend);
+    const second = await read(backend);
+    first.stream.close();
+    await first.stream.closed;
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(second.events).toEqual(first.events);
+    expect(second.stream.status).toBe("connected");
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("resets a resume cursor before replaying its snapshot", async () => {
+    const { events } = await read(
+      createStaticNotebookBackend(snapshot()),
+      "previous-10",
+    );
+    expect(events[0]).toEqual({ event: "reset", data: {} });
+    expect(events.at(-1)).toEqual({ event: "ready", id: "static", data: {} });
+  });
+
+  it("advertises no mutations and returns a protocol failure for direct edits", async () => {
+    const backend = createStaticNotebookBackend(snapshot());
+    expect(await backend.client.edit([])).toEqual({
+      ok: false,
+      status: 501,
+      problem: {
+        type: "tag:marimo.io,2026:host/unsupported-operation",
+        title: "Unsupported operation",
+        status: 501,
+        detail: "Static notebooks do not support editing",
+      },
+    });
+  });
+
+  it("respects cancellation before opening, during delivery, and for commands", async () => {
+    const backend = createStaticNotebookBackend(snapshot());
+    const before = new AbortController();
+    before.abort();
+    const open = vi.fn();
+    const message = vi.fn();
+    await backend.transport(
+      { cursor: null, signal: before.signal },
+      { open, message },
+    );
+    expect(open).not.toHaveBeenCalled();
+    expect(message).not.toHaveBeenCalled();
+    await expect(
+      backend.client.edit([], { signal: before.signal }),
+    ).rejects.toBe(before.signal.reason);
+    const during = new AbortController();
+    message.mockImplementation(() => during.abort());
+    await backend.transport(
+      { cursor: null, signal: during.signal },
+      { open, message },
+    );
+    expect(message).toHaveBeenCalledOnce();
+  });
+});

package/src/core/host/backend.ts

@@ -0,0 +1,10 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { NotebookClient, NotebookTransport } from "@marimo-team/client";
+
+/** Events and commands for the same notebook, independent of React or a replica. */
+export interface NotebookBackend {
+  readonly transport: NotebookTransport;
+  /** Method presence is not permission; the notebook advertises its operations. */
+  readonly client: Pick<NotebookClient, "edit">;
+}

package/src/core/host/static.ts

@@ -0,0 +1,70 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type * as Protocol from "@marimo-team/client/protocol";
+import type { NotebookBackend } from "./backend";
+
+/** A document snapshot with its own identity and revision metadata. */
+export interface StaticNotebookSnapshot {
+  readonly notebook: Omit<Protocol.Notebook, "operations">;
+  readonly document: Protocol.Document;
+  readonly cells: readonly Protocol.Cell[];
+}
+
+/**
+ * Serve a document without a server, runtime, or mutation operations.
+ * Callers and readers must treat the snapshot records as immutable.
+ */
+export function createStaticNotebookBackend(
+  snapshot: StaticNotebookSnapshot,
+): NotebookBackend {
+  const frames: Protocol.Event[] = [
+    {
+      event: "notebook",
+      data: { notebook: { ...snapshot.notebook, operations: [] } },
+    },
+    ...snapshot.cells.map((cell): Protocol.CellEvent => ({
+      event: "cell",
+      data: { cell },
+    })),
+    { event: "document", data: { document: snapshot.document } },
+    { event: "ready", id: "static", data: {} },
+  ];
+
+  return {
+    transport: ({ cursor, signal }, { open, message }) =>
+      new Promise((resolve) => {
+        if (signal.aborted) {
+          resolve();
+          return;
+        }
+        // Finishing would ask NotebookEvents to reconnect. A snapshot stays open
+        // until its reader closes, even though there are no more updates.
+        signal.addEventListener("abort", () => resolve(), { once: true });
+        open();
+        if (cursor !== null && !signal.aborted) {
+          message({ event: "reset", data: {} });
+        }
+        for (const frame of frames) {
+          if (signal.aborted) {
+            return;
+          }
+          message(frame);
+        }
+      }),
+    client: {
+      edit: async (_changes, options) => {
+        options?.signal?.throwIfAborted();
+        return {
+          ok: false,
+          status: 501,
+          problem: {
+            type: "tag:marimo.io,2026:host/unsupported-operation",
+            title: "Unsupported operation",
+            status: 501,
+            detail: "Static notebooks do not support editing",
+          },
+        };
+      },
+    },
+  };
+}

package/src/core/islands/components/__tests__/IslandControls.test.tsx

@@ -2,6 +2,7 @@
 
 import { fireEvent, render, screen } from "@testing-library/react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MockRequestClient } from "@/__mocks__/requests";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import type { CellId } from "@/core/cells/ids";
 import * as requestsModule from "@/core/network/requests";
@@ -18,7 +19,8 @@ vi.mock("@/utils/copy", () => ({
 }));
 
 describe("IslandControls", () => {
-  const mockSendRun = vi.fn();
+  const mockSendRun =
+    vi.fn<ReturnType<typeof requestsModule.useRequestClient>["sendRun"]>();
   const mockCopyToClipboard = vi.fn();
   const mockCodeCallback = vi.fn(() => "print('test code')");
   const cellId = "test-cell-id" as CellId;
@@ -30,11 +32,11 @@ describe("IslandControls", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockSendRun.mockResolvedValue(undefined);
+    mockSendRun.mockResolvedValue(null);
 
-    vi.spyOn(requestsModule, "useRequestClient").mockReturnValue({
-      sendRun: mockSendRun,
-    } as any);
+    vi.spyOn(requestsModule, "useRequestClient").mockReturnValue(
+      MockRequestClient.create({ sendRun: mockSendRun }),
+    );
 
     vi.spyOn(copyModule, "copyToClipboard").mockImplementation(
       mockCopyToClipboard,