@marimo-team/islands 0.24.3-dev5 → 0.24.3-dev52

package/src/components/editor/alerts/connection-notice.tsx

@@ -0,0 +1,140 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { useAtomValue } from "jotai";
+import { AlertCircleIcon, ArrowRightIcon } from "lucide-react";
+import { useState } from "react";
+import { Spinner } from "@/components/icons/spinner";
+import { Button } from "@/components/ui/button";
+import { hasCellsAtom } from "@/core/cells/cells";
+import type { AppConfig } from "@/core/config/config-schema";
+import { connectionAtom } from "@/core/network/connection";
+import { connectionNoticeAtom } from "@/core/network/connection-notice";
+import { WebSocketState } from "@/core/websocket/types";
+import { useDelayElapsed } from "@/hooks/useDelayElapsed";
+import { useInterval } from "@/hooks/useInterval";
+import { cn } from "@/utils/cn";
+import { SandboxErrorOutput } from "../chrome/panels/sandbox-panel";
+import { chromeAtom, useChromeActions } from "../chrome/state";
+import { VerticalLayoutWrapper } from "../renderers/vertical-layout/vertical-layout-wrapper";
+
+export const ConnectionNotice = ({
+  appConfig,
+  onRetry,
+}: {
+  appConfig: AppConfig;
+  onRetry: () => void;
+}) => {
+  const notice = useAtomValue(connectionNoticeAtom);
+  const connection = useAtomValue(connectionAtom);
+  const hasCells = useAtomValue(hasCellsAtom);
+  const chrome = useAtomValue(chromeAtom);
+  const packagesOpen =
+    (chrome.isSidebarOpen && chrome.selectedPanel === "packages") ||
+    (chrome.isDeveloperPanelOpen &&
+      chrome.selectedDeveloperPanelTab === "packages");
+  const elapsed = useDelayElapsed(notice?.pending ? 500 : 0);
+  const { openApplication } = useChromeActions();
+
+  // Reconnection uses the footer indicator while existing cells stay visible.
+  if (
+    !notice ||
+    !elapsed ||
+    (hasCells &&
+      connection.state === WebSocketState.CONNECTING &&
+      connection.phase === "reconnecting")
+  ) {
+    return null;
+  }
+
+  return (
+    <VerticalLayoutWrapper
+      appConfig={appConfig}
+      className="shrink-0 pb-0 sm:pb-0 print:hidden"
+      innerClassName="pb-0 sm:pb-0 pr-4"
+    >
+      <section
+        aria-label="Notebook startup"
+        className={cn(
+          "text-muted-foreground",
+          hasCells
+            ? "mt-4 mb-8 border rounded-lg px-5 py-5"
+            : "max-w-sm mx-auto mt-16 sm:mt-24 px-4",
+          hasCells && !notice.pending && "border-(--red-7)",
+        )}
+      >
+        <div role="status" className="flex items-center gap-2.5">
+          {notice.pending ? (
+            <Spinner className="size-4 shrink-0" aria-hidden={true} />
+          ) : (
+            <AlertCircleIcon
+              className="size-4 shrink-0 text-(--red-11)"
+              aria-hidden={true}
+            />
+          )}
+          <h2
+            className={cn(
+              "text-base",
+              notice.pending
+                ? "font-normal text-foreground"
+                : "font-medium text-(--red-11)",
+            )}
+          >
+            {notice.title}
+          </h2>
+        </div>
+        <div className="ml-6.5">
+          <p
+            className={cn(
+              "mt-3 text-sm leading-7",
+              !notice.pending && "text-foreground",
+            )}
+          >
+            {notice.description}
+          </p>
+          {!notice.sandbox && notice.error && (
+            <SandboxErrorOutput error={notice.error} />
+          )}
+          <div className="mt-5 flex flex-wrap items-center gap-x-6 gap-y-3">
+            {!packagesOpen && (notice.sandbox || notice.pending) && (
+              <Button
+                variant="text"
+                size="xs"
+                className="h-auto p-0 text-xs gap-1.5"
+                onClick={() => openApplication("packages")}
+              >
+                {notice.pending ? "View setup details" : "Open Packages"}
+                <ArrowRightIcon className="size-3" aria-hidden={true} />
+              </Button>
+            )}
+            {!notice.pending && !notice.sandbox && (
+              <Button variant="outline" size="xs" onClick={onRetry}>
+                Try again
+              </Button>
+            )}
+            {notice.pending && <StartupElapsedTime />}
+          </div>
+        </div>
+      </section>
+    </VerticalLayoutWrapper>
+  );
+};
+
+function StartupElapsedTime() {
+  const [startedAt] = useState(Date.now);
+  const [seconds, setSeconds] = useState(0);
+  useInterval(() => setSeconds(Math.floor((Date.now() - startedAt) / 1000)), {
+    delayMs: 1000,
+    whenVisible: true,
+  });
+  const duration =
+    seconds < 60
+      ? `${seconds}s`
+      : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  return (
+    <span
+      className="text-xs text-muted-foreground/70 tabular-nums"
+      aria-live="off"
+    >
+      Elapsed {duration}
+    </span>
+  );
+}

package/src/components/editor/app-container.tsx

@@ -4,8 +4,11 @@ import type React from "react";
 import type { PropsWithChildren } from "react";
 import type { AppConfig } from "@/core/config/config-schema";
 import { PyodideLoader } from "@/core/wasm/PyodideLoader";
-import { isAppClosed } from "@/core/websocket/connection-utils";
-import type { ConnectionStatus } from "@/core/websocket/types";
+import {
+  type ConnectionStatus,
+  WebSocketClosedReason,
+  WebSocketState,
+} from "@/core/websocket/types";
 import { cn } from "@/utils/cn";
 import { DynamicFavicon } from "./dynamic-favicon";
 import { StatusOverlay } from "./header/status";
@@ -44,7 +47,10 @@ export const AppContainer: React.FC<PropsWithChildren<Props>> = ({
             data-connection-state={connectionState}
             className={cn(
               "mathjax_ignore",
-              isAppClosed(connectionState) && "disconnected",
+              connection.state === WebSocketState.CLOSED &&
+                connection.code !==
+                  WebSocketClosedReason.KERNEL_STARTUP_ERROR &&
+                "disconnected",
               "bg-background w-full h-full text-textColor",
               "flex flex-col overflow-y-auto",
               width === "full" && "config-width-full",

package/src/components/editor/boundary/ErrorBoundary.tsx

@@ -1,11 +1,21 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-import type { PropsWithChildren } from "react";
+import { Provider } from "jotai";
+import { type PropsWithChildren, lazy, Suspense, useState } from "react";
 import {
   type FallbackProps,
   ErrorBoundary as ReactErrorBoundary,
 } from "react-error-boundary";
-import { Constants } from "@/core/constants";
+import { store } from "@/core/state/jotai";
 import { Button } from "../../ui/button";
+import { Dialog, DialogTrigger } from "../../ui/dialog";
+import { Toaster } from "../../ui/toaster";
+import { TooltipProvider } from "../../ui/tooltip";
+
+const FeedbackModal = lazy(() =>
+  import("../chrome/components/feedback-button").then((mod) => ({
+    default: mod.FeedbackModal,
+  })),
+);
 
 export const ErrorBoundary: React.FC<PropsWithChildren> = (props) => {
   return (
@@ -16,26 +26,38 @@ export const ErrorBoundary: React.FC<PropsWithChildren> = (props) => {
 };
 
 const FallbackComponent: React.FC<FallbackProps> = (props) => {
+  const [open, setOpen] = useState(false);
+
   return (
-    <div className="flex-1 flex items-center justify-center flex-col space-y-4 max-w-2xl mx-auto px-6">
+    <div className="flex-1 flex items-center justify-center flex-col space-y-4 max-w-2xl mx-auto px-6 pb-6">
       <h1 className="text-2xl font-bold">Something went wrong</h1>
       <pre className="text-xs bg-muted/40 border rounded-md p-4 max-w-[80%] whitespace-normal">
         {props.error?.message}
       </pre>
-      <div>
-        If this is an issue with marimo, please report it on{" "}
-        <a href={Constants.issuesPage} target="_blank" className="underline">
-          GitHub
-        </a>
-        .
+      <div className="flex flex-wrap items-center justify-center gap-2">
+        <Dialog open={open} onOpenChange={setOpen}>
+          <DialogTrigger asChild={true}>
+            <Button variant="outline">Report an issue</Button>
+          </DialogTrigger>
+          {open && (
+            <Provider store={store}>
+              <TooltipProvider>
+                <Suspense fallback={null}>
+                  <FeedbackModal />
+                </Suspense>
+                <Toaster />
+              </TooltipProvider>
+            </Provider>
+          )}
+        </Dialog>
+        <Button
+          data-testid="reset-error-boundary-button"
+          onClick={props.resetErrorBoundary}
+          variant="outline"
+        >
+          Try again
+        </Button>
       </div>
-      <Button
-        data-testid="reset-error-boundary-button"
-        onClick={props.resetErrorBoundary}
-        variant="outline"
-      >
-        Try again
-      </Button>
     </div>
   );
 };

package/src/components/editor/boundary/__tests__/ErrorBoundary.test.tsx

@@ -0,0 +1,311 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import type { PropsWithChildren, ReactNode } from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { MockRequestClient } from "@/__mocks__/requests";
+import { ModalProvider } from "@/components/modal/ImperativeModal";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { clearToasts } from "@/components/ui/use-toast";
+import { initialNotebookState, notebookAtom } from "@/core/cells/cells";
+import { viewStateAtom } from "@/core/mode";
+import { connectionAtom } from "@/core/network/connection";
+import { requestClientAtom } from "@/core/network/requests";
+import type { EnvironmentInfo } from "@/core/network/types";
+import { filenameAtom } from "@/core/saving/file-state";
+import { store } from "@/core/state/jotai";
+import { WebSocketState } from "@/core/websocket/types";
+import { ErrorBoundary } from "../ErrorBoundary";
+
+vi.mock("@/utils/copy", () => ({
+  copyToClipboard: vi.fn().mockResolvedValue(undefined),
+}));
+
+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": {},
+};
+
+const CRASH_MESSAGE = "cell output crashed";
+
+function CrashingChild(): never {
+  throw new Error(CRASH_MESSAGE);
+}
+
+function RecoverableChild({ crash }: { crash: boolean }) {
+  if (crash) {
+    throw new Error(CRASH_MESSAGE);
+  }
+  return <p>recovered child</p>;
+}
+
+function DescendantProviders({ children }: PropsWithChildren) {
+  return (
+    <TooltipProvider>
+      <ModalProvider>{children}</ModalProvider>
+    </TooltipProvider>
+  );
+}
+
+function isExpectedReactExceptionOutput(args: unknown[]): boolean {
+  return args.some((arg) => {
+    if (arg instanceof Error) {
+      return arg.message.includes(CRASH_MESSAGE);
+    }
+    return (
+      typeof arg === "string" &&
+      (arg.includes(CRASH_MESSAGE) ||
+        arg.includes("The above error occurred") ||
+        arg.includes("React will try to recreate this component tree"))
+    );
+  });
+}
+
+function suppressExpectedReactException() {
+  return vi.spyOn(console, "error").mockImplementation((...args) => {
+    if (isExpectedReactExceptionOutput(args)) {
+      return;
+    }
+    throw new Error(`Unexpected console.error: ${args.map(String).join(" ")}`);
+  });
+}
+
+let consoleError: ReturnType<typeof vi.spyOn> | undefined;
+
+function renderCrashedBoundary(child: ReactNode = <CrashingChild />) {
+  consoleError?.mockRestore();
+  consoleError = suppressExpectedReactException();
+  return render(<ErrorBoundary>{child}</ErrorBoundary>);
+}
+
+function setRequestClient(
+  overrides?: Parameters<typeof MockRequestClient.create>[0],
+) {
+  const client = MockRequestClient.create(overrides);
+  store.set(requestClientAtom, client);
+  return client;
+}
+
+async function openReportDialog() {
+  const trigger = screen.getByRole("button", { name: "Report an issue" });
+  trigger.focus();
+  fireEvent.click(trigger);
+  return screen.findByRole("dialog");
+}
+
+async function expectReportButtonFocused() {
+  await waitFor(() => {
+    expect(
+      screen.getByRole("button", { name: "Report an issue" }),
+    ).toHaveFocus();
+  });
+}
+
+async function closeReportDialog(method: "escape" | "close") {
+  const dialog = await screen.findByRole("dialog");
+  if (method === "escape") {
+    fireEvent.keyDown(dialog, { key: "Escape" });
+  } else {
+    fireEvent.click(screen.getByRole("button", { name: "Close" }));
+  }
+  await waitFor(() => {
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+  });
+  await expectReportButtonFocused();
+}
+
+async function expectRealReportModal() {
+  const dialog = await openReportDialog();
+  expect(dialog).toHaveTextContent("Report an issue");
+  expect(screen.getByRole("link", { name: "Open GitHub issue" })).toBeVisible();
+  expect(
+    screen.getByRole("checkbox", { name: "Include errors" }),
+  ).toBeVisible();
+  expect(
+    screen.getByRole("checkbox", { name: "Include notebook code" }),
+  ).toBeVisible();
+  await screen.findByText("Environment details");
+  return dialog;
+}
+
+function resetSharedState() {
+  localStorage.clear();
+  clearToasts();
+  store.set(requestClientAtom, null);
+  store.set(notebookAtom, initialNotebookState());
+  store.set(viewStateAtom, { mode: "edit", cellAnchor: null });
+  store.set(connectionAtom, { state: WebSocketState.OPEN });
+  store.set(filenameAtom, "/project/example.py");
+}
+
+describe("ErrorBoundary report dialog", () => {
+  beforeEach(() => {
+    resetSharedState();
+  });
+
+  afterEach(() => {
+    consoleError?.mockRestore();
+    consoleError = undefined;
+    resetSharedState();
+  });
+
+  it("opens the report modal after a child render exception", async () => {
+    const { getEnvironmentInfo } = setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+    });
+
+    renderCrashedBoundary();
+
+    expect(screen.getByText("Something went wrong")).toBeVisible();
+    expect(screen.getByText("cell output crashed")).toBeVisible();
+    expect(screen.getByTestId("reset-error-boundary-button")).toBeVisible();
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(getEnvironmentInfo).not.toHaveBeenCalled();
+
+    await expectRealReportModal();
+    await waitFor(() => expect(getEnvironmentInfo).toHaveBeenCalledOnce());
+  });
+
+  it("still opens one report dialog after descendant providers disappear", async () => {
+    const { getEnvironmentInfo } = setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+    });
+
+    renderCrashedBoundary(
+      <DescendantProviders>
+        <CrashingChild />
+      </DescendantProviders>,
+    );
+
+    await expectRealReportModal();
+    expect(screen.getAllByRole("dialog")).toHaveLength(1);
+    await waitFor(() => expect(getEnvironmentInfo).toHaveBeenCalledOnce());
+  });
+
+  it("shows partial diagnostics when the request client is missing", async () => {
+    renderCrashedBoundary();
+
+    await openReportDialog();
+    await screen.findByText("Environment details");
+
+    expect(
+      screen.getByText("Server environment information unavailable"),
+    ).toBeVisible();
+    expect(
+      screen.queryByText("Loading environment details…"),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "Retry" }),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.getByRole("checkbox", { name: "Include notebook code" }),
+    ).toBeDisabled();
+    expect(screen.getByText("Notebook source is unavailable.")).toBeVisible();
+    const link = screen.getByRole("link", { name: "Open GitHub issue" });
+    expect(link.getAttribute("href") ?? "").toContain("&env=");
+  });
+
+  it("does not request environment or source while the report dialog is closed", async () => {
+    localStorage.setItem(
+      "marimo:issue-report:include-code",
+      JSON.stringify(true),
+    );
+    const { getEnvironmentInfo, readCode } = setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+      readCode: vi.fn().mockResolvedValue({ contents: "import marimo" }),
+    });
+
+    renderCrashedBoundary();
+
+    expect(screen.getByText("Something went wrong")).toBeVisible();
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(getEnvironmentInfo).not.toHaveBeenCalled();
+    expect(readCode).not.toHaveBeenCalled();
+  });
+
+  it("restores focus to the report button after closing with Escape", async () => {
+    setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+    });
+    renderCrashedBoundary();
+    await openReportDialog();
+    await closeReportDialog("escape");
+    expect(screen.getByText(CRASH_MESSAGE)).toBeVisible();
+  });
+
+  it("restores focus to the report button after closing with the close control", async () => {
+    setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+    });
+    renderCrashedBoundary();
+    await openReportDialog();
+    await closeReportDialog("close");
+    expect(screen.getByText(CRASH_MESSAGE)).toBeVisible();
+  });
+
+  it("reopens the report dialog while the original error remains", async () => {
+    setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+    });
+    renderCrashedBoundary();
+    await openReportDialog();
+    await closeReportDialog("escape");
+    expect(screen.getByText(CRASH_MESSAGE)).toBeVisible();
+    await expectRealReportModal();
+    expect(screen.getByText(CRASH_MESSAGE)).toBeVisible();
+  });
+
+  it("restores the child after try again once the failure is cleared", () => {
+    setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+    });
+    const view = renderCrashedBoundary(<RecoverableChild crash={true} />);
+    expect(screen.getByText("Something went wrong")).toBeVisible();
+
+    view.rerender(
+      <ErrorBoundary>
+        <RecoverableChild crash={false} />
+      </ErrorBoundary>,
+    );
+    fireEvent.click(screen.getByTestId("reset-error-boundary-button"));
+
+    expect(screen.getByText("recovered child")).toBeVisible();
+    expect(screen.queryByText("Something went wrong")).not.toBeInTheDocument();
+  });
+
+  it("does not read notebook source when opened with fresh inclusion preferences", async () => {
+    const { readCode } = setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+      readCode: vi.fn().mockResolvedValue({ contents: "import marimo" }),
+    });
+
+    renderCrashedBoundary();
+    await expectRealReportModal();
+
+    expect(readCode).not.toHaveBeenCalled();
+  });
+
+  it("renders the copy toast after the ancestor toaster is gone", async () => {
+    setRequestClient({
+      getEnvironmentInfo: vi.fn().mockResolvedValue(environment),
+    });
+    renderCrashedBoundary();
+    await expectRealReportModal();
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Copy environment JSON" }),
+    );
+
+    expect(await screen.findByText("Environment details copied")).toBeVisible();
+  });
+});

package/src/components/editor/cell/code/__tests__/rtc-editor-config.test.ts

@@ -0,0 +1,50 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { EditorState } from "@codemirror/state";
+import { describe, expect, it } from "vitest";
+import { composeRtcEditorConfig } from "../cell-editor";
+
+describe("composeRtcEditorConfig", () => {
+  it("does not accumulate RTC extensions across reconfigurations", () => {
+    const baseExtension = EditorState.readOnly.of(false);
+    const baseExtensions = [baseExtension];
+    const firstRtc = {
+      code: "first RTC code",
+      extension: EditorState.tabSize.of(2),
+    };
+    const secondRtc = {
+      code: "second RTC code",
+      extension: EditorState.tabSize.of(4),
+    };
+
+    const firstConfig = composeRtcEditorConfig(
+      "local code",
+      baseExtensions,
+      firstRtc,
+    );
+    const secondConfig = composeRtcEditorConfig(
+      "local code",
+      baseExtensions,
+      secondRtc,
+    );
+
+    expect(baseExtensions).toEqual([baseExtension]);
+    expect(firstConfig).toEqual({
+      code: firstRtc.code,
+      extensions: [baseExtension, firstRtc.extension],
+    });
+    expect(secondConfig).toEqual({
+      code: secondRtc.code,
+      extensions: [baseExtension, secondRtc.extension],
+    });
+  });
+
+  it("reuses the base configuration when RTC is disabled", () => {
+    const extensions = [EditorState.readOnly.of(false)];
+
+    const config = composeRtcEditorConfig("local code", extensions, undefined);
+
+    expect(config).toEqual({ code: "local code", extensions });
+    expect(config.extensions).toBe(extensions);
+  });
+});