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

package/src/core/codemirror/lsp/__tests__/notebook-lsp.test.ts

@@ -359,11 +359,111 @@ describe("NotebookLanguageServerClient", () => {
       return undefined;
     });
 
-    notebookClient = new NotebookLanguageServerClient(mockClient, {}, () => ({
-      [Cells.cell1]: new EditorView({ doc: "# this is a comment" }),
-      [Cells.cell2]: new EditorView({ doc: "import math\nimport numpy" }),
-      [Cells.cell3]: new EditorView({ doc: "print(math.sqrt(4))" }),
-    }));
+    notebookClient = new NotebookLanguageServerClient(
+      mockClient,
+      {},
+      () => ({}),
+    );
+  });
+
+  describe("live editor snapshots", () => {
+    function createEditor(code: string) {
+      return new EditorView({
+        doc: code,
+        extensions: [
+          languageAdapterState.init(() => new PythonLanguageAdapter()),
+          languageMetadataField.init(() => ({})),
+        ],
+      });
+    }
+
+    it("sends edits and their removal without invalidating the notebook atom", async () => {
+      const cachedCodes = store.get(topologicalCodesAtom);
+      const editor = createEditor("print(math.sqrt(4))");
+      replaceNotebookEditors(notebookClient, () => ({ [Cells.cell3]: editor }));
+      const uri = CellDocumentUri.of(Cells.cell3);
+      try {
+        await notebookClient.textDocumentDidOpen({
+          textDocument: {
+            uri,
+            languageId: "python",
+            version: 1,
+            text: editor.state.doc.toString(),
+          },
+        });
+        for (const [index, code] of [
+          "math.missing()",
+          "print(math.sqrt(4))",
+        ].entries()) {
+          editor.dispatch({
+            changes: { from: 0, to: editor.state.doc.length, insert: code },
+          });
+          await notebookClient.textDocumentDidChange({
+            textDocument: { uri, version: index + 2 },
+            contentChanges: [{ text: code }],
+          });
+          expect(store.get(topologicalCodesAtom)).toEqual(cachedCodes);
+          expect(mockClient.textDocumentDidChange).toHaveBeenNthCalledWith(
+            index + 1,
+            {
+              textDocument: {
+                uri: notebookClient.documentUri,
+                version: index + 2,
+              },
+              contentChanges: [
+                {
+                  text: `# this is a comment\nimport math\nimport numpy\n${code}`,
+                },
+              ],
+            },
+          );
+        }
+      } finally {
+        editor.destroy();
+      }
+    });
+
+    it("syncs pending edits before completion and uses their updated line offsets", async () => {
+      const editor = createEditor("import math\nimport numpy");
+      replaceNotebookEditors(notebookClient, () => ({ [Cells.cell2]: editor }));
+      try {
+        await notebookClient.textDocumentDidOpen({
+          textDocument: {
+            uri: CellDocumentUri.of(Cells.cell2),
+            languageId: "python",
+            version: 1,
+            text: editor.state.doc.toString(),
+          },
+        });
+        editor.dispatch({
+          changes: { from: editor.state.doc.length, insert: "\nextra = 1" },
+        });
+        mockClient.textDocumentCompletion.mockImplementation(async () => {
+          expect(mockClient.textDocumentDidChange).toHaveBeenCalledWith({
+            textDocument: { uri: notebookClient.documentUri, version: 2 },
+            contentChanges: [
+              {
+                text: "# this is a comment\nimport math\nimport numpy\nextra = 1\nprint(math.sqrt(4))",
+              },
+            ],
+          });
+          return null;
+        });
+        const params: LSP.CompletionParams = {
+          textDocument: { uri: CellDocumentUri.of(Cells.cell3) },
+          position: { line: 0, character: 11 },
+        };
+        await notebookClient.textDocumentCompletion(params);
+        expect(mockClient.textDocumentCompletion).toHaveBeenCalledWith({
+          textDocument: { uri: notebookClient.documentUri },
+          position: { line: 4, character: 11 },
+        });
+        await notebookClient.textDocumentCompletion(params);
+        expect(mockClient.textDocumentDidChange).toHaveBeenCalledTimes(1);
+      } finally {
+        editor.destroy();
+      }
+    });
   });
 
   describe("document lifecycle", () => {
@@ -1893,6 +1993,7 @@ describe("NotebookLanguageServerClient", () => {
       const isolatedNotebookClient = new NotebookLanguageServerClient(
         isolatedClient,
         {},
+        () => ({}),
       );
       await isolatedNotebookClient.sync();
       isolatedNotebookClient.patchProcessNotification();

package/src/core/codemirror/lsp/notebook-lsp.ts

@@ -343,7 +343,21 @@ export class NotebookLanguageServerClient implements ILanguageServerClient {
   }
 
   private getNotebookCode() {
-    return store.get(topologicalCodesAtom);
+    const { cellIds, codes } = store.get(topologicalCodesAtom);
+    const editors = this.getNotebookEditors();
+    // EditorView edits do not invalidate the cached notebook atom.
+    return {
+      cellIds,
+      codes: Objects.fromEntries(
+        cellIds.map((id) => {
+          const editor = editors[id];
+          return [
+            id,
+            editor ? getEditorCodeAsPython(editor) : (codes[id] ?? ""),
+          ];
+        }),
+      ),
+    };
   }
 
   private assertCellDocumentUri(
@@ -870,7 +884,7 @@ export class NotebookLanguageServerClient implements ILanguageServerClient {
   }
 
   public async textDocumentCompletion(params: LSP.CompletionParams) {
-    const { lens } = this.snapshotter.getLatestSnapshot();
+    const { lens } = await this.sync();
 
     // Check if URI is valid
     if (!CellDocumentUri.is(params.textDocument.uri)) {

package/src/core/codemirror/readonly/__tests__/extension.test.ts

@@ -4,12 +4,12 @@ import { EditorState } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
 import { createStore } from "jotai";
 import { describe, expect, it } from "vitest";
-import { WebSocketState } from "@/core/websocket/types";
+import { ConnectionState } from "@/core/websocket/types";
 import { connectionAtom } from "../../../network/connection";
 import { dynamicReadonly, isEditorReadonly } from "../extension";
 
 function makeStoreWithConnection(
-  state: typeof WebSocketState.CONNECTING | typeof WebSocketState.OPEN,
+  state: typeof ConnectionState.CONNECTING | typeof ConnectionState.OPEN,
 ) {
   const store = createStore();
   store.set(connectionAtom, { state });
@@ -18,7 +18,7 @@ function makeStoreWithConnection(
 
 describe("dynamicReadonly", () => {
   it("should be readonly when connection is not OPEN", () => {
-    const store = makeStoreWithConnection(WebSocketState.CONNECTING);
+    const store = makeStoreWithConnection(ConnectionState.CONNECTING);
     const state = EditorState.create({
       doc: "test",
       extensions: [dynamicReadonly(store)],
@@ -27,7 +27,7 @@ describe("dynamicReadonly", () => {
   });
 
   it("should be editable when connection is OPEN", async () => {
-    const store = makeStoreWithConnection(WebSocketState.OPEN);
+    const store = makeStoreWithConnection(ConnectionState.OPEN);
     const state = EditorState.create({
       doc: "test",
       extensions: [dynamicReadonly(store)],
@@ -37,7 +37,7 @@ describe("dynamicReadonly", () => {
   });
 
   it("should toggle readonly when connection state changes", () => {
-    const store = makeStoreWithConnection(WebSocketState.CONNECTING);
+    const store = makeStoreWithConnection(ConnectionState.CONNECTING);
     const state = EditorState.create({
       doc: "test",
       extensions: [dynamicReadonly(store)],
@@ -45,7 +45,7 @@ describe("dynamicReadonly", () => {
     const view = new EditorView({ state });
     expect(isEditorReadonly(state)).toBe(true);
     // Simulate connection opening
-    store.set(connectionAtom, { state: WebSocketState.OPEN });
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
     // The extension uses a plugin to update the state, so we need to create a view to trigger it
     view.requestMeasure();
     // The state should now be editable

package/src/core/codemirror/readonly/extension.ts

@@ -7,7 +7,7 @@ import {
   isAppConnecting,
 } from "@/core/websocket/connection-utils";
 import { connectionAtom } from "../../network/connection";
-import { WebSocketState } from "../../websocket/types";
+import { ConnectionState } from "../../websocket/types";
 
 /**
  * State effect for updating readonly status based on connection
@@ -111,7 +111,7 @@ export function dynamicReadonly(store: ReturnType<typeof createStore>) {
     // Subscribe to connectionAtom and manage listeners
     const unsubscribe = store.sub(connectionAtom, () => {
       const connection = store.get(connectionAtom);
-      if (connection.state === WebSocketState.CONNECTING) {
+      if (connection.state === ConnectionState.CONNECTING) {
         attachListeners();
       } else {
         detachListeners();

package/src/core/config/pair.ts

@@ -7,7 +7,6 @@ export const pairPreviewSchema = z.object({
   command: z.string(),
   templates: z.object({
     prompt: z.string(),
-    file: z.string(),
     session: z.string(),
     token_file: z.string(),
     token: z.string(),

package/src/core/datasets/__tests__/data-source-discovery.test.ts

@@ -2,7 +2,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { connectionAtom } from "@/core/network/connection";
 import { store } from "@/core/state/jotai";
-import { WebSocketState } from "@/core/websocket/types";
+import { ConnectionState } from "@/core/websocket/types";
 import {
   fetchDataSourceDiscovery,
   invalidateDataSourceDiscovery,
@@ -30,7 +30,7 @@ describe("fetchDataSourceDiscovery", () => {
   beforeEach(() => {
     // Discovery waits for the session's websocket connection to be open
     // before requesting, so it doesn't race a still-connecting session.
-    store.set(connectionAtom, { state: WebSocketState.OPEN });
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
   });
 
   afterEach(() => {

package/src/core/edit-app.tsx

@@ -197,7 +197,11 @@ export const EditApp: React.FC<AppProps> = ({
           )}
         </div>
 
-        <ConnectionNotice appConfig={appConfig} onRetry={reconnect} />
+        <ConnectionNotice
+          appConfig={appConfig}
+          onRetry={reconnect}
+          canOpenPackages={!hideControls}
+        />
 
         {/* Don't render until we have a single cell. NotStartedConnectionAlert
             still covers the "no remote runtime started" prompt. */}

package/src/core/export/hooks.ts

@@ -16,7 +16,7 @@ import { connectionAtom } from "../network/connection";
 import { useRequestClient } from "../network/requests";
 import type { UpdateCellOutputsRequest } from "../network/types";
 import { VirtualFileTracker } from "../static/virtual-file-tracker";
-import { WebSocketState } from "../websocket/types";
+import { ConnectionState } from "../websocket/types";
 
 const DELAY = 5000; // 5 seconds;
 
@@ -28,7 +28,7 @@ export function useAutoExport() {
   const htmlEnabled = appConfig.auto_download.includes("html");
   const ipynbEnabled = appConfig.auto_download.includes("ipynb");
 
-  const isConnected = state === WebSocketState.OPEN;
+  const isConnected = state === ConnectionState.OPEN;
   const markdownDisabled = !markdownEnabled || !isConnected;
   const htmlDisabled = !htmlEnabled || !isConnected;
   const ipynbDisabled = !ipynbEnabled || !isConnected;

package/src/core/islands/bootstrap.ts

@@ -283,6 +283,7 @@ function handleMessage(
         return;
 
       case "consumer-capabilities":
+      case "execution":
         return;
       default:
         logNever(msg);

package/src/core/kernel/session.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { init } from "@paralleldrive/cuid2";
+import { atom } from "jotai";
 import { Logger } from "@/utils/Logger";
 import type { TypedString } from "@/utils/typed";
 import { updateQueryParams } from "@/utils/urls";
@@ -9,6 +10,14 @@ import { store } from "../state/jotai";
 
 export type SessionId = TypedString<"SessionId">;
 
+/**
+ * Server-owned identity of the notebook Session. It survives browser reloads
+ * and reconnects and ends with the Session.
+ */
+export type StableSessionId = TypedString<"StableSessionId">;
+
+export const stableSessionIdAtom = atom<StableSessionId | null>(null);
+
 const createId = init({ length: 6 });
 
 export function generateSessionId(): SessionId {

package/src/core/network/__tests__/connection.test.ts

@@ -3,7 +3,7 @@
 import { afterEach, describe, expect, it } from "vitest";
 import { initialModeAtom } from "@/core/mode";
 import { store } from "@/core/state/jotai";
-import { WebSocketState } from "../../websocket/types";
+import { ConnectionState } from "../../websocket/types";
 import { connectionAtom, waitForConnectionOpenIfNotebook } from "../connection";
 
 const NEVER = Symbol("never");
@@ -20,7 +20,7 @@ function settledOrNever(promise: Promise<unknown>) {
 
 describe("waitForConnectionOpenIfNotebook", () => {
   afterEach(() => {
-    store.set(connectionAtom, { state: WebSocketState.NOT_STARTED });
+    store.set(connectionAtom, { state: ConnectionState.NOT_STARTED });
     store.set(initialModeAtom, undefined);
   });
 
@@ -39,7 +39,7 @@ describe("waitForConnectionOpenIfNotebook", () => {
     const promise = waitForConnectionOpenIfNotebook();
     await expect(settledOrNever(promise)).resolves.toBe(NEVER);
 
-    store.set(connectionAtom, { state: WebSocketState.OPEN });
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
     await expect(settledOrNever(promise)).resolves.not.toBe(NEVER);
   });
 });

package/src/core/network/connection-notice.ts

@@ -5,7 +5,7 @@ import { sandboxAtom, sandboxSyncAtom } from "@/core/packages/sandbox-state";
 import {
   type ConnectionPhase,
   WebSocketClosedReason,
-  WebSocketState,
+  ConnectionState,
 } from "@/core/websocket/types";
 import { connectionAtom } from "./connection";
 
@@ -37,7 +37,7 @@ export const connectionNoticeAtom = atom<ConnectionNotice | null>((get) => {
   if (
     sandbox &&
     (syncing || syncError !== null) &&
-    connection.state === WebSocketState.OPEN
+    connection.state === ConnectionState.OPEN
   ) {
     return {
       kind: "sync",
@@ -56,7 +56,7 @@ export const connectionNoticeAtom = atom<ConnectionNotice | null>((get) => {
       error: syncError,
     };
   }
-  if (connection.state === WebSocketState.CONNECTING) {
+  if (connection.state === ConnectionState.CONNECTING) {
     const messages = {
       "preparing-environment": {
         title: "Preparing environment…",
@@ -88,11 +88,11 @@ export const connectionNoticeAtom = atom<ConnectionNotice | null>((get) => {
       error: null,
     };
   }
-  if (connection.state === WebSocketState.CLOSED) {
+  if (connection.state === ConnectionState.CLOSED) {
     const startupFailed =
       connection.code === WebSocketClosedReason.KERNEL_STARTUP_ERROR;
     const environmentFailed =
-      startupFailed && connection.phase === "preparing-environment";
+      sandbox && startupFailed && connection.phase === "preparing-environment";
     return {
       kind: startupFailed ? "startup" : "connection",
       phase: connection.phase,

package/src/core/network/connection.ts

@@ -4,14 +4,14 @@ import { atomWithReducer } from "jotai/utils";
 import type { NotificationMessageData } from "../kernel/messages";
 import { isNotebookPage } from "../mode";
 import { waitFor } from "../state/jotai";
-import { type ConnectionStatus, WebSocketState } from "../websocket/types";
+import { type ConnectionStatus, ConnectionState } from "../websocket/types";
 
 /**
  * Atom for storing the connection status.
  * Initialized to NOT_STARTED.
  */
 export const connectionAtom = atom<ConnectionStatus>({
-  state: WebSocketState.NOT_STARTED,
+  state: ConnectionState.NOT_STARTED,
 });
 
 type StartupProgress = NotificationMessageData<"startup-progress">;
@@ -33,7 +33,7 @@ export const startupProgressAtom = atomWithReducer<
 
 export function waitForConnectionOpen() {
   return waitFor(connectionAtom, (value) => {
-    return value.state === WebSocketState.OPEN;
+    return value.state === ConnectionState.OPEN;
   });
 }
 
@@ -53,28 +53,28 @@ export function waitForConnectionOpenIfNotebook() {
 
 export const isConnectingAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.CONNECTING;
+  return connection.state === ConnectionState.CONNECTING;
 });
 
 export const isConnectedAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.OPEN;
+  return connection.state === ConnectionState.OPEN;
 });
 
 export const canInteractWithAppAtom = atom((get) => {
   const connection = get(connectionAtom);
   return (
-    connection.state === WebSocketState.OPEN ||
-    connection.state === WebSocketState.NOT_STARTED
+    connection.state === ConnectionState.OPEN ||
+    connection.state === ConnectionState.NOT_STARTED
   );
 });
 
 export const isClosedAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.CLOSED;
+  return connection.state === ConnectionState.CLOSED;
 });
 
 export const isNotStartedAtom = atom((get) => {
   const connection = get(connectionAtom);
-  return connection.state === WebSocketState.NOT_STARTED;
+  return connection.state === ConnectionState.NOT_STARTED;
 });

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;
     }