@marimo-team/frontend 0.25.2-dev66 → 0.25.2-dev89

package/src/core/network/requests-lazy.ts

@@ -7,7 +7,7 @@ import { memoizeLastValue } from "@/utils/once";
 import { waitForKernelToBeInstantiated } from "../kernel/state";
 import type { RuntimeManager } from "../runtime/runtime";
 import { store } from "../state/jotai";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { connectionAtom, waitForConnectionOpen } from "./connection";
 import type { EditRequests, RunRequests } from "./types";
 
@@ -159,7 +159,7 @@ export function createLazyRequests(
 ): AllRequests {
   // Memoize the init call, just once per runtime manager
   const initOnce = memoizeLastValue(async (runtimeManager: RuntimeManager) => {
-    store.set(connectionAtom, { state: WebSocketState.CONNECTING });
+    store.set(connectionAtom, { state: ConnectionState.CONNECTING });
     await runtimeManager.init();
   });
 

package/src/core/packages/__tests__/useSandboxController.test.tsx

@@ -17,7 +17,7 @@ import type {
 } from "@/core/network/types";
 import { filenameAtom } from "@/core/saving/file-state";
 import { store } from "@/core/state/jotai";
-import { WebSocketState } from "@/core/websocket/types";
+import { ConnectionState } from "@/core/websocket/types";
 import { HTTPError } from "@/utils/errors";
 import { packageDataVersionAtom } from "../package-data";
 import {
@@ -52,7 +52,7 @@ beforeEach(() => {
   store.set(sandboxAtom, null);
   store.set(sandboxSyncAtom, { kind: "succeeded" });
   store.set(sandboxActionsAtom, null);
-  store.set(connectionAtom, { state: WebSocketState.OPEN });
+  store.set(connectionAtom, { state: ConnectionState.OPEN });
   store.set(kernelStartupErrorAtom, null);
   store.set(filenameAtom, "notebook.py");
   store.set(packageDataVersionAtom, 0);

package/src/core/packages/useSandboxController.ts

@@ -8,7 +8,7 @@ import { useRequestClient } from "@/core/network/requests";
 import { useFilename } from "@/core/saving/filename";
 import { waitFor } from "@/core/state/jotai";
 import { isWasm } from "@/core/wasm/utils";
-import { WebSocketState } from "@/core/websocket/types";
+import { ConnectionState } from "@/core/websocket/types";
 import { HTTPError, prettyError } from "@/utils/errors";
 import { invalidatePackageData } from "./package-data";
 import {
@@ -67,7 +67,7 @@ export function useSandboxController(onReconnect: () => Promise<void>) {
     if (
       inFlight.current ||
       operation.kind === "running" ||
-      connection.state === WebSocketState.CONNECTING
+      connection.state === ConnectionState.CONNECTING
     ) {
       return false;
     }
@@ -91,10 +91,10 @@ export function useSandboxController(onReconnect: () => Promise<void>) {
         const status = await waitFor(
           connectionAtom,
           (value) =>
-            value.state === WebSocketState.OPEN ||
-            value.state === WebSocketState.CLOSED,
+            value.state === ConnectionState.OPEN ||
+            value.state === ConnectionState.CLOSED,
         );
-        if (status.state === WebSocketState.CLOSED) {
+        if (status.state === ConnectionState.CLOSED) {
           setOperation({ kind: "idle" });
           return false;
         }
@@ -177,7 +177,7 @@ export function useSandboxController(onReconnect: () => Promise<void>) {
     saving ||
     loading ||
     operation.kind === "running" ||
-    connection.state === WebSocketState.CONNECTING;
+    connection.state === ConnectionState.CONNECTING;
   const diagnostic =
     error ??
     (operation.kind === "failed"

package/src/core/runtime/__tests__/adapter.test.ts

@@ -6,7 +6,7 @@ import { islandsInitializedAtom } from "../../islands/state";
 import { kernelStateAtom } from "../../kernel/state";
 import { connectionAtom } from "../../network/connection";
 import { wasmInitStateAtom } from "../../wasm/state";
-import { WebSocketState } from "../../websocket/types";
+import { ConnectionState } from "../../websocket/types";
 import {
   canRunCellsAtom,
   islandsAdapter,
@@ -50,13 +50,13 @@ describe("wasmAdapter", () => {
 
 describe("remoteAdapter", () => {
   it.each([
-    [{ state: WebSocketState.OPEN }, { kind: "ready" }],
+    [{ state: ConnectionState.OPEN }, { kind: "ready" }],
     [
-      { state: WebSocketState.CONNECTING },
+      { state: ConnectionState.CONNECTING },
       { kind: "connecting", progress: { label: "Connecting…" } },
     ],
     [
-      { state: WebSocketState.NOT_STARTED },
+      { state: ConnectionState.NOT_STARTED },
       { kind: "connecting", progress: { label: "Not connected" } },
     ],
   ] as const)("maps %j to %j", (conn, expected) => {
@@ -68,7 +68,7 @@ describe("remoteAdapter", () => {
   it("surfaces the close reason when closed", () => {
     const store = createStore();
     store.set(connectionAtom, {
-      state: WebSocketState.CLOSED,
+      state: ConnectionState.CLOSED,
       code: "KERNEL_DISCONNECTED",
       reason: "Kernel went away",
     });
@@ -125,7 +125,7 @@ describe("canRunCellsAtom", () => {
   it("is false on a remote adapter until kernel acks", () => {
     const store = createStore();
     // Default adapter in test env is remote.
-    store.set(connectionAtom, { state: WebSocketState.OPEN });
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
     expect(store.get(canRunCellsAtom)).toBe(false);
 
     store.set(kernelStateAtom, { isInstantiated: true, error: null });

package/src/core/runtime/adapter.ts

@@ -8,7 +8,7 @@ import { connectionAtom } from "../network/connection";
 import { isStaticNotebook } from "../static/static-state";
 import { wasmInitStateAtom } from "../wasm/state";
 import { isWasm } from "../wasm/utils";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 
 export type RuntimeKind = "wasm" | "remote" | "static" | "islands";
 
@@ -76,19 +76,19 @@ export const wasmAdapter: RuntimeAdapter = {
 const remoteStateAtom = atom<AdapterState>((get) => {
   const conn = get(connectionAtom);
   switch (conn.state) {
-    case WebSocketState.OPEN:
+    case ConnectionState.OPEN:
       return { kind: "ready" };
-    case WebSocketState.CONNECTING:
+    case ConnectionState.CONNECTING:
       return { kind: "connecting", progress: { label: "Connecting…" } };
-    case WebSocketState.NOT_STARTED:
+    case ConnectionState.NOT_STARTED:
       return { kind: "connecting", progress: { label: "Not connected" } };
-    case WebSocketState.CLOSING:
-    case WebSocketState.CLOSED:
+    case ConnectionState.CLOSING:
+    case ConnectionState.CLOSED:
       return {
         kind: "failed",
         error: {
           message:
-            conn.state === WebSocketState.CLOSED
+            conn.state === ConnectionState.CLOSED
               ? conn.reason
               : "Disconnecting",
           errorKind: "runtime",

package/src/core/runtime/config.ts

@@ -5,7 +5,7 @@ import { Logger } from "@/utils/Logger";
 import { connectionAtom } from "../network/connection";
 import { store } from "../state/jotai";
 import { isAppNotStarted } from "../websocket/connection-utils";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { RuntimeManager } from "./runtime";
 import type { RuntimeConfig } from "./types";
 
@@ -36,7 +36,7 @@ export function useConnectToRuntime(): () => Promise<void> {
   const [connection, setConnection] = useAtom(connectionAtom);
   return useEvent(async () => {
     if (isAppNotStarted(connection.state)) {
-      setConnection({ state: WebSocketState.CONNECTING });
+      setConnection({ state: ConnectionState.CONNECTING });
       await runtimeManager.init();
     } else {
       Logger.log("Runtime already started or starting...");

package/src/core/saving/filename.ts

@@ -9,7 +9,7 @@ import { getAppConfig } from "../config/config";
 import { KnownQueryParams } from "../constants";
 import { connectionAtom } from "../network/connection";
 import { useRequestClient } from "../network/requests";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { filenameAtom } from "./file-state";
 
 export function useFilename() {
@@ -24,7 +24,7 @@ export function useUpdateFilename() {
 
   const handleFilenameChange = useEvent(async (name: string) => {
     const appConfig = getAppConfig();
-    if (connection.state !== WebSocketState.OPEN) {
+    if (connection.state !== ConnectionState.OPEN) {
       openAlert("Failed to save notebook: not connected to a kernel.");
       return null;
     }

package/src/core/saving/save-component.tsx

@@ -31,7 +31,7 @@ import { layoutStateAtom } from "../layout/state";
 import { kioskModeAtom } from "../mode";
 import { connectionAtom } from "../network/connection";
 import { useRequestClient } from "../network/requests";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 import { filenameAtom } from "./file-state";
 import { useFilename, useUpdateFilename } from "./filename";
 import { lastSavedNotebookAtom, needsSaveAtom } from "./state";
@@ -55,7 +55,7 @@ export function enqueueNotebookSave<T>(save: () => Promise<T>): Promise<T> {
 export const SaveComponent = ({ kioskMode }: SaveNotebookProps) => {
   const filename = useFilename();
   const needsSave = useAtomValue(needsSaveAtom);
-  const closed = useAtomValue(connectionAtom).state === WebSocketState.CLOSED;
+  const closed = useAtomValue(connectionAtom).state === ConnectionState.CLOSED;
   const { saveOrNameNotebook, saveIfNotebookIsPersistent } = useSaveNotebook();
   useAutoSaveNotebook({ onSave: saveIfNotebookIsPersistent, kioskMode });
 
@@ -120,7 +120,7 @@ export function useSaveNotebook() {
       }
 
       // Don't save if we are not connected to a kernel
-      if (connection.state !== WebSocketState.OPEN) {
+      if (connection.state !== ConnectionState.OPEN) {
         openAlert("Failed to save notebook: not connected to a kernel.");
         return;
       }
@@ -168,7 +168,7 @@ export function useSaveNotebook() {
     const connection = store.get(connectionAtom);
     if (
       isNamedPersistentFile(filename) &&
-      connection.state === WebSocketState.OPEN
+      connection.state === ConnectionState.OPEN
     ) {
       saveNotebook(filename, userInitiated);
     }
@@ -191,7 +191,7 @@ export function useSaveNotebook() {
     // Filename does not exist and we are connected to a kernel
     if (
       !isNamedPersistentFile(filename) &&
-      connection.state !== WebSocketState.CLOSED
+      connection.state !== ConnectionState.CLOSED
     ) {
       openModal(<SaveDialog onClose={closeModal} onSave={handleSaveDialog} />);
     }

package/src/core/saving/useAutoSave.ts

@@ -2,7 +2,7 @@
 import { useEffect, useRef } from "react";
 import type { UserConfig } from "../config/config-schema";
 import type { CellConfig } from "../network/types";
-import { type ConnectionStatus, WebSocketState } from "../websocket/types";
+import { type ConnectionStatus, ConnectionState } from "../websocket/types";
 
 export function useAutoSave(opts: {
   codes: string[];
@@ -43,7 +43,7 @@ export function useAutoSave(opts: {
         clearTimeout(autosaveTimeoutId.current);
       }
 
-      if (needsSave && connStatus.state === WebSocketState.OPEN) {
+      if (needsSave && connStatus.state === ConnectionState.OPEN) {
         autosaveTimeoutId.current = setTimeout(onSave, config.autosave_delay);
       }
     }

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

@@ -52,7 +52,7 @@ import { useRuntimeManager } from "@/core/runtime/config";
 import { initialRunCompletedAtom } from "../../kernel/state";
 import { connectionAtom, startupProgressAtom } from "../../network/connection";
 import type { SessionId } from "../../kernel/session";
-import { WebSocketClosedReason, WebSocketState } from "../types";
+import { WebSocketClosedReason, ConnectionState } from "../types";
 import type { IConnectionTransport } from "../transports/transport";
 import { useMarimoKernelConnection } from "../useMarimoKernelConnection";
 import { useConnectionTransport } from "../useWebSocket";
@@ -118,7 +118,7 @@ describe("useMarimoKernelConnection.reconnect()", () => {
     isHealthy = vi.fn<() => Promise<boolean>>().mockResolvedValue(true);
     store = createStore();
     store.set(connectionAtom, {
-      state: WebSocketState.CLOSED,
+      state: ConnectionState.CLOSED,
       code: WebSocketClosedReason.KERNEL_DISCONNECTED,
       reason: "kernel not found",
     });
@@ -163,7 +163,7 @@ describe("useMarimoKernelConnection.reconnect()", () => {
     expect(isHealthy).toHaveBeenCalledOnce();
     expect(transport.reconnect).toHaveBeenCalledOnce();
     expect(store.get(connectionAtom)).toEqual({
-      state: WebSocketState.CONNECTING,
+      state: ConnectionState.CONNECTING,
     });
   });
 
@@ -176,7 +176,7 @@ describe("useMarimoKernelConnection.reconnect()", () => {
     expect(isHealthy).toHaveBeenCalledOnce();
     expect(transport.reconnect).not.toHaveBeenCalled();
     expect(store.get(connectionAtom)).toEqual({
-      state: WebSocketState.CLOSED,
+      state: ConnectionState.CLOSED,
       code: WebSocketClosedReason.KERNEL_DISCONNECTED,
       reason: "kernel not found",
     });
@@ -215,7 +215,7 @@ it.each(["kernel-ready", "reconnected"])(
   "waits for %s before marking the session connected",
   async (op) => {
     const store = createStore();
-    store.set(connectionAtom, { state: WebSocketState.CONNECTING });
+    store.set(connectionAtom, { state: ConnectionState.CONNECTING });
     vi.mocked(useConnectionTransport).mockClear();
     vi.mocked(useConnectionTransport).mockReturnValue(
       makeTransport(WebSocket.OPEN),
@@ -229,7 +229,7 @@ it.each(["kernel-ready", "reconnected"])(
     await act(async () => {
       await options.onOpen(new Event("open"));
     });
-    expect(store.get(connectionAtom).state).toBe(WebSocketState.CONNECTING);
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.CONNECTING);
 
     act(() => {
       options.onMessage(
@@ -257,7 +257,7 @@ it.each(["kernel-ready", "reconnected"])(
         }),
       );
     });
-    expect(store.get(connectionAtom).state).toBe(WebSocketState.OPEN);
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.OPEN);
   },
 );
 
@@ -267,7 +267,7 @@ describe("connection notice", () => {
 
   function renderNotice() {
     const store = createStore();
-    store.set(connectionAtom, { state: WebSocketState.CONNECTING });
+    store.set(connectionAtom, { state: ConnectionState.CONNECTING });
     const transport = makeTransport(WebSocket.OPEN);
     vi.mocked(useConnectionTransport).mockReturnValue(transport);
     vi.mocked(useRuntimeManager).mockReturnValue(
@@ -322,14 +322,6 @@ describe("connection notice", () => {
     );
     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",
@@ -338,6 +330,18 @@ describe("connection notice", () => {
     });
     expect(screen.getByRole("status")).toHaveTextContent("Starting kernel");
     expect(screen.getByText("Elapsed 35s")).toBeInTheDocument();
+    act(() =>
+      store.set(
+        notebookAtom,
+        MockNotebook.notebookState({
+          cellData: { [cellId("test")]: { code: "answer = 42" } },
+        }),
+      ),
+    );
+    expect(
+      screen.getByRole("button", { name: "Starting kernel… Open Packages" }),
+    ).toBeVisible();
+    expect(screen.queryByText(/Elapsed/)).not.toBeInTheDocument();
     send({ op: "reconnected" });
     expect(
       screen.queryByRole("region", { name: "Notebook startup" }),
@@ -345,7 +349,7 @@ describe("connection notice", () => {
     act(() => options.onClose(new CloseEvent("close")));
     act(() => vi.advanceTimersByTime(500));
     expect(store.get(connectionAtom)).toEqual({
-      state: WebSocketState.CONNECTING,
+      state: ConnectionState.CONNECTING,
       phase: "reconnecting",
     });
     expect(
@@ -388,7 +392,7 @@ describe("connection notice", () => {
       logs: "Kernel startup output\n",
       log_mode: "replace",
     });
-    expect(store.get(connectionAtom)).toEqual({ state: WebSocketState.OPEN });
+    expect(store.get(connectionAtom)).toEqual({ state: ConnectionState.OPEN });
     expect(store.get(startupProgressAtom)).toEqual({
       phase: "starting-kernel",
       logs: "Kernel startup output\n",
@@ -429,12 +433,9 @@ describe("connection notice", () => {
     ).not.toBeInTheDocument();
   });
 
-  it.each([
-    ["preparing-environment", "Sandbox setup failed"],
-    ["starting-kernel", "Kernel failed to start"],
-  ] as const)(
+  it.each(["preparing-environment", "starting-kernel"] as const)(
     "keeps a %s failure available until the user retries",
-    async (phase, title) => {
+    async (phase) => {
       const { store, transport, options, send } = renderNotice();
       send({ op: "startup-progress", phase, logs: "", log_mode: "replace" });
       const error = "A full diagnostic\nwith <stderr> details";
@@ -445,9 +446,13 @@ describe("connection notice", () => {
           new CloseEvent("close", { reason: "MARIMO_KERNEL_STARTUP_ERROR" }),
         ),
       );
-      expect(screen.getByRole("status")).toHaveTextContent(title);
+      expect(screen.getByRole("status")).toHaveTextContent(
+        "Kernel failed to start",
+      );
       act(() => vi.advanceTimersByTime(30_000));
-      expect(screen.getByRole("status")).toHaveTextContent(title);
+      expect(screen.getByRole("status")).toHaveTextContent(
+        "Kernel failed to start",
+      );
       expect(screen.getByLabelText("Error details")).toHaveTextContent(error, {
         normalizeWhitespace: false,
       });

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

@@ -2,7 +2,7 @@
 
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { Logger } from "@/utils/Logger";
-import { WebSocketClosedReason, WebSocketState } from "../types";
+import { WebSocketClosedReason, ConnectionState } from "../types";
 import { classifyCloseEvent } from "../useMarimoKernelConnection";
 
 function classify(reason: string | undefined) {
@@ -14,7 +14,7 @@ describe("classifyCloseEvent", () => {
     it("retries on empty/undefined reason", () => {
       const decision = classify(undefined);
       expect(decision.kind).toBe("retry");
-      expect(decision.status).toEqual({ state: WebSocketState.CONNECTING });
+      expect(decision.status).toEqual({ state: ConnectionState.CONNECTING });
     });
 
     it("treats unknown reason strings as transient and logs a warning", () => {
@@ -44,7 +44,7 @@ describe("classifyCloseEvent", () => {
       const decision = classify(reason);
       expect(decision.kind).toBe("terminal");
       expect(decision.status).toMatchObject({
-        state: WebSocketState.CLOSED,
+        state: ConnectionState.CLOSED,
         code: WebSocketClosedReason.KERNEL_DISCONNECTED,
       });
       expect(decision).toMatchObject({
@@ -57,7 +57,7 @@ describe("classifyCloseEvent", () => {
       const decision = classify("MARIMO_KERNEL_STARTUP_ERROR");
       expect(decision.kind).toBe("terminal");
       expect(decision.status).toMatchObject({
-        state: WebSocketState.CLOSED,
+        state: ConnectionState.CLOSED,
         code: WebSocketClosedReason.KERNEL_STARTUP_ERROR,
       });
       expect(decision).toMatchObject({
@@ -72,7 +72,7 @@ describe("classifyCloseEvent", () => {
       const decision = classify("MARIMO_TRANSPORT_EXHAUSTED");
       expect(decision.kind).toBe("gave-up");
       expect(decision.status).toEqual({
-        state: WebSocketState.CLOSED,
+        state: ConnectionState.CLOSED,
         code: WebSocketClosedReason.KERNEL_DISCONNECTED,
         reason: "kernel not found",
       });

package/src/core/websocket/connection-utils.ts

@@ -1,66 +1,66 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-import { WebSocketState } from "./types";
+import { ConnectionState } from "./types";
 
 /**
  * Check if the app is in a closed/disconnected state
  */
-export function isAppClosed(state: WebSocketState): boolean {
-  return state === WebSocketState.CLOSED;
+export function isAppClosed(state: ConnectionState): boolean {
+  return state === ConnectionState.CLOSED;
 }
 
 /**
  * Check if the app is in a connecting state
  */
-export function isAppConnecting(state: WebSocketState): boolean {
-  return state === WebSocketState.CONNECTING;
+export function isAppConnecting(state: ConnectionState): boolean {
+  return state === ConnectionState.CONNECTING;
 }
 
 /**
  * Check if the app is in an open/connected state
  */
-export function isAppConnected(state: WebSocketState): boolean {
-  return state === WebSocketState.OPEN;
+export function isAppConnected(state: ConnectionState): boolean {
+  return state === ConnectionState.OPEN;
 }
 
 /**
  * Check if the app is in a closing state
  */
-export function isAppClosing(state: WebSocketState): boolean {
-  return state === WebSocketState.CLOSING;
+export function isAppClosing(state: ConnectionState): boolean {
+  return state === ConnectionState.CLOSING;
 }
 
 /**
  * Check if the app is in a not started state
  */
-export function isAppNotStarted(state: WebSocketState): boolean {
-  return state === WebSocketState.NOT_STARTED;
+export function isAppNotStarted(state: ConnectionState): boolean {
+  return state === ConnectionState.NOT_STARTED;
 }
 
 /**
  * Check if the app is in a state where user interactions should be disabled
  */
-export function isAppInteractionDisabled(state: WebSocketState): boolean {
+export function isAppInteractionDisabled(state: ConnectionState): boolean {
   return (
-    state === WebSocketState.CLOSED ||
-    state === WebSocketState.CLOSING ||
-    state === WebSocketState.CONNECTING
+    state === ConnectionState.CLOSED ||
+    state === ConnectionState.CLOSING ||
+    state === ConnectionState.CONNECTING
   );
 }
 
 /**
  * Get a human-readable tooltip message for the connection state
  */
-export function getConnectionTooltip(state: WebSocketState): string {
+export function getConnectionTooltip(state: ConnectionState): string {
   switch (state) {
-    case WebSocketState.CLOSED:
+    case ConnectionState.CLOSED:
       return "App disconnected";
-    case WebSocketState.CONNECTING:
+    case ConnectionState.CONNECTING:
       return "Connecting to a runtime ...";
-    case WebSocketState.CLOSING:
+    case ConnectionState.CLOSING:
       return "App disconnecting...";
-    case WebSocketState.OPEN:
+    case ConnectionState.OPEN:
       return "";
-    case WebSocketState.NOT_STARTED:
+    case ConnectionState.NOT_STARTED:
       return "Click to connect to a runtime";
     default:
       return "";

package/src/core/websocket/types.ts

@@ -6,8 +6,7 @@ export type ConnectionPhase =
   | NotificationMessageData<"startup-progress">["phase"]
   | "reconnecting";
 
-// TODO: rename to ConnectionState
-export const WebSocketState = {
+export const ConnectionState = {
   NOT_STARTED: "NOT_STARTED",
   CONNECTING: "CONNECTING",
   OPEN: "OPEN",
@@ -15,8 +14,8 @@ export const WebSocketState = {
   CLOSED: "CLOSED",
 } as const;
 
-export type WebSocketState =
-  (typeof WebSocketState)[keyof typeof WebSocketState];
+export type ConnectionState =
+  (typeof ConnectionState)[keyof typeof ConnectionState];
 
 export const WebSocketClosedReason = {
   KERNEL_DISCONNECTED: "KERNEL_DISCONNECTED",
@@ -28,7 +27,7 @@ export type WebSocketClosedReason =
 
 export type ConnectionStatus =
   | {
-      state: typeof WebSocketState.CLOSED;
+      state: typeof ConnectionState.CLOSED;
       code: WebSocketClosedReason;
       /**
        * Human-readable reason for closing the connection.
@@ -37,12 +36,12 @@ export type ConnectionStatus =
       phase?: ConnectionPhase;
     }
   | {
-      state: typeof WebSocketState.CONNECTING;
+      state: typeof ConnectionState.CONNECTING;
       phase?: ConnectionPhase;
     }
   | {
       state:
-        | typeof WebSocketState.OPEN
-        | typeof WebSocketState.CLOSING
-        | typeof WebSocketState.NOT_STARTED;
+        | typeof ConnectionState.OPEN
+        | typeof ConnectionState.CLOSING
+        | typeof ConnectionState.NOT_STARTED;
     };