@marimo-team/islands 0.23.14-dev6 → 0.23.14-dev61

package/src/core/codemirror/go-to-definition/underline.ts

@@ -55,12 +55,9 @@ class MetaUnderlineVariablePlugin {
   private view: EditorView;
   private commandClickMode: boolean;
   private hoveredRange: { from: number; to: number; position: number } | null;
-  private onClick: (view: EditorView, variableName: string) => void;
+  private onClick: (view: EditorView) => void;
 
-  constructor(
-    view: EditorView,
-    onClick: (view: EditorView, variableName: string) => void,
-  ) {
+  constructor(view: EditorView, onClick: (view: EditorView) => void) {
     this.view = view;
     this.commandClickMode = false;
     this.hoveredRange = null;
@@ -191,20 +188,16 @@ class MetaUnderlineVariablePlugin {
   // If we have a hovered range, go to it
   private click = (event: MouseEvent) => {
     if (this.hoveredRange) {
-      const variableName = this.view.state.doc.sliceString(
-        this.hoveredRange.from,
-        this.hoveredRange.to,
-      );
       event.preventDefault();
       event.stopPropagation();
-      this.onClick(this.view, variableName);
-      // Move the cursor to the clicked position
+      // Move the cursor before resolving so LSP uses the clicked position.
       this.view.dispatch({
         selection: {
           head: this.hoveredRange.position,
           anchor: this.hoveredRange.position,
         },
       });
+      this.onClick(this.view);
     }
   };
 
@@ -217,7 +210,5 @@ class MetaUnderlineVariablePlugin {
   }
 }
 
-export const createUnderlinePlugin = (
-  onClick: (view: EditorView, variableName: string) => void,
-) =>
+export const createUnderlinePlugin = (onClick: (view: EditorView) => void) =>
   ViewPlugin.define((view) => new MetaUnderlineVariablePlugin(view, onClick));

package/src/core/codemirror/go-to-definition/utils.ts

@@ -2,8 +2,14 @@
 
 import { closeCompletion } from "@codemirror/autocomplete";
 import type { EditorState } from "@codemirror/state";
-import { closeHoverTooltips, type EditorView } from "@codemirror/view";
+import {
+  closeHoverTooltips,
+  type EditorView,
+  type KeyBinding,
+  keymap,
+} from "@codemirror/view";
 import type { CellId } from "@/core/cells/ids";
+import { hotkeysAtom, platformAtom } from "../../config/config";
 import { notebookAtom } from "../../cells/cells";
 import { store } from "../../state/jotai";
 import { variablesAtom } from "../../variables/state";
@@ -11,6 +17,20 @@ import type { VariableName, Variables } from "../../variables/types";
 import { getPositionAtWordBounds } from "../completion/hints";
 import { goToLine, goToVariableDefinition } from "./commands";
 
+function keymapBindingMatchesHotkey(
+  binding: KeyBinding,
+  hotkey: string,
+): boolean {
+  const platform = store.get(platformAtom);
+  const bindingKey =
+    platform === "mac"
+      ? (binding.mac ?? binding.key)
+      : platform === "windows"
+        ? (binding.win ?? binding.key)
+        : (binding.linux ?? binding.key);
+  return bindingKey === hotkey;
+}
+
 /**
  * Get the word under the cursor.
  */
@@ -68,6 +88,34 @@ export function goToDefinitionAtCursorPosition(view: EditorView): boolean {
   return goToDefinition(view, word, position);
 }
 
+/**
+ * Invoke the editor's go-to-definition keymap handlers for the configured
+ * hotkey. Matches CodeMirror key strings directly (including customized
+ * shortcuts like `Ctrl-F12`) instead of synthesizing keyboard events.
+ */
+export function requestLspGoToDefinition(
+  view: EditorView,
+  hotkey = store.get(hotkeysAtom).getHotkey("cell.goToDefinition").key,
+): boolean {
+  for (const binding of view.state.facet(keymap).flat()) {
+    if (keymapBindingMatchesHotkey(binding, hotkey) && binding.run?.(view)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Go to the definition under the cursor, falling back to the language server
+ * when marimo cannot resolve the symbol (e.g. external library code).
+ */
+export function goToDefinitionWithLspFallback(view: EditorView): boolean {
+  if (goToDefinitionAtCursorPosition(view)) {
+    return true;
+  }
+  return requestLspGoToDefinition(view);
+}
+
 /**
  * Go to the definition of the variable under the cursor.
  * @param view The editor view at which the command was invoked.

package/src/core/codemirror/utils.ts

@@ -2,6 +2,7 @@
 import type { EditorState, Transaction } from "@codemirror/state";
 import type { EditorView, ViewUpdate } from "@codemirror/view";
 import { getCM } from "@replit/codemirror-vim";
+import type { ReactCodeMirrorRef } from "@uiw/react-codemirror";
 
 export function isAtStartOfEditor(ev: { state: EditorState }) {
   const main = ev.state.selection.main;
@@ -37,6 +38,20 @@ export function moveToEndOfEditor(ev: EditorView | undefined) {
   });
 }
 
+/** We delay the focus and move to end of the editor until React has rendered the prefilled value. */
+export function focusInputAndMoveToEnd(
+  ref: React.RefObject<ReactCodeMirrorRef | null>,
+) {
+  requestAnimationFrame(() => {
+    const view = ref.current?.view;
+    if (!view) {
+      return;
+    }
+    view.focus();
+    moveToEndOfEditor(view);
+  });
+}
+
 export function isInVimMode(ev: EditorView): boolean {
   return getCM(ev)?.state.vim != null;
 }

package/src/core/config/__tests__/config-schema.test.ts

@@ -4,6 +4,7 @@ import { createStore } from "jotai";
 import { expect, test } from "vitest";
 import {
   configOverridesAtom,
+  connectionTransportTypeAtom,
   resolvedMarimoConfigAtom,
   userConfigAtom,
 } from "../config";
@@ -296,3 +297,19 @@ test("resolvedMarimoConfigAtom overrides correctly and does not mutate the origi
     formatting: { line_length: 79 },
   });
 });
+
+test("connectionTransportTypeAtom defaults to websocket", () => {
+  const store = createStore();
+  store.set(userConfigAtom, defaultUserConfig());
+  expect(store.get(connectionTransportTypeAtom)).toBe("websocket");
+});
+
+test("connectionTransportTypeAtom reads server.transport", () => {
+  const store = createStore();
+  const config = defaultUserConfig();
+  store.set(userConfigAtom, {
+    ...config,
+    server: { ...config.server, transport: "sse" },
+  });
+  expect(store.get(connectionTransportTypeAtom)).toBe("sse");
+});

package/src/core/config/config-schema.ts

@@ -203,6 +203,7 @@ export const UserConfigSchema = z
     server: z
       .looseObject({
         disable_file_downloads: z.boolean().optional(),
+        transport: z.enum(["websocket", "sse"]).optional(),
       })
       .prefault(() => ({})),
     diagnostics: z

package/src/core/config/config.ts

@@ -44,6 +44,16 @@ export const autoSaveConfigAtom = atom((get) => {
   return get(resolvedMarimoConfigAtom).save;
 });
 
+/**
+ * The transport used to stream kernel messages from the server.
+ * Experimental; configured via `server.transport`.
+ */
+export const connectionTransportTypeAtom = atom<"websocket" | "sse">((get) => {
+  return get(resolvedMarimoConfigAtom).server.transport === "sse"
+    ? "sse"
+    : "websocket";
+});
+
 export const aiAtom = atom((get) => {
   return get(resolvedMarimoConfigAtom).ai;
 });

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

@@ -11,6 +11,8 @@ export interface ExperimentalFeatures {
   rtc_v2: boolean;
   cache_panel: boolean;
   external_agents: boolean;
+  debugger: boolean; // Live frame-watching debugger (gutter breakpoints + pdb)
+  line_timing: boolean; // Green active-line highlight + per-line elapsed timer
   // Add new feature flags here
 }
 
@@ -20,6 +22,8 @@ const defaultValues: ExperimentalFeatures = {
   rtc_v2: false,
   cache_panel: false,
   external_agents: import.meta.env.DEV,
+  debugger: false,
+  line_timing: false,
 };
 
 export function getFeatureFlag<T extends keyof ExperimentalFeatures>(

package/src/core/edit-app.tsx

@@ -13,6 +13,7 @@ import { AppHeader } from "@/components/editor/header/app-header";
 import { FilenameForm } from "@/components/editor/header/filename-form";
 import { MultiCellActionToolbar } from "@/components/editor/navigation/multi-cell-action-toolbar";
 import { ViewerBanner } from "@/components/editor/viewer-banner";
+import { ProgressiveBoundary } from "@/components/lifecycle/ProgressiveBoundary";
 import { cn } from "@/utils/cn";
 import { Paths } from "@/utils/paths";
 import { AppContainer } from "../components/editor/app-container";
@@ -64,7 +65,6 @@ export const EditApp: React.FC<AppProps> = ({
     useCellActions();
   const viewState = useAtomValue(viewStateAtom);
   const numColumns = useAtomValue(numColumnsAtom);
-  const hasCells = useAtomValue(hasCellsAtom);
   const filename = useFilename();
   const setLastSavedNotebook = useSetAtom(lastSavedNotebookAtom);
   const { sendComponentValues, sendInterrupt } = useRequestClient();
@@ -181,13 +181,16 @@ export const EditApp: React.FC<AppProps> = ({
 
         <ViewerBanner />
 
-        {/* Don't render until we have a single cell */}
-        {hasCells && (
+        {/* Don't render until we have a single cell. NotStartedConnectionAlert
+            still covers the "no remote runtime started" prompt. */}
+        <ProgressiveBoundary
+          requires={hasCellsAtom}
+          fallback={<NotStartedConnectionAlert />}
+        >
           <CellsRenderer appConfig={appConfig} mode={viewState.mode}>
             {editableCellsArray}
           </CellsRenderer>
-        )}
-        {!hasCells && <NotStartedConnectionAlert />}
+        </ProgressiveBoundary>
       </AppContainer>
       <MultiCellActionToolbar />
       {!hideControls && (

package/src/core/errors/errors.ts

@@ -6,6 +6,7 @@ import type { AiCompletionCell } from "../ai/state";
 import type { CellId } from "../cells/ids";
 import type { MarimoError } from "../kernel/messages";
 import { wrapInFunction } from "./utils";
+import { store } from "../state/jotai";
 
 interface AIFix {
   setAiCompletionCell: (opts: AiCompletionCell) => void;
@@ -84,7 +85,7 @@ export function getAutoFixes(
         description: "Fix the SQL statement",
         fixType: "ai",
         onFix: async (ctx) => {
-          const datasourceContext = getDatasourceContext(ctx.cellId);
+          const datasourceContext = getDatasourceContext(ctx.cellId, store);
           let initialPrompt = `Fix the SQL statement: ${error.msg}.`;
           if (datasourceContext) {
             initialPrompt += `\nDatabase schema: ${datasourceContext}`;

package/src/core/islands/bootstrap.ts

@@ -5,8 +5,8 @@ import { ISLAND_CSS_CLASSES, ISLAND_TAG_NAMES } from "@/core/islands/constants";
 import { renderHTML } from "@/plugins/core/RenderHTML";
 import {
   handleWidgetMessage,
-  MODEL_MANAGER,
-} from "@/plugins/impl/anywidget/model";
+  WIDGET_REGISTRY,
+} from "@/plugins/impl/anywidget/registry";
 import { initializePlugins } from "@/plugins/plugins";
 import { Functions } from "@/utils/functions";
 import {
@@ -174,6 +174,7 @@ function handleMessage(
       case "completion-result":
       case "reload":
       case "focus-cell":
+      case "active-line":
       case "variables":
       case "variable-values":
       case "data-column-preview":
@@ -252,7 +253,7 @@ function handleMessage(
         return;
 
       case "model-lifecycle":
-        handleWidgetMessage(MODEL_MANAGER, msg.data);
+        handleWidgetMessage(WIDGET_REGISTRY, msg.data);
         return;
 
       case "consumer-capabilities":

package/src/core/islands/bridge.ts

@@ -244,6 +244,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   sendListFiles = throwNotImplemented;
   sendSearchFiles = throwNotImplemented;
   sendPdb = throwNotImplemented;
+  sendSetBreakpoints = throwNotImplemented;
   sendCreateFileOrFolder = throwNotImplemented;
   sendDeleteFileOrFolder = throwNotImplemented;
   sendCopyFileOrFolder = throwNotImplemented;

package/src/core/lifecycle/__tests__/render-policy.test.ts

@@ -0,0 +1,247 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { visibleForTesting } from "../render-policy";
+
+const { computeRenderPolicy } = visibleForTesting;
+
+const originalHref = window.location.href;
+function setSearch(search: string) {
+  window.history.replaceState(null, "", `/${search}`);
+}
+
+describe("computeRenderPolicy", () => {
+  it("shows code in edit mode", () => {
+    const policy = computeRenderPolicy({
+      mode: "edit",
+      showAppCode: false, // ignored in edit mode
+      hasCells: true,
+      hasCachedOutputs: false,
+      allCellsIdle: false,
+    });
+    expect(policy.showCode).toBe(true);
+  });
+
+  it("hides code in present mode regardless of config", () => {
+    const policy = computeRenderPolicy({
+      mode: "present",
+      showAppCode: true,
+      hasCells: true,
+      hasCachedOutputs: true,
+      allCellsIdle: false,
+    });
+    expect(policy.showCode).toBe(false);
+  });
+
+  it("respects showAppCode in read mode", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: true,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: false,
+      }).showCode,
+    ).toBe(true);
+
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: false,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: false,
+      }).showCode,
+    ).toBe(false);
+  });
+
+  it("reports showCachedOutputs when cells and cached outputs are present", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: false,
+        hasCells: true,
+        hasCachedOutputs: true,
+        allCellsIdle: false,
+      }).showCachedOutputs,
+    ).toBe(true);
+  });
+
+  it("does not report showCachedOutputs when there are no cells", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: false,
+        hasCells: false,
+        hasCachedOutputs: true,
+        allCellsIdle: false,
+      }).showCachedOutputs,
+    ).toBe(false);
+  });
+
+  it("only reports showCachedOutputs for real outputs, not an idle notebook", () => {
+    // Regression guard: `showCachedOutputs` must stay honest even when the
+    // notebook is settled with no outputs (that only affects `canPaint`).
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: false,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: true,
+      }).showCachedOutputs,
+    ).toBe(false);
+  });
+});
+
+describe("computeRenderPolicy — read-mode code visibility", () => {
+  beforeEach(() => {
+    setSearch("");
+  });
+
+  afterEach(() => {
+    window.history.replaceState(null, "", originalHref);
+  });
+
+  it("hides code when the server stripped sources (?include-code=false)", () => {
+    setSearch("?include-code=false");
+    const policy = computeRenderPolicy({
+      mode: "read",
+      showAppCode: true, // config would show code, but sources are stripped
+      hasCells: true,
+      hasCachedOutputs: false,
+      allCellsIdle: false,
+    });
+    expect(policy.showCode).toBe(false);
+    // With no code, no outputs, and still running, there is nothing to paint.
+    expect(policy.canPaint).toBe(false);
+  });
+
+  it("include-code=false still paints when cached outputs exist", () => {
+    setSearch("?include-code=false");
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: true,
+        hasCells: true,
+        hasCachedOutputs: true,
+        allCellsIdle: false,
+      }).canPaint,
+    ).toBe(true);
+  });
+});
+
+describe("computeRenderPolicy.canPaint", () => {
+  it("is false when no cells exist, even if all (zero) cells are vacuously idle", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: true,
+        hasCells: false,
+        hasCachedOutputs: false,
+        allCellsIdle: true,
+      }).canPaint,
+    ).toBe(false);
+  });
+
+  it("is true in edit mode whenever cells exist", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "edit",
+        showAppCode: false,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: false,
+      }).canPaint,
+    ).toBe(true);
+  });
+
+  it("is true in read mode when code is visible", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: true,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: false,
+      }).canPaint,
+    ).toBe(true);
+  });
+
+  it("is false in headless read mode while the notebook is still running with no outputs", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: false,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: false,
+      }).canPaint,
+    ).toBe(false);
+  });
+
+  it("is true in headless read mode with cached outputs", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: false,
+        hasCells: true,
+        hasCachedOutputs: true,
+        allCellsIdle: false,
+      }).canPaint,
+    ).toBe(true);
+  });
+
+  it("is true in headless read mode for a settled notebook with no outputs", () => {
+    // A notebook that ran to completion producing no outputs must still paint
+    // (empty) rather than sit on a spinner — parity with the pre-framework
+    // `hasAnyOutputAtom` idle fallback.
+    expect(
+      computeRenderPolicy({
+        mode: "read",
+        showAppCode: false,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: true,
+      }).canPaint,
+    ).toBe(true);
+  });
+
+  // In present mode `showCode` is always false, so `canPaint` rides entirely
+  // on cached outputs / a settled notebook.
+  it("is true in present mode with cached outputs", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "present",
+        showAppCode: true,
+        hasCells: true,
+        hasCachedOutputs: true,
+        allCellsIdle: false,
+      }).canPaint,
+    ).toBe(true);
+  });
+
+  it("is false in present mode while still running with no outputs", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "present",
+        showAppCode: true,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: false,
+      }).canPaint,
+    ).toBe(false);
+  });
+
+  it("is true in present mode for a settled notebook with no outputs", () => {
+    expect(
+      computeRenderPolicy({
+        mode: "present",
+        showAppCode: true,
+        hasCells: true,
+        hasCachedOutputs: false,
+        allCellsIdle: true,
+      }).canPaint,
+    ).toBe(true);
+  });
+});

package/src/core/lifecycle/render-policy.ts

@@ -0,0 +1,125 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { atom } from "jotai";
+import { hasCellsAtom, notebookAtom } from "../cells/cells";
+import { isOutputEmpty } from "../cells/outputs";
+import { KnownQueryParams } from "../constants";
+import { showCodeInRunModeAtom } from "../meta/state";
+import { type AppMode, initialModeAtom } from "../mode";
+import { hasQueryParam } from "@/utils/urls";
+
+export interface RenderPolicy {
+  /** False in `present` mode, and in `read` mode when the user has opted to hide code. */
+  showCode: boolean;
+  /** True only when there are real, non-empty cached outputs to display. */
+  showCachedOutputs: boolean;
+  /**
+   * Whether the current view has anything to paint without waiting on the
+   * runtime:
+   * - In edit/home/gallery mode, this is `hasCells` — the editor renders the
+   *   cell skeleton even when output is empty.
+   * - In read/present mode with code visible, the cell source is enough.
+   * - In headless read mode (code hidden), we need either cached outputs or a
+   *   settled notebook (all cells idle) — a completed but output-less notebook
+   *   is still "done" and shouldn't strand on an infinite spinner.
+   */
+  canPaint: boolean;
+}
+
+function readCodeVisibility(
+  mode: AppMode | undefined,
+  showAppCode: boolean,
+): boolean {
+  if (mode === "edit" || mode === "home" || mode === "gallery") {
+    return true;
+  }
+  if (mode === "present") {
+    return false;
+  }
+  // read mode (or undefined). If `marimo run` stripped the sources
+  // (`--include-code` off), there is no code to show regardless of any other
+  // signal — mirror `core/meta/code-visibility.ts` so the two don't drift.
+  if (hasQueryParam(KnownQueryParams.includeCode, "false")) {
+    return false;
+  }
+  // Otherwise the URL `show-code` param wins, then the view config.
+  if (hasQueryParam(KnownQueryParams.showCode, "false")) {
+    return false;
+  }
+  if (hasQueryParam(KnownQueryParams.showCode, "true")) {
+    return true;
+  }
+  return showAppCode;
+}
+
+function computeRenderPolicy(input: {
+  mode: AppMode | undefined;
+  showAppCode: boolean;
+  hasCells: boolean;
+  hasCachedOutputs: boolean;
+  /**
+   * True when every cell is idle. A settled notebook is paintable even with no
+   * visible outputs — otherwise a completed but output-less notebook viewed in
+   * headless read mode would strand on an infinite spinner. Mirrors the
+   * pre-framework `hasAnyOutputAtom` idle fallback.
+   */
+  allCellsIdle: boolean;
+}): RenderPolicy {
+  const showCode = readCodeVisibility(input.mode, input.showAppCode);
+  const showCachedOutputs = input.hasCells && input.hasCachedOutputs;
+  const canPaint =
+    input.hasCells && (showCode || showCachedOutputs || input.allCellsIdle);
+
+  return { showCode, showCachedOutputs, canPaint };
+}
+
+/**
+ * Both cell-runtime facts the render policy needs, computed in a single pass
+ * over `cellRuntime`:
+ * - `hasCachedOutputs`: any cell has a non-empty output.
+ * - `allCellsIdle`: every cell's status is idle — nothing queued or running.
+ *   Vacuously true for an empty notebook, so `canPaint` still gates on
+ *   `hasCells`.
+ *
+ * Fan out to two boolean selector atoms below so `renderPolicyAtom` only
+ * recomputes when one of the booleans actually flips, not on every notebook
+ * update.
+ */
+const cellRuntimeSummaryAtom = atom((get) => {
+  let hasCachedOutputs = false;
+  let allCellsIdle = true;
+  for (const runtime of Object.values(get(notebookAtom).cellRuntime)) {
+    if (!isOutputEmpty(runtime.output)) {
+      hasCachedOutputs = true;
+    }
+    if (runtime.status !== "idle") {
+      allCellsIdle = false;
+    }
+  }
+  return { hasCachedOutputs, allCellsIdle };
+});
+
+const hasCachedOutputsAtom = atom(
+  (get) => get(cellRuntimeSummaryAtom).hasCachedOutputs,
+);
+
+const allCellsIdleAtom = atom(
+  (get) => get(cellRuntimeSummaryAtom).allCellsIdle,
+);
+
+export const renderPolicyAtom = atom<RenderPolicy>((get) =>
+  computeRenderPolicy({
+    mode: get(initialModeAtom),
+    showAppCode: get(showCodeInRunModeAtom),
+    hasCells: get(hasCellsAtom),
+    hasCachedOutputs: get(hasCachedOutputsAtom),
+    allCellsIdle: get(allCellsIdleAtom),
+  }),
+);
+
+/** Sugar over `renderPolicyAtom.canPaint`. */
+export const canPaintAtom = atom((get) => get(renderPolicyAtom).canPaint);
+
+export const visibleForTesting = {
+  computeRenderPolicy,
+};