@marimo-team/frontend 0.25.3-dev13 → 0.25.3-dev135

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

@@ -21,8 +21,8 @@ import {
   vi,
 } from "vitest";
 
-vi.mock("../transports/create", () => ({
-  createConnectionTransport: vi.fn(),
+vi.mock("../backend", () => ({
+  createEditorBackend: vi.fn(),
 }));
 
 vi.mock("@/core/runtime/config", async () => {
@@ -36,21 +36,13 @@ vi.mock("@/core/runtime/config", async () => {
 });
 
 import { MockNotebook } from "@/__mocks__/notebook";
-import * as Toast from "@/components/ui/use-toast";
-import { Logger } from "@/utils/Logger";
 import { Deferred } from "@/utils/Deferred";
 import { cellId } from "@/__tests__/branded";
 import { alertAtom, getPackageAlert } from "@/core/alerts/state";
-import {
-  type Attachment,
-  attachmentsAtom,
-  agentAttachmentsAtom,
-} from "@/core/attachments/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 { RunEvent } from "@/core/host/protocol";
 import type { NotificationPayload } from "@/core/kernel/messages";
 import { useRuntimeManager } from "@/core/runtime/config";
 import { initialRunCompletedAtom } from "../../kernel/state";
@@ -58,54 +50,75 @@ import { connectionAtom, startupProgressAtom } from "../../network/connection";
 import { generateSessionId } from "../../kernel/session";
 import { RuntimeManager } from "../../runtime/runtime";
 import { WebSocketClosedReason, ConnectionState } from "../types";
-import type { IConnectionTransport } from "../transports/transport";
+import { classifyCloseEvent } from "../connection-state";
+import { createEditorBackend } from "../backend";
+import { fakeBackend } from "../../host/__tests__/fixtures";
 import { useNotebookSession } from "../useNotebookSession";
-import { createConnectionTransport } from "../transports/create";
+import { type NotebookTransport, StreamStopped } from "@marimo-team/client";
 
 const SESSION_ID = generateSessionId();
 
-interface MockTransport {
-  readyState: 0 | 1 | 2 | 3;
-  reconnect: Mock<IConnectionTransport["reconnect"]>;
-  close: Mock<IConnectionTransport["close"]>;
-  send: Mock<IConnectionTransport["send"]>;
-  addEventListener: Mock<IConnectionTransport["addEventListener"]>;
-  removeEventListener: Mock<IConnectionTransport["removeEventListener"]>;
+/** One connection the fake transport opened. */
+interface Attempt {
+  open(): void;
+  receive(message: unknown): void;
+  drop(): void;
+  stop(error: StreamStopped): void;
 }
 
-function makeTransport(
-  readyState: 0 | 1 | 2 | 3 = WebSocket.CLOSED,
-): MockTransport {
-  return {
-    readyState,
-    reconnect: vi.fn(),
-    close: vi.fn(),
-    send: vi.fn(),
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-  };
+/** A transport the test drives, one connection at a time. */
+function makeTransport() {
+  const attempts: Attempt[] = [];
+  const transport: NotebookTransport = ({ signal }, handlers) =>
+    new Promise((resolve, reject) => {
+      attempts.push({
+        open: handlers.open,
+        receive: handlers.message,
+        drop: resolve,
+        stop: reject,
+      });
+      signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+  return { transport, attempts };
 }
 
-function getTransportHandlers() {
-  const result = vi.mocked(createConnectionTransport).mock.results.at(-1);
-  if (!result || result.type !== "return") {
-    throw new Error("No connection transport was created");
-  }
-  const transport = result.value;
-  function emit(
-    event: "open" | "close" | "error" | "message",
-    message: Event | CloseEvent | MessageEvent,
-  ) {
-    const callback = vi
-      .mocked(transport.addEventListener)
-      .mock.calls.find(([name]) => name === event)?.[1];
-    callback?.(message);
-  }
+type FakeTransport = ReturnType<typeof makeTransport>;
+
+/** Use a fake transport for the next session the hook follows. */
+function withTransport(fake: FakeTransport = makeTransport()) {
+  vi.mocked(createEditorBackend).mockImplementation(({ checkHealth }) =>
+    fakeBackend({ transport: fake.transport, checkHealth }),
+  );
+  return fake;
+}
+
+/** Let the stream open its first connection. */
+const started = () => act(() => Promise.resolve());
+
+/** Drive the latest connection the fake transport opened. */
+function connection(fake: FakeTransport) {
+  const current = () => {
+    const attempt = fake.attempts.at(-1);
+    if (attempt === undefined) {
+      throw new Error("No connection was opened");
+    }
+    return attempt;
+  };
   return {
-    onError: (event: Event) => emit("error", event),
-    onOpen: (event: Event) => emit("open", event),
-    onClose: (event: CloseEvent) => emit("close", event),
-    onMessage: (event: MessageEvent) => emit("message", event),
+    open: () => current().open(),
+    receive: (message: unknown) => current().receive(message),
+    /** Deliver a notification as the session routes frame it. */
+    send: (notification: unknown) =>
+      current().receive({ event: "marimo", data: { marimo: notification } }),
+    /** End the connection so the stream reconnects. */
+    drop: () => current().drop(),
+    /** Close the connection with a reason the editor treats as final. */
+    close: (reason: string) =>
+      current().stop(
+        new StreamStopped(reason, {
+          cause: classifyCloseEvent({ reason }).status,
+        }),
+      ),
   };
 }
 
@@ -147,12 +160,12 @@ function renderConnectionHook(store: ReturnType<typeof createStore>) {
 }
 
 describe("useNotebookSession.reconnect()", () => {
-  let transport: MockTransport;
+  let fake: FakeTransport;
   let isHealthy: Mock<() => Promise<boolean>>;
   let store: ReturnType<typeof createStore>;
 
   beforeEach(() => {
-    transport = makeTransport(WebSocket.CLOSED);
+    fake = withTransport();
     isHealthy = vi.fn<() => Promise<boolean>>().mockResolvedValue(true);
     store = createStore();
     store.set(connectionAtom, {
@@ -160,55 +173,53 @@ describe("useNotebookSession.reconnect()", () => {
       code: WebSocketClosedReason.KERNEL_DISCONNECTED,
       reason: "kernel not found",
     });
-    vi.mocked(createConnectionTransport).mockReturnValue(transport);
     vi.mocked(useRuntimeManager).mockReturnValue(makeRuntimeManager(isHealthy));
   });
 
-  function renderUseHook() {
-    return renderConnectionHook(store);
+  async function renderStopped() {
+    const hook = renderConnectionHook(store);
+    await started();
+    await act(async () => connection(fake).close("MARIMO_SHUTDOWN"));
+    return hook;
   }
 
-  it("is a no-op when the transport is already OPEN", async () => {
-    transport.readyState = WebSocket.OPEN;
-    const { result } = renderUseHook();
-    await act(async () => {
-      await result.current.reconnect();
-    });
-    expect(isHealthy).not.toHaveBeenCalled();
-    expect(transport.reconnect).not.toHaveBeenCalled();
-  });
-
-  it("is a no-op when the transport is already CONNECTING", async () => {
-    transport.readyState = WebSocket.CONNECTING;
-    const { result } = renderUseHook();
-    await act(async () => {
-      await result.current.reconnect();
-    });
-    expect(isHealthy).not.toHaveBeenCalled();
-    expect(transport.reconnect).not.toHaveBeenCalled();
-  });
+  it.each(["connecting", "connected"])(
+    "is a no-op while the stream is %s",
+    async (state) => {
+      const { result } = renderConnectionHook(store);
+      await started();
+      if (state === "connected") {
+        act(() => connection(fake).open());
+      }
+      await act(async () => {
+        await result.current.reconnect();
+      });
+      expect(isHealthy).not.toHaveBeenCalled();
+      expect(fake.attempts).toHaveLength(1);
+    },
+  );
 
   it("probes /health and reconnects when the runtime is healthy", async () => {
     isHealthy.mockResolvedValue(true);
-    const { result } = renderUseHook();
+    const { result } = await renderStopped();
     await act(async () => {
       await result.current.reconnect();
     });
     expect(isHealthy).toHaveBeenCalledOnce();
-    expect(transport.reconnect).toHaveBeenCalledOnce();
+    expect(fake.attempts).toHaveLength(2);
     expect(store.get(connectionAtom)).toEqual({
       state: ConnectionState.CONNECTING,
     });
   });
 
-  it("transitions to CLOSED and does not call ws.reconnect when the probe fails", async () => {
+  it("transitions to CLOSED and does not reconnect when the probe fails", async () => {
     isHealthy.mockResolvedValue(false);
-    const { result } = renderUseHook();
+    const { result } = await renderStopped();
     await act(async () => {
       await result.current.reconnect();
     });
     expect(isHealthy).toHaveBeenCalledOnce();
-    expect(transport.reconnect).not.toHaveBeenCalled();
+    expect(fake.attempts).toHaveLength(1);
     expect(store.get(connectionAtom)).toEqual({
       state: ConnectionState.CLOSED,
       code: WebSocketClosedReason.KERNEL_DISCONNECTED,
@@ -219,144 +230,30 @@ describe("useNotebookSession.reconnect()", () => {
 
 describe("useNotebookSession messages", () => {
   let store: ReturnType<typeof createStore>;
+  let fake: FakeTransport;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     store = createStore();
-    vi.mocked(createConnectionTransport).mockClear();
-    vi.mocked(createConnectionTransport).mockReturnValue(
-      makeTransport(WebSocket.OPEN),
-    );
+    fake = withTransport();
     vi.mocked(useRuntimeManager).mockReturnValue(makeRuntimeManager());
     renderConnectionHook(store);
+    await started();
   });
 
   function receive(payload: unknown) {
-    const options = getTransportHandlers();
-    act(() => {
-      options.onMessage(
-        new MessageEvent("message", { data: JSON.stringify(payload) }),
-      );
-    });
+    act(() => connection(fake).receive(payload));
   }
 
-  it("replaces attachment snapshots, including the last detach", () => {
-    const agent: Attachment = {
-      id: "a1",
-      kind: "agent",
-      name: "Pi",
-      since: "2026-10-14T00:00:00Z",
-      notebook_id: "nb-test",
-      identity: "pi-thread",
-    };
-    const client: Attachment = {
-      id: "c1",
-      kind: "client",
-      name: null,
-      since: "2026-10-14T00:00:01Z",
-      notebook_id: "nb-test",
-    };
-    for (const attachments of [[agent, client], [client], []]) {
-      receive({ data: { op: "attachments", attachments } });
-      expect(store.get(attachmentsAtom)).toEqual(attachments);
-    }
-  });
-
-  it.each(["{broken", "null"])(
-    "reports a malformed legacy frame and continues applying notifications: %s",
-    (data) => {
-      const toast = vi.spyOn(Toast, "toast");
-      try {
-        receive({ data: { op: "reconnected" } });
-        act(() =>
-          getTransportHandlers().onMessage(
-            new MessageEvent("message", { data }),
-          ),
-        );
-        expect(toast).toHaveBeenCalledExactlyOnceWith({
-          title: "Failed to handle message",
-          description: expect.any(String),
-          variant: "danger",
-        });
-        expect(store.get(connectionAtom)).toEqual({
-          state: ConnectionState.OPEN,
-        });
-        receive({
-          data: {
-            op: "completed-run",
-            run_id: "r1",
-            outcome: "succeeded",
-            error: null,
-          },
-        });
-        expect(store.get(initialRunCompletedAtom)).toBe(true);
-      } finally {
-        toast.mockRestore();
-      }
-    },
-  );
-
-  it.each(["session", "host"])(
-    "records completion of the initial run from the %s stream",
-    (stream) => {
-      const notification = {
-        op: "completed-run",
-        run_id: null,
-        outcome: "succeeded",
-        error: null,
-      } satisfies NotificationPayload["data"];
-      expect(store.get(initialRunCompletedAtom)).toBe(false);
-      receive(
-        stream === "host"
-          ? { id: "42", event: "marimo", data: { marimo: notification } }
-          : { op: notification.op, data: notification },
-      );
-      expect(store.get(initialRunCompletedAtom)).toBe(true);
-    },
-  );
-
-  it("ignores other host events before handling the next notification", () => {
-    const errors = vi.spyOn(Logger, "error").mockImplementation(vi.fn());
-    try {
-      receive({ id: "1", event: "ready", data: {} });
-      receive({
-        id: "2",
-        event: "run",
-        data: {
-          run: {
-            id: "r1",
-            notebook_id: "n1",
-            caused_by: null,
-            status: "completed",
-            outcome: "succeeded",
-            started_at: "2026-10-19T12:00:00Z",
-            completed_at: "2026-10-19T12:00:01Z",
-          },
-        },
-      } satisfies RunEvent);
-      receive({
-        id: "3",
-        event: "future-event",
-        data: { marimo: { op: "completed-run", run_id: "r1" } },
-      });
-      receive({ id: "4", event: "another-event", data: null });
-      expect(store.get(initialRunCompletedAtom)).toBe(false);
-      receive({
-        id: "5",
-        event: "marimo",
-        data: {
-          marimo: {
-            op: "completed-run",
-            run_id: "r1",
-            outcome: "succeeded",
-            error: null,
-          },
-        },
-      });
-      expect(store.get(initialRunCompletedAtom)).toBe(true);
-      expect(errors).not.toHaveBeenCalled();
-    } finally {
-      errors.mockRestore();
-    }
+  it("records completion of the initial run", () => {
+    const notification = {
+      op: "completed-run",
+      run_id: null,
+      outcome: "succeeded",
+      error: null,
+    } satisfies NotificationPayload["data"];
+    expect(store.get(initialRunCompletedAtom)).toBe(false);
+    receive({ id: "42", event: "marimo", data: { marimo: notification } });
+    expect(store.get(initialRunCompletedAtom)).toBe(true);
   });
 });
 
@@ -365,190 +262,35 @@ it.each(["kernel-ready", "reconnected"])(
   async (op) => {
     const store = createStore();
     store.set(connectionAtom, { state: ConnectionState.CONNECTING });
-    vi.mocked(createConnectionTransport).mockClear();
-    vi.mocked(createConnectionTransport).mockReturnValue(
-      makeTransport(WebSocket.OPEN),
-    );
-    vi.mocked(useRuntimeManager).mockReturnValue(makeRuntimeManager());
-    renderConnectionHook(store);
-    const options = getTransportHandlers();
-
-    await act(async () => {
-      await options.onOpen(new Event("open"));
-    });
-    expect(store.get(connectionAtom).state).toBe(ConnectionState.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(ConnectionState.OPEN);
-  },
-);
-
-describe("attachment snapshots across browser connections", () => {
-  const agent: Attachment = {
-    id: "a1",
-    kind: "agent",
-    name: "Pi",
-    since: "2026-10-14T00:00:00Z",
-    notebook_id: "nb-test",
-    identity: "pi-thread",
-  };
-
-  function connectedSession() {
-    const store = createStore();
-    store.set(connectionAtom, { state: ConnectionState.OPEN });
-    store.set(attachmentsAtom, [agent]);
-    const transport = makeTransport(WebSocket.OPEN);
-    vi.mocked(createConnectionTransport).mockReturnValue(transport);
+    const fake = withTransport();
     vi.mocked(useRuntimeManager).mockReturnValue(makeRuntimeManager());
     renderConnectionHook(store);
-    const options = getTransportHandlers();
-    const receive = (data: NotificationPayload["data"]) =>
-      act(() => {
-        options.onMessage(
-          new MessageEvent("message", {
-            data: JSON.stringify({ op: data.op, data }),
-          }),
-        );
-      });
-    return { store, transport, options, receive };
-  }
-
-  it.each([
-    "MARIMO_NO_FILE_KEY",
-    "MARIMO_NO_SESSION_ID",
-    "MARIMO_NO_SESSION",
-    "MARIMO_SHUTDOWN",
-    "MARIMO_KERNEL_STARTUP_ERROR",
-    "MARIMO_UNAUTHORIZED",
-    "MARIMO_KIOSK_NOT_ALLOWED",
-    "MARIMO_TRANSPORT_EXHAUSTED",
-  ])("clears cached attachments on %s", (reason) => {
-    const { store, transport, options } = connectedSession();
-    act(() => options.onClose(new CloseEvent("close", { reason })));
-    expect(store.get(attachmentsAtom)).toEqual([]);
-    expect(store.get(agentAttachmentsAtom)).toEqual([]);
-    expect(store.get(connectionAtom).state).toBe(ConnectionState.CLOSED);
-    expect(transport.reconnect).not.toHaveBeenCalled();
-  });
-
-  it("clears the snapshot on transport error", () => {
-    const { store, options } = connectedSession();
-    act(() => options.onError(new Event("error")));
-    expect(store.get(attachmentsAtom)).toEqual([]);
-    expect(store.get(agentAttachmentsAtom)).toEqual([]);
-  });
+    await started();
+    const conn = connection(fake);
 
-  it("waits for a fresh snapshot after a transient reconnect", async () => {
-    const { store, transport, options, receive } = connectedSession();
-    act(() => options.onClose(new CloseEvent("close")));
-    expect(store.get(attachmentsAtom)).toEqual([]);
+    await act(async () => conn.open());
     expect(store.get(connectionAtom).state).toBe(ConnectionState.CONNECTING);
-    expect(transport.reconnect).toHaveBeenCalledOnce();
 
-    await act(async () => options.onOpen(new Event("open")));
-    receive({ op: "reconnected" });
-    expect(store.get(connectionAtom).state).toBe(ConnectionState.OPEN);
-    expect(store.get(agentAttachmentsAtom)).toEqual([]);
-
-    const refreshed = { ...agent, id: "a2", name: "Codex" };
-    receive({ op: "attachments", attachments: [refreshed] });
-    expect(store.get(agentAttachmentsAtom)).toEqual([refreshed]);
-    receive({ op: "attachments", attachments: [] });
-    expect(store.get(agentAttachmentsAtom)).toEqual([]);
-  });
-
-  it("keeps a fresh snapshot hidden until the session is ready", async () => {
-    const { store, options, receive } = connectedSession();
-    act(() => options.onClose(new CloseEvent("close")));
-    await act(async () => options.onOpen(new Event("open")));
-    receive({ op: "attachments", attachments: [agent] });
-    expect(store.get(attachmentsAtom)).toEqual([agent]);
-    expect(store.get(agentAttachmentsAtom)).toEqual([]);
-    receive({ op: "reconnected" });
-    expect(store.get(agentAttachmentsAtom)).toEqual([agent]);
-  });
-
-  it("invalidates an old snapshot when a new transport opens", async () => {
-    const { store, options } = connectedSession();
-    await act(async () => options.onOpen(new Event("open")));
-    expect(store.get(attachmentsAtom)).toEqual([]);
-    expect(store.get(agentAttachmentsAtom)).toEqual([]);
-  });
-});
-
-it.each([true, false])(
-  "keeps attachments only when kernel-ready resumes the session: %s",
-  (resumed) => {
-    const store = createStore();
-    const attachments: Attachment[] = [
-      {
-        id: "a1",
-        kind: "agent",
-        name: "Pi",
-        since: "2026-10-14T00:00:00Z",
-        notebook_id: "nb-test",
-        identity: "pi-thread",
-      },
-    ];
-    store.set(attachmentsAtom, attachments);
-    vi.mocked(createConnectionTransport).mockReturnValue(
-      makeTransport(WebSocket.OPEN),
-    );
-    vi.mocked(useRuntimeManager).mockReturnValue(makeRuntimeManager());
-    renderConnectionHook(store);
-    const options = getTransportHandlers();
     act(() =>
-      options.onMessage(
-        new MessageEvent("message", {
-          data: JSON.stringify({
-            op: "kernel-ready",
-            data: {
-              op: "kernel-ready",
-              cell_ids: [],
-              codes: [],
-              names: [],
-              configs: [],
-              layout: null,
-              resumed,
-              ui_values: {},
-              last_executed_code: {},
-              last_execution_time: {},
-              app_config: { width: "normal" },
-              kiosk: false,
-              capabilities: { terminal: false },
-              auto_instantiated: true,
-              consumer_capabilities: { edit: true, interact: true },
-            },
-          }),
-        }),
-      ),
+      conn.send({
+        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(attachmentsAtom)).toEqual(resumed ? attachments : []);
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.OPEN);
   },
 );
 
@@ -556,11 +298,10 @@ describe("connection notice", () => {
   beforeEach(() => vi.useFakeTimers());
   afterEach(() => vi.useRealTimers());
 
-  function renderNotice() {
+  async function renderNotice() {
     const store = createStore();
     store.set(connectionAtom, { state: ConnectionState.CONNECTING });
-    const transport = makeTransport(WebSocket.OPEN);
-    vi.mocked(createConnectionTransport).mockReturnValue(transport);
+    const fake = withTransport();
     vi.mocked(useRuntimeManager).mockReturnValue(makeRuntimeManager());
     const Connection = () => {
       const { reconnect } = useNotebookSession({
@@ -582,20 +323,17 @@ describe("connection notice", () => {
         </ErrorBoundary>
       </JotaiProvider>,
     );
-    const options = getTransportHandlers();
+    await started();
+    const conn = connection(fake);
+    // Messages arrive on an open connection.
+    act(() => conn.open());
     const send = (data: NotificationPayload["data"]) =>
-      act(() => {
-        options.onMessage(
-          new MessageEvent("message", {
-            data: JSON.stringify({ op: data.op, data }),
-          }),
-        );
-      });
-    return { store, transport, options, send };
+      act(() => conn.send(data));
+    return { store, fake, conn, send };
   }
 
-  it("keeps elapsed time across startup phases and leaves reconnection to the footer once cells are available", () => {
-    const { store, options, send } = renderNotice();
+  it("keeps elapsed time across startup phases and leaves reconnection to the footer once cells are available", async () => {
+    const { store, conn, send } = await renderNotice();
     send({
       op: "startup-progress",
       phase: "preparing-environment",
@@ -635,7 +373,7 @@ describe("connection notice", () => {
     expect(
       screen.queryByRole("region", { name: "Notebook startup" }),
     ).not.toBeInTheDocument();
-    act(() => options.onClose(new CloseEvent("close")));
+    await act(async () => conn.drop());
     act(() => vi.advanceTimersByTime(500));
     expect(store.get(connectionAtom)).toEqual({
       state: ConnectionState.CONNECTING,
@@ -646,8 +384,8 @@ describe("connection notice", () => {
     ).not.toBeInTheDocument();
   });
 
-  it("restores startup output before appending live chunks and resets it for a new attempt", () => {
-    const { store, send } = renderNotice();
+  it("restores startup output before appending live chunks and resets it for a new attempt", async () => {
+    const { store, send } = await renderNotice();
     const snapshot = {
       op: "startup-progress",
       phase: "starting-kernel",
@@ -673,7 +411,7 @@ describe("connection notice", () => {
   });
 
   it("restores completed startup output without putting a connected kernel back into startup", async () => {
-    const { store, options, send } = renderNotice();
+    const { store, conn, send } = await renderNotice();
     send({ op: "reconnected" });
     send({
       op: "startup-progress",
@@ -691,13 +429,15 @@ describe("connection notice", () => {
       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")));
+    // A new connection starts from the next session's authoritative snapshot.
+    await act(async () => conn.drop());
+    await act(async () => vi.advanceTimersByTime(2000));
+    await act(async () => conn.open());
     expect(store.get(startupProgressAtom)).toBeNull();
   });
 
-  it("does not flash a notice when startup finishes within the delay", () => {
-    const { send } = renderNotice();
+  it("does not flash a notice when startup finishes within the delay", async () => {
+    const { send } = await renderNotice();
     send({
       op: "startup-progress",
       phase: "preparing-environment",
@@ -725,16 +465,11 @@ describe("connection notice", () => {
   it.each(["preparing-environment", "starting-kernel"] as const)(
     "keeps a %s failure available until the user retries",
     async (phase) => {
-      const { store, transport, options, send } = renderNotice();
+      const { store, fake, conn, send } = await 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" }),
-        ),
-      );
+      await act(async () => conn.close("MARIMO_KERNEL_STARTUP_ERROR"));
       expect(screen.getByRole("status")).toHaveTextContent(
         "Kernel failed to start",
       );
@@ -745,11 +480,11 @@ describe("connection notice", () => {
       expect(screen.getByLabelText("Error details")).toHaveTextContent(error, {
         normalizeWhitespace: false,
       });
-      expect(transport.reconnect).not.toHaveBeenCalled();
+      expect(fake.attempts).toHaveLength(1);
       await act(async () =>
         fireEvent.click(screen.getByRole("button", { name: "Try again" })),
       );
-      expect(transport.reconnect).toHaveBeenCalledOnce();
+      expect(fake.attempts).toHaveLength(2);
       expect(store.get(kernelStartupErrorAtom)).toBeNull();
       expect(
         screen.queryByRole("button", { name: "Try again" }),
@@ -769,23 +504,14 @@ describe("connection notice", () => {
   );
 });
 
-it("replaces environment state from snapshots, then continues live progress", () => {
+it("replaces environment state from snapshots, then continues live progress", async () => {
   const store = createStore();
-  vi.mocked(createConnectionTransport).mockClear();
-  vi.mocked(createConnectionTransport).mockReturnValue(
-    makeTransport(WebSocket.OPEN),
-  );
+  const fake = withTransport();
   vi.mocked(useRuntimeManager).mockReturnValue(makeRuntimeManager());
   renderConnectionHook(store);
-  const options = getTransportHandlers();
+  await started();
   function receive(data: NotificationPayload["data"]) {
-    act(() =>
-      options?.onMessage(
-        new MessageEvent("message", {
-          data: JSON.stringify({ op: data.op, data }),
-        }),
-      ),
-    );
+    act(() => connection(fake).send(data));
   }
   receive({
     op: "environment-operation",