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

package/src/core/cells/utils.ts

@@ -2,6 +2,8 @@
 
 import type { EditorView } from "@codemirror/view";
 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";
@@ -196,3 +198,52 @@ export function cellStatusClasses({
     stale: status === "disabled-transitively",
   };
 }
+
+/**
+ * Status classes for a published cell (read or present mode, output only).
+ */
+export function publishedCellClasses({
+  errored,
+  stopped,
+}: {
+  errored: boolean;
+  stopped: boolean;
+}) {
+  return {
+    published: true,
+    "has-error": errored,
+    stopped: stopped,
+  };
+}
+
+/**
+ * Whether a published cell (read or present mode) should be hidden.
+ *
+ * Errored, interrupted, and stopped cells (and error outputs) are hidden in
+ * published views, unless `show_tracebacks` is enabled and the output carries
+ * an exception traceback to display inline.
+ */
+export function shouldHidePublishedCell({
+  errored,
+  interrupted,
+  stopped,
+  output,
+  showErrorTracebacks,
+}: {
+  errored: boolean;
+  interrupted: boolean;
+  stopped: boolean;
+  output: OutputMessage | null;
+  showErrorTracebacks: boolean;
+}): boolean {
+  const outputIsError = isErrorMime(output?.mimetype);
+  const hasTraceback =
+    showErrorTracebacks &&
+    outputIsError &&
+    Array.isArray(output?.data) &&
+    output.data.some(
+      (e: MarimoError) =>
+        e.type === "exception" && "traceback" in e && e.traceback,
+    );
+  return (errored || interrupted || stopped || outputIsError) && !hasTraceback;
+}

package/src/core/codemirror/completion/__tests__/signature-hint.test.ts

@@ -5,6 +5,7 @@ import { EditorView, type Tooltip } from "@codemirror/view";
 import { describe, expect, it } from "vitest";
 import {
   asSignatureHint,
+  closeSignatureHint,
   setSignatureHintEffect,
   signatureHintField,
 } from "../signature-hint";
@@ -51,12 +52,79 @@ describe("signatureHintField", () => {
     expect(state.field(signatureHintField)).toBeNull();
   });
 
-  it("keeps and re-anchors the tooltip across edits", () => {
+  it("keeps and re-anchors the tooltip across edits inside the call", () => {
     let state = stateWithHint("plt.plot(", 9);
-    // Insert before the tooltip position; it should shift to stay anchored.
-    state = state.update({ changes: { from: 0, insert: "xy" } }).state;
+    // Insert before the tooltip position while the cursor stays inside the
+    // call; the anchor should shift but the hint should remain.
+    state = state.update({
+      changes: { from: 0, insert: "xy" },
+      selection: { anchor: 11 },
+    }).state;
     expect(state.field(signatureHintField)?.pos).toBe(11);
   });
+
+  it("dismisses the tooltip when the closing paren is typed", () => {
+    let state = stateWithHint("plt.plot(", 9);
+    // Type the closing paren; the cursor is now outside the call.
+    state = state.update({
+      changes: { from: 9, insert: ")" },
+      selection: { anchor: 10 },
+    }).state;
+    expect(state.field(signatureHintField)).toBeNull();
+  });
+
+  it("dismisses the tooltip when the anchored call closes inside grouping parens", () => {
+    // Regression for the `(plt.plot())` case: the outer grouping paren must not
+    // keep the (now-closed) plt.plot hint alive.
+    let state = stateWithHint("(plt.plot(", 10);
+    // Close plt.plot's call; the outer `(` is still open but we've left the
+    // anchored call.
+    state = state.update({
+      changes: { from: 10, insert: ")" },
+      selection: { anchor: 11 },
+    }).state;
+    expect(state.field(signatureHintField)).toBeNull();
+  });
+
+  it("keeps the tooltip while typing a nested call inside the anchored call", () => {
+    // Cursor inside the anchored call of `f(g(<cursor>`; opening/typing a nested
+    // call stays inside the anchored call, so the hint should remain.
+    let state = stateWithHint("f(g(", 4);
+    state = state.update({
+      changes: { from: 4, insert: "x(" },
+      selection: { anchor: 6 },
+    }).state;
+    expect(state.field(signatureHintField)?.pos).toBe(4);
+  });
+
+  it("keeps the tooltip when a nested call closes inside the anchored call", () => {
+    const anchor = "f(".length;
+    let state = stateWithHint("f(g(x", anchor);
+    state = state.update({
+      changes: { from: 5, insert: ")" },
+      selection: { anchor: 6 },
+    }).state;
+    expect(state.field(signatureHintField)?.pos).toBe(anchor);
+  });
+
+  it("dismisses the tooltip when the closing paren is typed in a large multi-line call", () => {
+    const anchor = "f(".length;
+    const prefix = `f(\n${"  x,\n".repeat(25)}`;
+    let state = EditorState.create({
+      doc: prefix,
+      selection: { anchor: prefix.length },
+      extensions: [signatureHintField],
+    });
+    state = state.update({
+      effects: setSignatureHintEffect.of(fakeTooltip(anchor)),
+    }).state;
+    const head = prefix.length;
+    state = state.update({
+      changes: { from: head, insert: ")" },
+      selection: { anchor: head + 1 },
+    }).state;
+    expect(state.field(signatureHintField)).toBeNull();
+  });
 });
 
 describe("asSignatureHint", () => {
@@ -92,3 +160,29 @@ describe("asSignatureHint", () => {
     expect(wrapped.above).toBe(true);
   });
 });
+
+describe("closeSignatureHint", () => {
+  it("returns false when no hint is showing", () => {
+    const view = new EditorView({
+      state: EditorState.create({ extensions: [signatureHintField] }),
+    });
+    expect(closeSignatureHint(view)).toBe(false);
+    expect(view.state.field(signatureHintField)).toBeNull();
+    view.destroy();
+  });
+
+  it("dismisses the hint and returns true when one is showing", () => {
+    const view = new EditorView({
+      state: EditorState.create({
+        doc: "plt.plot(",
+        extensions: [signatureHintField],
+      }),
+    });
+    view.dispatch({ effects: setSignatureHintEffect.of(fakeTooltip(9)) });
+    expect(view.state.field(signatureHintField)?.pos).toBe(9);
+
+    expect(closeSignatureHint(view)).toBe(true);
+    expect(view.state.field(signatureHintField)).toBeNull();
+    view.destroy();
+  });
+});

package/src/core/codemirror/completion/signature-hint.ts

@@ -1,12 +1,61 @@
 /* Copyright 2026 Marimo. All rights reserved. */
+import type { EditorState } from "@codemirror/state";
 import { StateEffect, StateField } from "@codemirror/state";
-import { showTooltip, type Tooltip } from "@codemirror/view";
+import { type EditorView, showTooltip, type Tooltip } from "@codemirror/view";
 
 /**
  * Effect to set (or clear, with `null`) the floating signature hint.
  */
 export const setSignatureHintEffect = StateEffect.define<Tooltip | null>();
 
+// Bound the scan so large cells stay cheap on every keystroke.
+const MAX_LINES_BACK = 20;
+
+/**
+ * Whether the cursor is still inside the anchored call (just inside its `(`).
+ *
+ * Anchor-relative paren scan, bounded to {@link MAX_LINES_BACK} lines.
+ * Good enough for hint dismissal — not a full parse (ignores strings/comments).
+ */
+function isCursorInsideAnchoredCall(options: {
+  state: EditorState;
+  anchor: number;
+  head: number;
+}): boolean {
+  const { state, anchor, head } = options;
+  if (head < anchor) {
+    return false;
+  }
+
+  const headLine = state.doc.lineAt(head).number;
+  const anchorLine = state.doc.lineAt(anchor).number;
+  const startLine = Math.max(anchorLine, headLine - MAX_LINES_BACK + 1);
+  const from = Math.max(anchor, state.doc.line(startLine).from);
+
+  // If the anchor is outside the bounded window, assume its `(` is still open.
+  const assumedOpen = from > anchor;
+  let balance = assumedOpen ? 1 : 0;
+  const iter = state.doc.iterRange(from, head);
+  for (;;) {
+    const { value, done } = iter.next();
+    if (done) {
+      break;
+    }
+    for (const char of value) {
+      if (char === "(") {
+        balance++;
+      } else if (char === ")") {
+        balance--;
+        const closed = assumedOpen ? balance <= 0 : balance < 0;
+        if (closed) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
 /**
  * Wrap a tooltip so it renders like the completion popup's info box.
  *
@@ -34,13 +83,7 @@ export function asSignatureHint(tooltip: Tooltip): Tooltip {
  * Holds the floating "signature hint" shown after typing `(` or `,` inside a
  * call on the non-LSP (Jedi) completion path.
  *
- * The LSP path has its own signature help; this fills the gap for users
- * without a language server. The completion source (`pythonCompletionSource`)
- * drives it: it dispatches `setSignatureHintEffect` with the tooltip when the
- * backend returns a signature and with `null` otherwise. The hint is also
- * cleared when the cursor moves via a selection-only change (e.g. clicking
- * away or arrowing out of the call), and kept anchored across edits so it
- * doesn't flicker while a fresh result is in flight.
+ * The LSP path has its own signature help; this fills the gap for users without a language server.
  */
 export const signatureHintField = StateField.define<Tooltip | null>({
   create: () => null,
@@ -57,12 +100,36 @@ export const signatureHintField = StateField.define<Tooltip | null>({
     if (tr.selection && !tr.docChanged) {
       return null;
     }
-    // Keep the hint anchored across edits; the completion source refreshes or
-    // clears it as new results arrive.
+    // Dismiss once the cursor leaves the anchored call (e.g. the closing paren
+    // is typed). Otherwise keep the hint anchored across edits so it doesn't
+    // flicker while a fresh result is in flight; the completion source refreshes
+    // or clears it as results arrive.
     if (tr.docChanged) {
-      return { ...tooltip, pos: tr.changes.mapPos(tooltip.pos) };
+      const anchor = tr.changes.mapPos(tooltip.pos);
+      if (
+        !isCursorInsideAnchoredCall({
+          state: tr.state,
+          anchor,
+          head: tr.state.selection.main.head,
+        })
+      ) {
+        return null;
+      }
+      return { ...tooltip, pos: anchor };
     }
     return tooltip;
   },
   provide: (field) => showTooltip.from(field),
 });
+
+/**
+ * Dismiss the floating signature hint if one is showing.
+ * Returns `true` if a hint was dismissed.
+ */
+export function closeSignatureHint(view: EditorView): boolean {
+  if (view.state.field(signatureHintField, false)) {
+    view.dispatch({ effects: setSignatureHintEffect.of(null) });
+    return true;
+  }
+  return false;
+}

package/src/core/constants.ts

@@ -3,6 +3,8 @@ export const Constants = {
   githubPage: "https://github.com/marimo-team/marimo",
   releasesPage: "https://github.com/marimo-team/marimo/releases",
   issuesPage: "https://github.com/marimo-team/marimo/issues",
+  bugReportUrl:
+    "https://github.com/marimo-team/marimo/issues/new?template=bug_report.yaml",
   feedbackForm: "https://marimo.io/feedback",
   discordLink: "https://marimo.io/discord?ref=notebook",
   docsPage: "https://docs.marimo.io",
@@ -50,6 +52,12 @@ export const KnownQueryParams = {
    * If false, the chrome will be hidden.
    */
   showChrome: "show-chrome",
+  /**
+   * Override the display theme: `light`, `dark`, or `system`.
+   * Takes precedence over the notebook's saved `display.theme`.
+   * Ignored for embedded islands, which infer the theme from their host page.
+   */
+  theme: "theme",
 };
 
 /**

package/src/core/diagnostics/__tests__/issue-details.test.ts

@@ -0,0 +1,173 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, it } from "vitest";
+import { cellId } from "@/__tests__/branded";
+import type { CellErrorEntry } from "@/core/errors/error-entries";
+import type { EnvironmentInfo } from "@/core/network/types";
+import {
+  buildBugReportUrl,
+  buildIssueDetails,
+  createPartialEnvironment,
+  enrichEnvironment,
+  markdownCodeFence,
+  MAX_PREFILL_URL_LENGTH,
+} from "../issue-details";
+
+const environment: EnvironmentInfo = {
+  marimo: "1.2.3",
+  editable: false,
+  location: "~/.venv/site-packages/marimo",
+  OS: "Darwin",
+  "OS Version": "25.0",
+  Processor: "arm",
+  "Python Version": "3.12.9",
+  Locale: "en_US",
+  Binaries: { Browser: "chrome 140", Node: "v22", uv: "0.11" },
+  Dependencies: { click: "8.4.2" },
+  "Optional Dependencies": { pandas: "3.0.0" },
+  "Experimental Flags": {},
+};
+
+describe("enrichEnvironment", () => {
+  it("replaces server Chrome detection with the active browser", () => {
+    const result = enrichEnvironment(environment, "Firefox/140");
+    expect(result.Binaries.Browser).toBe("Firefox/140");
+    expect(result.Binaries.Node).toBe("v22");
+  });
+
+  it("does not mutate the input", () => {
+    enrichEnvironment(environment, "Firefox/140");
+    expect(environment.Binaries.Browser).toBe("chrome 140");
+  });
+});
+
+describe("createPartialEnvironment", () => {
+  it("records the collection error and keeps the active browser", () => {
+    const partial = createPartialEnvironment(
+      "1.2.3",
+      "Firefox/140",
+      "en_US",
+      "Server environment information unavailable",
+    );
+    expect(partial.marimo).toBe("1.2.3");
+    expect(partial.Binaries?.Browser).toBe("Firefox/140");
+    expect(partial.Locale).toBe("en_US");
+    expect(partial["Environment Collection Error"]).toBe(
+      "Server environment information unavailable",
+    );
+  });
+
+  it("omits empty fields rather than filling placeholders", () => {
+    const partial = createPartialEnvironment(
+      "1.2.3",
+      "Firefox/140",
+      "",
+      "boom",
+    );
+    expect(partial.Locale).toBeUndefined();
+    expect(partial.location).toBeUndefined();
+    expect(partial.OS).toBeUndefined();
+    expect(partial.Dependencies).toBeUndefined();
+  });
+});
+
+describe("markdownCodeFence", () => {
+  it("uses a fence longer than any backtick run in the content", () => {
+    const block = markdownCodeFence("python", 'text = "```"');
+    expect(block.startsWith("````python\n")).toBe(true);
+    expect(block.endsWith("\n````")).toBe(true);
+    expect(block).toContain('text = "```"');
+  });
+
+  it("uses a minimum fence of three backticks", () => {
+    const block = markdownCodeFence("json", "{}");
+    expect(block.startsWith("```json\n")).toBe(true);
+    expect(block.endsWith("\n```")).toBe(true);
+  });
+});
+
+describe("buildIssueDetails", () => {
+  it("includes the environment and omits notebook source unless provided", () => {
+    const markdown = buildIssueDetails({
+      environment,
+      errors: [],
+      notebook: undefined,
+    });
+    expect(markdown).toContain("<summary>Environment</summary>");
+    expect(markdown).toContain('"marimo": "1.2.3"');
+    expect(markdown).not.toContain("Notebook source");
+    expect(markdown).not.toContain("Current errors");
+  });
+
+  it("includes current errors as plain text without notebook source", () => {
+    const errors: CellErrorEntry[] = [
+      {
+        cellId: cellId("cell-1"),
+        cellName: "Cell 1",
+        cellCode: "password = 'private'",
+        errorData: [],
+        tracebackHtml:
+          '<span class="gr">ValueError</span>: <span class="n">bad value</span>',
+      },
+    ];
+    const markdown = buildIssueDetails({ environment, errors });
+    expect(markdown).toContain("<summary>Current errors</summary>");
+    expect(markdown).toContain("ValueError: bad value");
+    expect(markdown).not.toContain("password");
+  });
+
+  it("includes notebook source under its basename when provided", () => {
+    const markdown = buildIssueDetails({
+      environment,
+      errors: [],
+      notebook: {
+        filename: "/project/example.py",
+        contents: "x = 1",
+      },
+    });
+    expect(markdown).toContain(
+      "<summary>Notebook source: example.py</summary>",
+    );
+    expect(markdown).toContain("x = 1");
+  });
+
+  it("escapes the summary label as text", () => {
+    const markdown = buildIssueDetails({
+      environment,
+      errors: [],
+      notebook: {
+        filename: "/project/<script>.py",
+        contents: "x = 1",
+      },
+    });
+    expect(markdown).toContain("&lt;script&gt;.py");
+    expect(markdown).not.toContain("<script>.py");
+  });
+});
+
+describe("buildBugReportUrl", () => {
+  const baseUrl =
+    "https://github.com/marimo-team/marimo/issues/new?template=bug_report.yaml";
+
+  it("prefills the env field with the encoded issue details", () => {
+    const url = buildBugReportUrl(baseUrl, "hello world");
+    expect(url).toBe(`${baseUrl}&env=hello%20world`);
+  });
+
+  it("appends env with a query separator when the base URL has none", () => {
+    const url = buildBugReportUrl("https://example.com/new", "x");
+    expect(url).toBe("https://example.com/new?env=x");
+  });
+
+  it("encodes markdown so it survives as a single query param", () => {
+    const details = buildIssueDetails({ environment, errors: [] });
+    const url = buildBugReportUrl(baseUrl, details);
+    expect(url).toContain("&env=");
+    expect(new URL(url).searchParams.get("env")).toBe(details);
+  });
+
+  it("falls back to the plain base URL when the prefill exceeds the cap", () => {
+    const huge = "x".repeat(MAX_PREFILL_URL_LENGTH);
+    expect(buildBugReportUrl(baseUrl, huge)).toBe(baseUrl);
+  });
+});

package/src/core/diagnostics/issue-details.ts

@@ -0,0 +1,139 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import {
+  type CellErrorEntry,
+  formatCellError,
+} from "@/core/errors/error-entries";
+import type { EnvironmentInfo } from "@/core/network/types";
+import { Paths } from "@/utils/paths";
+import { Strings } from "@/utils/strings";
+
+/**
+ * Environment information augmented with a client-side collection error, used
+ * when the server environment request fails and only partial data is available.
+ * Fields are optional because a partial environment only carries what the
+ * client could determine without the server.
+ */
+export type EnvironmentDiagnostics = Partial<EnvironmentInfo> & {
+  "Environment Collection Error"?: string;
+};
+
+export interface NotebookSource {
+  filename: string;
+  contents: string;
+}
+
+export interface IssueDetailsInput {
+  environment: EnvironmentDiagnostics;
+  errors: CellErrorEntry[];
+  notebook?: NotebookSource;
+}
+
+/**
+ * Replace the server-detected browser with the active browser's user agent.
+ *
+ * The server cannot know which browser is driving the UI, so diagnostics
+ * generated from the modal reflect the live `navigator.userAgent` instead.
+ */
+export function enrichEnvironment(
+  environment: EnvironmentInfo,
+  userAgent: string,
+): EnvironmentInfo {
+  return {
+    ...environment,
+    Binaries: {
+      ...environment.Binaries,
+      Browser: userAgent,
+    },
+  };
+}
+
+export function createPartialEnvironment(
+  marimoVersion: string,
+  userAgent: string,
+  locale: string,
+  message: string,
+): EnvironmentDiagnostics {
+  return {
+    marimo: marimoVersion,
+    Locale: locale || undefined,
+    Binaries: { Browser: userAgent },
+    "Environment Collection Error": message,
+  };
+}
+
+/**
+ * Wrap `contents` in a Markdown code fence long enough to survive backtick runs
+ * inside it, so pasted diagnostics render as a single block on GitHub.
+ */
+export function markdownCodeFence(language: string, contents: string): string {
+  const longest = Math.max(
+    2,
+    ...Array.from(contents.matchAll(/`+/g), (match) => match[0].length),
+  );
+  const fence = "`".repeat(longest + 1);
+  return `${fence}${language}\n${contents}\n${fence}`;
+}
+
+/**
+ * GitHub returns HTTP 414 for issue-form URLs beyond roughly 8 KB, so prefill is
+ * skipped once the encoded body would push the URL past this conservative cap.
+ */
+export const MAX_PREFILL_URL_LENGTH = 6000;
+
+/**
+ * Build a bug-report URL with `issueDetails` prefilled into the form's `env`
+ * field. Falls back to `baseUrl` unchanged when the prefilled URL would exceed
+ * `MAX_PREFILL_URL_LENGTH`.
+ */
+export function buildBugReportUrl(
+  baseUrl: string,
+  issueDetails: string,
+): string {
+  const separator = baseUrl.includes("?") ? "&" : "?";
+  const prefilled = `${baseUrl}${separator}env=${encodeURIComponent(issueDetails)}`;
+  return prefilled.length > MAX_PREFILL_URL_LENGTH ? baseUrl : prefilled;
+}
+
+function detailsSection(summary: string, body: string): string {
+  return [
+    "<details>",
+    `<summary>${Strings.htmlEscape(summary) ?? ""}</summary>`,
+    "",
+    body,
+    "",
+    "</details>",
+  ].join("\n");
+}
+
+export function buildIssueDetails(input: IssueDetailsInput): string {
+  const sections = [
+    detailsSection(
+      "Environment",
+      markdownCodeFence("json", JSON.stringify(input.environment, null, 2)),
+    ),
+  ];
+
+  if (input.errors.length > 0) {
+    sections.push(
+      detailsSection(
+        "Current errors",
+        markdownCodeFence(
+          "text",
+          input.errors.map(formatCellError).join("\n\n---\n\n"),
+        ),
+      ),
+    );
+  }
+
+  if (input.notebook) {
+    sections.push(
+      detailsSection(
+        `Notebook source: ${Paths.basename(input.notebook.filename)}`,
+        markdownCodeFence("python", input.notebook.contents),
+      ),
+    );
+  }
+
+  return sections.join("\n\n");
+}

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

@@ -0,0 +1,25 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, it } from "vitest";
+import { cellId } from "@/__tests__/branded";
+import { type CellErrorEntry, formatCellError } from "../error-entries";
+
+describe("formatCellError", () => {
+  it("formats current tracebacks without notebook source", () => {
+    const entry: CellErrorEntry = {
+      cellId: cellId("cell-1"),
+      cellName: "Cell 1",
+      cellCode: "password = 'private'",
+      errorData: [],
+      tracebackHtml:
+        '<span class="gr">ValueError</span>: <span class="n">bad value</span>',
+    };
+
+    const text = formatCellError(entry);
+
+    expect(text).toContain("Cell 1");
+    expect(text).toContain("ValueError: bad value");
+    expect(text).not.toContain("password");
+    expect(text).not.toContain("<span");
+  });
+});