@marimo-team/islands 0.24.3-dev9 → 0.25.0

package/src/core/wasm/worker/bootstrap.ts

@@ -41,10 +41,9 @@ export class DefaultWasmController implements WasmController {
     return this.pyodide;
   }
 
-  async bootstrap(opts: {
-    version: string;
-    pyodideVersion: string;
-  }): Promise<PyodideInterface> {
+  async bootstrap(
+    opts: Parameters<WasmController["bootstrap"]>[0],
+  ): Promise<PyodideInterface> {
     const pyodide = await this.loadPyodideAndPackages(opts);
 
     if (MAKE_SNAPSHOT) {
@@ -55,10 +54,9 @@ export class DefaultWasmController implements WasmController {
     return pyodide;
   }
 
-  private async loadPyodideAndPackages(opts: {
-    version: string;
-    pyodideVersion: string;
-  }): Promise<PyodideInterface> {
+  private async loadPyodideAndPackages(
+    opts: Parameters<WasmController["bootstrap"]>[0],
+  ): Promise<PyodideInterface> {
     if (!loadPyodide) {
       throw new Error("loadPyodide is not defined");
     }
@@ -68,7 +66,9 @@ export class DefaultWasmController implements WasmController {
       // Without this, this fails in Firefox with
       // `Could not extract indexURL path from pyodide module`
       // This fixes for Firefox and does not break Chrome/others
-      const indexURL = `https://cdn.jsdelivr.net/pyodide/${opts.pyodideVersion}/full/`;
+      const indexURL =
+        opts.pyodideIndexUrl ??
+        `https://cdn.jsdelivr.net/pyodide/${opts.pyodideVersion}/full/`;
       const pyodide = await loadPyodide({
         // Perf: These get loaded while pyodide is being bootstrapped
         packages: [
@@ -81,16 +81,26 @@ export class DefaultWasmController implements WasmController {
           "packaging",
         ],
         _makeSnapshot: MAKE_SNAPSHOT,
-        lockFileURL: `https://wasm.marimo.app/pyodide-lock.json?v=${opts.version}&pyodide=${opts.pyodideVersion}`,
+        lockFileURL:
+          opts.pyodideLockfileUrl ??
+          `https://wasm.marimo.app/pyodide-lock.json?v=${opts.version}&pyodide=${opts.pyodideVersion}`,
         indexURL,
         // Since Pyodide 0.28.0, when lockFileURL is set, the package base URL
         // defaults to the lockfile's URL (wasm.marimo.app) instead of indexURL.
         // Unlike Node, browsers get no CDN fallback on a failed fetch, so we
-        // should pin packageBaseUrl back to the jsDelivr CDN  to restore
+        // should pin packageBaseUrl to indexURL to restore
         // the resolution akin to pre-0.28.
         packageBaseUrl: indexURL,
         convertNullToNone: true,
       });
+      if (opts.pypiIndexUrl) {
+        const micropip = pyodide.pyimport("micropip");
+        try {
+          micropip.set_index_urls(opts.pypiIndexUrl);
+        } finally {
+          micropip.destroy();
+        }
+      }
       this.pyodide = pyodide;
       span.end("ok");
       return pyodide;

package/src/core/wasm/worker/constants.ts

@@ -1,2 +1,3 @@
 /* Copyright 2026 Marimo. All rights reserved. */
+export const CUSTOM_CONTROLLER_SUFFIX = "::controller";
 export const TRANSPORT_ID = "marimo-transport";

package/src/core/wasm/worker/fs.ts

@@ -20,6 +20,10 @@ export const WasmFileSystem = {
     FS.chdir(HOME_DIR);
   },
   mountFS: (pyodide: PyodideInterface) => {
+    // Opaque origins (single-file exports) use the in-memory filesystem.
+    if (globalThis.origin === "null") {
+      return;
+    }
     const FS = getFS(pyodide);
     // Mount the filesystem
     FS.mount(pyodide.FS.filesystems.IDBFS, { root: "." }, HOME_DIR);

package/src/core/wasm/worker/getController.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { DefaultWasmController } from "./bootstrap";
+import { CUSTOM_CONTROLLER_SUFFIX } from "./constants";
 import type { WasmController } from "./types";
 
 // Load the controller
@@ -8,7 +9,8 @@ export async function getController(version: string): Promise<WasmController> {
   // Hosts that provide a custom /wasm/controller.js opt in via the worker
   // name (see bridge.ts). Default: skip the dynamic import to avoid a
   // guaranteed-404 round trip on the standard build.
-  const hasCustomController = self.name?.includes("::controller") ?? false;
+  const hasCustomController =
+    self.name?.includes(CUSTOM_CONTROLLER_SUFFIX) ?? false;
   if (!hasCustomController) {
     return new DefaultWasmController();
   }

package/src/core/wasm/worker/save-worker.ts

@@ -9,9 +9,11 @@ import {
 } from "rpc-anywhere";
 import type { SaveNotebookRequest } from "@/core/network/types";
 import { decodeUtf8 } from "@/utils/strings";
+import { Deferred } from "../../../utils/Deferred";
 import { prettyError } from "../../../utils/errors";
 import { Logger } from "../../../utils/Logger";
 import type { ParentSchema } from "../rpc";
+import type { WasmRuntimeConfig } from "../runtime-config";
 import { TRANSPORT_ID } from "./constants";
 import { WasmFileSystem } from "./fs";
 import { getController } from "./getController";
@@ -25,18 +27,20 @@ declare const self: Window & {
   pyodide: PyodideInterface;
 };
 
+const runtimeConfig = new Deferred<WasmRuntimeConfig>();
+
 // Initialize
 async function loadPyodideAndPackages() {
   try {
     // Import pyodide
-    const marimoVersion = getMarimoVersion();
-    const pyodideVersion = getPyodideVersion(marimoVersion);
+    const config = await runtimeConfig.promise;
+    const pyodideVersion = getPyodideVersion(config.version);
 
     // Bootstrap the controller
-    const controller = await getController(marimoVersion);
+    const controller = await getController(config.version);
     self.controller = controller;
     self.pyodide = await controller.bootstrap({
-      version: marimoVersion,
+      ...config,
       pyodideVersion: pyodideVersion,
     });
 
@@ -100,9 +104,6 @@ const rpc = createRPC<SaveWorkerSchema, ParentSchema>({
   requestHandler,
 });
 
-rpc.send("ready", {});
+rpc.addMessageListener("bootstrap", (config) => runtimeConfig.resolve(config));
 
-function getMarimoVersion() {
-  // Worker name is "<version>" or "<version>::<capability>" — see bridge.ts.
-  return self.name.split("::")[0];
-}
+rpc.send("ready", {});

package/src/core/wasm/worker/types.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import type { PyodideInterface } from "pyodide";
+import type { WasmRuntimeConfig } from "../runtime-config";
 import type { UserConfig } from "@/core/config/config-schema";
 import type {
   CommandMessage,
@@ -43,10 +44,11 @@ export interface WasmController {
    * Prepare the wasm environment
    * @param opts.version - The marimo version
    */
-  bootstrap(opts: {
-    version: string;
-    pyodideVersion: string;
-  }): Promise<PyodideInterface>;
+  bootstrap(
+    opts: WasmRuntimeConfig & {
+      pyodideVersion: string;
+    },
+  ): Promise<PyodideInterface>;
   /**
    * Mount the filesystem
    * @param opts.code - The code to mount

package/src/core/wasm/worker/worker.ts

@@ -22,6 +22,7 @@ import { prettyError } from "../../../utils/errors";
 import { invariant } from "../../../utils/invariant";
 import { Logger } from "../../../utils/Logger";
 import type { ParentSchema } from "../rpc";
+import type { WasmRuntimeConfig } from "../runtime-config";
 import { TRANSPORT_ID } from "./constants";
 import { WasmFileSystem } from "./fs";
 import { getController } from "./getController";
@@ -47,18 +48,20 @@ declare const self: Window & {
 
 const workerInitSpan = t.startSpan("worker:init");
 
+const runtimeConfig = new Deferred<WasmRuntimeConfig>();
+
 // Initialize pyodide
 async function loadPyodideAndPackages() {
   try {
-    const marimoVersion = getMarimoVersion();
-    const pyodideVersion = getPyodideVersion(marimoVersion);
-    const controller = await t.wrapAsync(getController)(marimoVersion);
+    const config = await runtimeConfig.promise;
+    const pyodideVersion = getPyodideVersion(config.version);
+    const controller = await t.wrapAsync(getController)(config.version);
     self.controller = controller;
     rpc.send.initializingMessage({
       message: "Loading marimo...",
     });
     self.pyodide = await t.wrapAsync(controller.bootstrap.bind(controller))({
-      version: marimoVersion,
+      ...config,
       pyodideVersion: pyodideVersion,
     });
   } catch (error) {
@@ -354,6 +357,8 @@ const rpc = createRPC<WorkerSchema, ParentSchema>({
   requestHandler,
 });
 
+rpc.addMessageListener("bootstrap", (config) => runtimeConfig.resolve(config));
+
 rpc.send("ready", {});
 
 /// Listeners
@@ -374,9 +379,4 @@ const namesThatRequireSync = new Set<keyof RawBridge>([
   "update_file",
 ]);
 
-function getMarimoVersion() {
-  // Worker name is "<version>" or "<version>::<capability>" — see bridge.ts.
-  return self.name.split("::")[0];
-}
-
 const pyodideReadyPromise = t.wrapAsync(loadPyodideAndPackages)();

package/src/core/websocket/__tests__/useMarimoKernelConnection.hook.test.tsx

@@ -1,11 +1,25 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 // @vitest-environment jsdom
 
-import { act, renderHook } from "@testing-library/react";
+import {
+  act,
+  fireEvent,
+  render,
+  renderHook,
+  screen,
+} from "@testing-library/react";
 import { createStore, Provider as JotaiProvider } from "jotai";
 import type React from "react";
 import { ErrorBoundary } from "react-error-boundary";
-import { beforeEach, describe, expect, it, type Mock, vi } from "vitest";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  type Mock,
+  vi,
+} from "vitest";
 
 vi.mock("@/core/websocket/useWebSocket", async () => {
   const actual =
@@ -26,9 +40,17 @@ vi.mock("@/core/runtime/config", async () => {
   };
 });
 
+import { MockNotebook } from "@/__mocks__/notebook";
+import { cellId } from "@/__tests__/branded";
+import { alertAtom, getPackageAlert } from "@/core/alerts/state";
+import { notebookAtom } from "@/core/cells/cells";
+import { AppConfigSchema } from "@/core/config/config-schema";
+import { ConnectionNotice } from "@/components/editor/alerts/connection-notice";
+import { kernelStartupErrorAtom } from "@/core/errors/state";
+import type { NotificationPayload } from "@/core/kernel/messages";
 import { useRuntimeManager } from "@/core/runtime/config";
 import { initialRunCompletedAtom } from "../../kernel/state";
-import { connectionAtom } from "../../network/connection";
+import { connectionAtom, startupProgressAtom } from "../../network/connection";
 import type { SessionId } from "../../kernel/session";
 import { WebSocketClosedReason, WebSocketState } from "../types";
 import type { IConnectionTransport } from "../transports/transport";
@@ -188,3 +210,382 @@ describe("useMarimoKernelConnection messages", () => {
     expect(store.get(initialRunCompletedAtom)).toBe(true);
   });
 });
+
+it.each(["kernel-ready", "reconnected"])(
+  "waits for %s before marking the session connected",
+  async (op) => {
+    const store = createStore();
+    store.set(connectionAtom, { state: WebSocketState.CONNECTING });
+    vi.mocked(useConnectionTransport).mockClear();
+    vi.mocked(useConnectionTransport).mockReturnValue(
+      makeTransport(WebSocket.OPEN),
+    );
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    renderConnectionHook(store);
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+
+    await act(async () => {
+      await options.onOpen(new Event("open"));
+    });
+    expect(store.get(connectionAtom).state).toBe(WebSocketState.CONNECTING);
+
+    act(() => {
+      options.onMessage(
+        new MessageEvent("message", {
+          data: JSON.stringify({
+            op,
+            data: {
+              op,
+              cell_ids: [],
+              codes: [],
+              names: [],
+              configs: [],
+              layout: null,
+              resumed: true,
+              ui_values: {},
+              last_executed_code: {},
+              last_execution_time: {},
+              app_config: { width: "normal" },
+              kiosk: false,
+              capabilities: { terminal: false },
+              auto_instantiated: false,
+              consumer_capabilities: { edit: true, interact: true },
+            },
+          }),
+        }),
+      );
+    });
+    expect(store.get(connectionAtom).state).toBe(WebSocketState.OPEN);
+  },
+);
+
+describe("connection notice", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  function renderNotice() {
+    const store = createStore();
+    store.set(connectionAtom, { state: WebSocketState.CONNECTING });
+    const transport = makeTransport(WebSocket.OPEN);
+    vi.mocked(useConnectionTransport).mockReturnValue(transport);
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    const Connection = () => {
+      const { reconnect } = useMarimoKernelConnection({
+        sessionId: "test-session" as SessionId,
+        autoInstantiate: false,
+        setCells: () => {},
+      });
+      return (
+        <ConnectionNotice
+          appConfig={AppConfigSchema.parse({})}
+          onRetry={reconnect}
+        />
+      );
+    };
+    render(
+      <JotaiProvider store={store}>
+        <ErrorBoundary fallback={null}>
+          <Connection />
+        </ErrorBoundary>
+      </JotaiProvider>,
+    );
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+    const send = (data: NotificationPayload["data"]) =>
+      act(() => {
+        options.onMessage(
+          new MessageEvent("message", {
+            data: JSON.stringify({ op: data.op, data }),
+          }),
+        );
+      });
+    return { store, transport, options, send };
+  }
+
+  it("keeps elapsed time across startup phases and leaves reconnection to the footer once cells are available", () => {
+    const { store, options, send } = renderNotice();
+    send({
+      op: "startup-progress",
+      phase: "preparing-environment",
+      logs: "",
+      log_mode: "replace",
+    });
+    expect(
+      screen.queryByRole("region", { name: "Notebook startup" }),
+    ).not.toBeInTheDocument();
+    act(() => vi.advanceTimersByTime(500));
+    expect(screen.getByRole("status")).toHaveTextContent(
+      "Preparing environment",
+    );
+    act(() => vi.advanceTimersByTime(35_000));
+    expect(screen.getByText("Elapsed 35s")).toBeInTheDocument();
+    act(() =>
+      store.set(
+        notebookAtom,
+        MockNotebook.notebookState({
+          cellData: { [cellId("test")]: { code: "answer = 42" } },
+        }),
+      ),
+    );
+    send({
+      op: "startup-progress",
+      phase: "starting-kernel",
+      logs: "",
+      log_mode: "replace",
+    });
+    expect(screen.getByRole("status")).toHaveTextContent("Starting kernel");
+    expect(screen.getByText("Elapsed 35s")).toBeInTheDocument();
+    send({ op: "reconnected" });
+    expect(
+      screen.queryByRole("region", { name: "Notebook startup" }),
+    ).not.toBeInTheDocument();
+    act(() => options.onClose(new CloseEvent("close")));
+    act(() => vi.advanceTimersByTime(500));
+    expect(store.get(connectionAtom)).toEqual({
+      state: WebSocketState.CONNECTING,
+      phase: "reconnecting",
+    });
+    expect(
+      screen.queryByRole("region", { name: "Notebook startup" }),
+    ).not.toBeInTheDocument();
+  });
+
+  it("restores startup output before appending live chunks and resets it for a new attempt", () => {
+    const { store, send } = renderNotice();
+    const snapshot = {
+      op: "startup-progress",
+      phase: "starting-kernel",
+      logs: "Downloading runtime\n",
+      log_mode: "replace",
+    } as const;
+    send(snapshot);
+    send(snapshot);
+    const connection = store.get(connectionAtom);
+    send({ ...snapshot, logs: "Loading kernel\n", log_mode: "append" });
+    expect(store.get(startupProgressAtom)).toEqual({
+      phase: "starting-kernel",
+      logs: "Downloading runtime\nLoading kernel\n",
+    });
+    expect(store.get(connectionAtom)).toBe(connection);
+    expect(getPackageAlert(store.get(alertAtom))).toBeNull();
+
+    send({ ...snapshot, phase: "preparing-environment", logs: "" });
+    expect(store.get(startupProgressAtom)).toEqual({
+      phase: "preparing-environment",
+      logs: "",
+    });
+  });
+
+  it("restores completed startup output without putting a connected kernel back into startup", async () => {
+    const { store, options, send } = renderNotice();
+    send({ op: "reconnected" });
+    send({
+      op: "startup-progress",
+      phase: "starting-kernel",
+      logs: "Kernel startup output\n",
+      log_mode: "replace",
+    });
+    expect(store.get(connectionAtom)).toEqual({ state: WebSocketState.OPEN });
+    expect(store.get(startupProgressAtom)).toEqual({
+      phase: "starting-kernel",
+      logs: "Kernel startup output\n",
+    });
+    act(() => vi.advanceTimersByTime(500));
+    expect(
+      screen.queryByRole("region", { name: "Notebook startup" }),
+    ).not.toBeInTheDocument();
+
+    // A new transport starts from the next session's authoritative snapshot.
+    await act(async () => options.onOpen(new Event("open")));
+    expect(store.get(startupProgressAtom)).toBeNull();
+  });
+
+  it("does not flash a notice when startup finishes within the delay", () => {
+    const { send } = renderNotice();
+    send({
+      op: "startup-progress",
+      phase: "preparing-environment",
+      logs: "",
+      log_mode: "replace",
+    });
+    act(() => vi.advanceTimersByTime(200));
+    send({
+      op: "startup-progress",
+      phase: "starting-kernel",
+      logs: "",
+      log_mode: "replace",
+    });
+    act(() => vi.advanceTimersByTime(200));
+    expect(
+      screen.queryByRole("region", { name: "Notebook startup" }),
+    ).not.toBeInTheDocument();
+    send({ op: "reconnected" });
+    act(() => vi.advanceTimersByTime(500));
+    expect(
+      screen.queryByRole("region", { name: "Notebook startup" }),
+    ).not.toBeInTheDocument();
+  });
+
+  it.each([
+    ["preparing-environment", "Sandbox setup failed"],
+    ["starting-kernel", "Kernel failed to start"],
+  ] as const)(
+    "keeps a %s failure available until the user retries",
+    async (phase, title) => {
+      const { store, transport, options, send } = renderNotice();
+      send({ op: "startup-progress", phase, logs: "", log_mode: "replace" });
+      const error = "A full diagnostic\nwith <stderr> details";
+      send({ op: "kernel-startup-error", error });
+      transport.readyState = WebSocket.CLOSED;
+      act(() =>
+        options.onClose(
+          new CloseEvent("close", { reason: "MARIMO_KERNEL_STARTUP_ERROR" }),
+        ),
+      );
+      expect(screen.getByRole("status")).toHaveTextContent(title);
+      act(() => vi.advanceTimersByTime(30_000));
+      expect(screen.getByRole("status")).toHaveTextContent(title);
+      expect(screen.getByLabelText("Error details")).toHaveTextContent(error, {
+        normalizeWhitespace: false,
+      });
+      expect(transport.reconnect).not.toHaveBeenCalled();
+      await act(async () =>
+        fireEvent.click(screen.getByRole("button", { name: "Try again" })),
+      );
+      expect(transport.reconnect).toHaveBeenCalledOnce();
+      expect(store.get(kernelStartupErrorAtom)).toBeNull();
+      expect(
+        screen.queryByRole("button", { name: "Try again" }),
+      ).not.toBeInTheDocument();
+      send({
+        op: "startup-progress",
+        phase: "preparing-environment",
+        logs: "",
+        log_mode: "replace",
+      });
+      act(() => vi.advanceTimersByTime(500));
+      expect(screen.getByRole("status")).toHaveTextContent(
+        "Preparing environment",
+      );
+      expect(screen.getByText("Elapsed 0s")).toBeInTheDocument();
+    },
+  );
+});
+
+it("replaces environment state from snapshots, then continues live progress", () => {
+  const store = createStore();
+  vi.mocked(useConnectionTransport).mockClear();
+  vi.mocked(useConnectionTransport).mockReturnValue(
+    makeTransport(WebSocket.OPEN),
+  );
+  vi.mocked(useRuntimeManager).mockReturnValue(
+    makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+  );
+  renderConnectionHook(store);
+  const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)?.[0];
+  function receive(data: NotificationPayload["data"]) {
+    act(() =>
+      options?.onMessage(
+        new MessageEvent("message", {
+          data: JSON.stringify({ op: data.op, data }),
+        }),
+      ),
+    );
+  }
+  receive({
+    op: "environment-operation",
+    source: "kernel",
+    operation_id: "old",
+    action: "install",
+    status: { kind: "running" },
+    packages: { pandas: "running" },
+    logs: { pandas: "stale" },
+    log_mode: "append",
+  });
+  const operation = {
+    operation_id: "new",
+    action: "install",
+    source: "kernel",
+    status: { kind: "running" },
+    packages: { numpy: "running" },
+    logs: { numpy: "Downloading\n" },
+  } as const;
+  const serverOperation = {
+    ...operation,
+    operation_id: "server",
+    action: "install",
+    source: "server",
+    status: { kind: "succeeded" },
+    packages: { numpy: "succeeded" },
+    logs: { numpy: "Server logs\n" },
+  } as const;
+  receive({
+    op: "environment-state",
+    source: "server",
+    state: {
+      restart_required: false,
+      operations: [serverOperation],
+    },
+  });
+  const snapshot = {
+    op: "environment-state",
+    source: "kernel",
+    state: { restart_required: false, operations: [operation] },
+  } as const;
+  // Receiving a snapshot twice must not duplicate logs.
+  receive({
+    ...snapshot,
+    state: { ...snapshot.state, operations: [operation] },
+  });
+  receive({
+    ...snapshot,
+    state: { ...snapshot.state, operations: [operation] },
+  });
+  receive({
+    op: "environment-operation",
+    operation_id: "new",
+    action: "install",
+    source: "kernel",
+    status: { kind: "failed", error: "Network unavailable" },
+    packages: { numpy: "running" },
+    logs: { numpy: "Failed\n" },
+    log_mode: "append",
+  });
+  expect(getPackageAlert(store.get(alertAtom))).toEqual({
+    ...operation,
+    id: "new",
+    kind: "environment",
+    restartRequired: false,
+    status: { kind: "failed", error: "Network unavailable" },
+    logs: { numpy: "Downloading\nFailed\n" },
+  });
+  receive({
+    op: "environment-state",
+    source: "kernel",
+    state: {
+      restart_required: false,
+      operations: [],
+    },
+  });
+  // Clearing the active environment must not promote an old server success.
+  expect(getPackageAlert(store.get(alertAtom))).toBeNull();
+  expect(store.get(alertAtom).environments.server.operations).toEqual([
+    serverOperation,
+  ]);
+  receive({
+    op: "environment-state",
+    source: "server",
+    state: {
+      restart_required: false,
+      operations: [],
+    },
+  });
+  expect(getPackageAlert(store.get(alertAtom))).toBeNull();
+  expect(store.get(alertAtom).environments).toEqual({
+    kernel: { restart_required: false, operations: [] },
+    server: { restart_required: false, operations: [] },
+  });
+});

package/src/core/websocket/__tests__/useMarimoKernelConnection.test.ts

@@ -47,9 +47,10 @@ describe("classifyCloseEvent", () => {
         state: WebSocketState.CLOSED,
         code: WebSocketClosedReason.KERNEL_DISCONNECTED,
       });
-      if (decision.kind === "terminal") {
-        expect(decision.closeTransport).toBe(true);
-      }
+      expect(decision).toMatchObject({
+        kind: "terminal",
+        closeTransport: true,
+      });
     });
 
     it("MARIMO_KERNEL_STARTUP_ERROR → terminal + closeTransport", () => {
@@ -59,9 +60,10 @@ describe("classifyCloseEvent", () => {
         state: WebSocketState.CLOSED,
         code: WebSocketClosedReason.KERNEL_STARTUP_ERROR,
       });
-      if (decision.kind === "terminal") {
-        expect(decision.closeTransport).toBe(true);
-      }
+      expect(decision).toMatchObject({
+        kind: "terminal",
+        closeTransport: true,
+      });
     });
   });