@marimo-team/islands 0.23.14-dev5 → 0.23.14-dev50

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/feature-flag.tsx

@@ -11,6 +11,7 @@ export interface ExperimentalFeatures {
   rtc_v2: boolean;
   cache_panel: boolean;
   external_agents: boolean;
+  debugger: boolean; // Live frame-watching debugger (gutter breakpoints + pdb)
   // Add new feature flags here
 }
 
@@ -20,6 +21,7 @@ const defaultValues: ExperimentalFeatures = {
   rtc_v2: false,
   cache_panel: false,
   external_agents: import.meta.env.DEV,
+  debugger: 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

@@ -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":

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,
+};

package/src/core/mime.ts

@@ -1,9 +1,16 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import type { OutputMessage } from "./kernel/messages";
 
+export function isMarimoErrorsMime(
+  mime: OutputMessage["mimetype"] | undefined,
+) {
+  return mime === "application/vnd.marimo+error";
+}
+
+export function isTracebackMime(mime: OutputMessage["mimetype"] | undefined) {
+  return mime === "application/vnd.marimo+traceback";
+}
+
 export function isErrorMime(mime: OutputMessage["mimetype"] | undefined) {
-  return (
-    mime === "application/vnd.marimo+error" ||
-    mime === "application/vnd.marimo+traceback"
-  );
+  return isMarimoErrorsMime(mime) || isTracebackMime(mime);
 }

package/src/core/network/__tests__/api.test.ts

@@ -1,6 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { HTTPError } from "@/utils/errors";
 import { API } from "../api";
 
 // Mock fetch globally
@@ -77,4 +78,20 @@ describe("API", () => {
       expect.objectContaining({ method: "POST" }),
     );
   });
+
+  it("openapi-client error rejects with HTTPError carrying the status", async () => {
+    const body = { detail: "This connection is read-only for this action." };
+    await expect(
+      API.handleResponseReturnNull({
+        error: body,
+        response: { status: 403, statusText: "Forbidden" } as Response,
+      }),
+    ).rejects.toMatchObject({ status: 403, cause: body });
+    await expect(
+      API.handleResponseReturnNull({
+        error: body,
+        response: { status: 403, statusText: "Forbidden" } as Response,
+      }),
+    ).rejects.toBeInstanceOf(HTTPError);
+  });
 });

package/src/core/network/__tests__/requests-toasting.test.tsx

@@ -0,0 +1,46 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { HTTPError } from "@/utils/errors";
+
+const toastMock = vi.fn();
+vi.mock("@/components/ui/use-toast", () => ({
+  toast: (...args: unknown[]) => toastMock(...args),
+}));
+
+import { createErrorToastingRequests } from "../requests-toasting";
+import type { EditRequests, RunRequests } from "../types";
+
+function requestsThatReject(error: unknown): EditRequests & RunRequests {
+  return createErrorToastingRequests({
+    sendRun: vi.fn().mockRejectedValue(error),
+  } as unknown as EditRequests & RunRequests);
+}
+
+describe("createErrorToastingRequests", () => {
+  beforeEach(() => {
+    toastMock.mockClear();
+  });
+
+  it("suppresses the error toast for a capability 403", async () => {
+    const requests = requestsThatReject(
+      new HTTPError(403, "Forbidden", {
+        detail: "This connection is read-only for this action.",
+      }),
+    );
+    await expect(requests.sendRun({} as never)).rejects.toBeInstanceOf(
+      HTTPError,
+    );
+    expect(toastMock).not.toHaveBeenCalled();
+  });
+
+  it("shows a danger toast for other request errors", async () => {
+    const requests = requestsThatReject(new HTTPError(500, "Server Error"));
+    await expect(requests.sendRun({} as never)).rejects.toBeInstanceOf(
+      HTTPError,
+    );
+    expect(toastMock).toHaveBeenCalledWith(
+      expect.objectContaining({ variant: "danger" }),
+    );
+  });
+});