@marimo-team/islands 0.24.3-dev37 → 0.24.3-dev39

package/src/components/editor/chrome/wrapper/footer-items/backend-status.tsx

@@ -42,7 +42,9 @@ export const BackendConnectionStatus: React.FC = () => {
   const { isFetching, error, data, refetch } = useAsyncData(async () => {
     // If the connection is not connected, return
     if (!isAppConnected(connection)) {
-      setConnectionStatus("disconnected");
+      setConnectionStatus(
+        isAppConnecting(connection) ? "connecting" : "disconnected",
+      );
       return;
     }
 

package/src/components/editor/header/__tests__/status.test.tsx

@@ -66,24 +66,12 @@ describe("StatusOverlay disconnect indicator", () => {
     expect((button as HTMLButtonElement).disabled).toBe(true);
   });
 
-  it.each([
-    [
-      WebSocketClosedReason.KERNEL_STARTUP_ERROR,
-      "Failed to start kernel sandbox",
-    ],
-  ])(
-    "renders a disabled button for non-recoverable close reason %s",
-    (code, reason) => {
-      const onReconnect = vi.fn();
-      const { getByTestId } = renderOverlay(
-        { state: WebSocketState.CLOSED, code, reason },
-        onReconnect,
-      );
-
-      const button = getByTestId("disconnected-indicator") as HTMLButtonElement;
-      expect(button.disabled).toBe(true);
-      fireEvent.click(button);
-      expect(onReconnect).not.toHaveBeenCalled();
-    },
-  );
+  it("leaves editor startup failures to the inline notice", () => {
+    const { queryByTestId } = renderOverlay({
+      state: WebSocketState.CLOSED,
+      code: WebSocketClosedReason.KERNEL_STARTUP_ERROR,
+      reason: "Failed to start kernel sandbox",
+    });
+    expect(queryByTestId("disconnected-indicator")).not.toBeInTheDocument();
+  });
 });

package/src/components/editor/header/status.tsx

@@ -20,10 +20,12 @@ export const StatusOverlay: React.FC<{
   onReconnect?: () => void;
 }> = ({ connection, isRunning, onReconnect }) => {
   const { mode } = useAtomValue(viewStateAtom);
-  const isClosed = connection.state === WebSocketState.CLOSED;
+  const isClosed =
+    connection.state === WebSocketState.CLOSED &&
+    (mode === "read" ||
+      connection.code !== WebSocketClosedReason.KERNEL_STARTUP_ERROR);
   const isOpen = connection.state === WebSocketState.OPEN;
-  // Only KERNEL_DISCONNECTED is recoverable by a retry. KERNEL_STARTUP_ERROR
-  // would deterministically fail the same way.
+  // Editor startup failures have their own recovery UI.
   const canReconnect =
     isClosed && connection.code === WebSocketClosedReason.KERNEL_DISCONNECTED;
 

package/src/components/editor/renderers/cell-array.tsx

@@ -43,10 +43,7 @@ import type { AppMode } from "../../../core/mode";
 import { useHotkey } from "../../../hooks/useHotkey";
 import { type Theme, useTheme } from "../../../theme/useTheme";
 import { AddCellWithAI } from "../ai/add-cell-with-ai";
-import {
-  ConnectingAlert,
-  NotStartedConnectionAlert,
-} from "../alerts/connecting-alert";
+import { NotStartedConnectionAlert } from "../alerts/connecting-alert";
 import { FloatingOutline } from "../chrome/panels/outline/floating-outline";
 import { useChromeActions } from "../chrome/state";
 import { Column } from "../columns/cell-column";
@@ -140,7 +137,6 @@ const CellArrayInternal: React.FC<CellArrayProps> = ({
       <PackageAlert />
       <StartupLogsAlert />
       <StdinBlockingAlert />
-      <ConnectingAlert />
       <NotebookBanner width={appConfig.width} />
       {/* Only show if not cells, otherwise running a single cell will start the connection */}
       {cellIds.idLength === 0 && <NotStartedConnectionAlert />}

package/src/core/MarimoApp.tsx

@@ -12,7 +12,6 @@ import { getInitialAppMode } from "@/core/mode";
 import { CssVariables } from "@/theme/ThemeProvider";
 import { reactLazyWithPreload } from "@/utils/lazy";
 import { ErrorBoundary } from "../components/editor/boundary/ErrorBoundary";
-import { KernelStartupErrorModal } from "../components/editor/KernelStartupErrorModal";
 import { TracebackModalContainer } from "../components/editor/TracebackModalContainer";
 import { ModalProvider } from "../components/modal/ImperativeModal";
 import { Toaster } from "../components/ui/toaster";
@@ -105,7 +104,6 @@ const Providers = memo(({ children }: PropsWithChildren) => {
                 {children}
                 <Toaster />
                 <TailwindIndicator />
-                <KernelStartupErrorModal />
                 <TracebackModalContainer />
               </ModalProvider>
             </LocaleProvider>

package/src/core/edit-app.tsx

@@ -9,7 +9,8 @@ import { useAtomValue, useSetAtom } from "jotai";
 import { useEffect } from "react";
 import { NotStartedConnectionAlert } from "@/components/editor/alerts/connecting-alert";
 import { Controls } from "@/components/editor/controls/Controls";
-import { AppHeader } from "@/components/editor/header/app-header";
+import { SandboxController } from "@/components/editor/chrome/panels/sandbox-controller";
+import { ConnectionNotice } from "@/components/editor/alerts/connection-notice";
 import { FilenameForm } from "@/components/editor/header/filename-form";
 import { MultiCellActionToolbar } from "@/components/editor/navigation/multi-cell-action-toolbar";
 import { ViewerBanner } from "@/components/editor/viewer-banner";
@@ -158,6 +159,7 @@ export const EditApp: React.FC<AppProps> = ({
 
   return (
     <>
+      <SandboxController onReconnect={reconnect} />
       <AppContainer
         connection={connection}
         isRunning={isRunning}
@@ -165,10 +167,9 @@ export const EditApp: React.FC<AppProps> = ({
         onReconnect={reconnect}
       >
         <ViewerBanner />
-        <AppHeader
-          connection={connection}
+        <div
           className={cn(
-            "pt-4 sm:pt-12 pb-2 mb-4 print:hidden z-50",
+            "pt-4 sm:pt-12 pb-6 print:hidden z-50",
             // Keep the header sticky when scrolling horizontally, for column mode
             "sticky left-0",
           )}
@@ -178,7 +179,9 @@ export const EditApp: React.FC<AppProps> = ({
               <FilenameForm filename={filename} />
             </div>
           )}
-        </AppHeader>
+        </div>
+
+        <ConnectionNotice appConfig={appConfig} onRetry={reconnect} />
 
         {/* Don't render until we have a single cell. NotStartedConnectionAlert
             still covers the "no remote runtime started" prompt. */}

package/src/core/errors/state.ts

@@ -7,8 +7,7 @@ import { generateUUID } from "@/utils/uuid";
 import type { Banner } from "../kernel/messages";
 
 /**
- * Atom for storing kernel startup error message.
- * When set to a non-null value, shows a modal with the error details.
+ * Full startup diagnostics, retained until a new connection attempt or readiness.
  */
 export const kernelStartupErrorAtom = atom<string | null>(null);
 

package/src/core/islands/bootstrap.ts

@@ -201,6 +201,7 @@ function handleMessage(
       case "storage-download-ready":
       case "secret-keys-result":
       case "startup-logs":
+      case "startup-progress":
       case "interrupted":
       case "reconnected":
       case "cache-cleared":

package/src/core/islands/bridge.ts

@@ -370,6 +370,9 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   addPackage = throwNotImplemented;
   removePackage = throwNotImplemented;
   getPackageList = throwNotImplemented;
+  getSandbox = throwNotImplemented;
+  updateManifest = throwNotImplemented;
+  syncSandbox = throwNotImplemented;
   getDependencyTree = throwNotImplemented;
   getRecentFiles = throwNotImplemented;
   getWorkspaceFiles = throwNotImplemented;

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

@@ -0,0 +1,84 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { atom } from "jotai";
+import { kernelStartupErrorAtom } from "@/core/errors/state";
+import { sandboxAtom, sandboxSyncAtom } from "@/core/packages/sandbox-state";
+import { WebSocketClosedReason, WebSocketState } from "@/core/websocket/types";
+import { connectionAtom } from "./connection";
+
+export const connectionNoticeAtom = atom((get) => {
+  const connection = get(connectionAtom);
+  const backend = get(sandboxAtom)?.backend;
+  const sandbox = Boolean(backend);
+  const sync = get(sandboxSyncAtom);
+  if (
+    sandbox &&
+    (sync.pending || sync.error) &&
+    connection.state === WebSocketState.OPEN
+  ) {
+    return {
+      sandbox,
+      title: sync.pending ? "Syncing sandbox…" : "Sandbox sync failed",
+      description: sync.pending
+        ? "Applying the saved manifest to this notebook’s environment."
+        : "Review the error details, then try again.",
+      pending: sync.pending,
+      error: sync.error,
+    };
+  }
+  if (connection.state === WebSocketState.CONNECTING) {
+    const messages = {
+      "preparing-environment": {
+        title: backend
+          ? `Preparing ${backend} sandbox…`
+          : "Preparing environment…",
+        description:
+          "Getting this notebook’s Python environment ready. The first start can take a few minutes.",
+      },
+      "starting-kernel": {
+        title: "Starting notebook…",
+        description:
+          "The environment is prepared. Waiting for the Python kernel to connect to this notebook.",
+      },
+      reconnecting: {
+        title: "Reconnecting…",
+        description:
+          "The connection was interrupted. Your notebook and existing outputs stay visible while the kernel reconnects.",
+      },
+    };
+    return {
+      sandbox,
+      ...(connection.phase
+        ? messages[connection.phase]
+        : {
+            title: "Connecting…",
+            description: "Waiting for the notebook’s kernel to connect.",
+          }),
+      pending: true,
+      error: null,
+    };
+  }
+  if (connection.state === WebSocketState.CLOSED) {
+    const startupFailed =
+      connection.code === WebSocketClosedReason.KERNEL_STARTUP_ERROR;
+    const environmentFailed =
+      startupFailed && connection.phase === "preparing-environment";
+    return {
+      sandbox,
+      title: environmentFailed
+        ? "Sandbox setup failed"
+        : startupFailed
+          ? "Kernel failed to start"
+          : connection.reason,
+      description: environmentFailed
+        ? "The notebook can’t run yet."
+        : startupFailed
+          ? "The Python kernel could not start. Check the error details, then try again."
+          : "The connection to the notebook’s kernel was lost.",
+      pending: false,
+      error: startupFailed
+        ? (get(kernelStartupErrorAtom) ?? connection.reason)
+        : null,
+    };
+  }
+  return null;
+});

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

@@ -93,6 +93,9 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   saveUserConfig: "throwError",
   sendShutdown: "throwError",
   getPackageList: "throwError",
+  getSandbox: "serverOnly",
+  updateManifest: "serverOnly",
+  syncSandbox: "serverOnly",
   getDependencyTree: "throwError",
   addPackage: "throwError",
   removePackage: "throwError",

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

@@ -532,6 +532,18 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
+    getSandbox: (request) =>
+      getClient()
+        .POST("/api/packages/sandbox", { body: request, params: getParams() })
+        .then(handleResponse),
+    updateManifest: (request) =>
+      getClient()
+        .POST("/api/packages/manifest", { body: request, params: getParams() })
+        .then(handleResponse),
+    syncSandbox: (request) =>
+      getClient()
+        .POST("/api/packages/sync", { body: request, params: getParams() })
+        .then(handleResponse),
     addPackage: (request) => {
       return getClient()
         .POST("/api/packages/add", {

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

@@ -98,6 +98,9 @@ export function createStaticRequests(): EditRequests & RunRequests {
     addPackage: throwNotInEditMode,
     removePackage: throwNotInEditMode,
     getPackageList: throwNotInEditMode,
+    getSandbox: throwNotInEditMode,
+    updateManifest: throwNotInEditMode,
+    syncSandbox: throwNotInEditMode,
     getDependencyTree: throwNotInEditMode,
     listSecretKeys: throwNotInEditMode,
     writeSecret: throwNotInEditMode,

package/src/core/network/requests-toasting.tsx

@@ -79,6 +79,9 @@ export function createErrorToastingRequests(
     addPackage: "Failed to add package",
     removePackage: "Failed to remove package",
     getPackageList: "Failed to get package list",
+    getSandbox: "",
+    updateManifest: "",
+    syncSandbox: "",
     getDependencyTree: "Failed to get dependency tree",
     listSecretKeys: "Failed to fetch secrets",
     writeSecret: "Failed to write secret",

package/src/core/network/resolve.ts

@@ -1,4 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
+import { withPackageInvalidation } from "../packages/package-data";
 import { getRuntimeManager } from "../runtime/config";
 import { isStaticNotebook } from "../static/static-state";
 import { PyodideBridge } from "../wasm/bridge";
@@ -20,5 +21,5 @@ export function resolveRequestClient(): EditRequests & RunRequests {
       getRuntimeManager(),
     );
   }
-  return createErrorToastingRequests(base);
+  return withPackageInvalidation(createErrorToastingRequests(base));
 }

package/src/core/network/types.ts

@@ -69,6 +69,10 @@ export type ListPackagesResponse = schemas["ListPackagesResponse"];
 export type DependencyTreeResponse = schemas["DependencyTreeResponse"];
 export type DependencyTreeNode = schemas["DependencyTreeNode"];
 
+export type SandboxRequest = schemas["SandboxRequest"];
+export type SandboxResponse = schemas["SandboxResponse"];
+export type UpdateManifestRequest = schemas["UpdateManifestRequest"];
+export type SyncSandboxResponse = schemas["SyncSandboxResponse"];
 export type PackageOperationResponse = schemas["PackageOperationResponse"];
 export type InstantiateNotebookRequest = schemas["InstantiateNotebookRequest"];
 export type MarimoConfig = schemas["MarimoConfig"];
@@ -246,6 +250,9 @@ export interface EditRequests {
   autoExportAsMarkdown: (request: AutoExportAsMarkdownRequest) => Promise<null>;
   autoExportAsIPYNB: (request: AutoExportAsIPYNBRequest) => Promise<null>;
   updateCellOutputs: (request: UpdateCellOutputsRequest) => Promise<null>;
+  getSandbox: (request: SandboxRequest) => Promise<SandboxResponse>;
+  updateManifest: (request: UpdateManifestRequest) => Promise<SandboxResponse>;
+  syncSandbox: (request: SandboxRequest) => Promise<SyncSandboxResponse>;
   // Package requests
   getPackageList: () => Promise<ListPackagesResponse>;
   getDependencyTree: () => Promise<DependencyTreeResponse>;

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

@@ -0,0 +1,129 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { act, renderHook } from "@testing-library/react";
+import { createStore, Provider } from "jotai";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MockRequestClient } from "@/__mocks__/requests";
+import { toast } from "@/components/ui/use-toast";
+import { requestClientAtom } from "@/core/network/requests";
+import type { PackageOperationResponse } from "@/core/network/types";
+import { usePackageAction } from "../usePackageAction";
+
+vi.mock("@/components/ui/use-toast", () => ({ toast: vi.fn() }));
+
+function setup(action: "upgrade" | "remove") {
+  const client = MockRequestClient.create();
+  const store = createStore();
+  store.set(requestClientAtom, client);
+  return {
+    request: vi.mocked(
+      action === "upgrade" ? client.addPackage : client.removePackage,
+    ),
+    ...renderHook(
+      () =>
+        usePackageAction(action, "numpy", [{ kind: "group", value: "dev" }]),
+      {
+        wrapper: ({ children }) => (
+          <Provider store={store}>{children}</Provider>
+        ),
+      },
+    ),
+  };
+}
+
+describe("usePackageAction", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it.each([
+    { action: "upgrade", title: "Package upgraded", upgrade: true },
+    { action: "remove", title: "Package removed" },
+  ] as const)(
+    "preserves dependency groups and prevents duplicate $action requests",
+    async ({ action, title, ...options }) => {
+      const { result, request } = setup(action);
+      const { promise, resolve } =
+        Promise.withResolvers<PackageOperationResponse>();
+      request.mockReturnValue(promise);
+      let pending: Promise<void>;
+      act(() => {
+        pending = result.current.run();
+      });
+      expect(result.current.loading).toBe(true);
+      await act(async () => {
+        await result.current.run();
+      });
+      expect(request).toHaveBeenCalledExactlyOnceWith({
+        package: "numpy",
+        group: "dev",
+        ...options,
+      });
+      await act(async () => {
+        resolve({ success: true });
+        await pending;
+      });
+      expect(result.current.loading).toBe(false);
+      expect(toast).toHaveBeenCalledExactlyOnceWith(
+        expect.objectContaining({ title }),
+      );
+    },
+  );
+
+  it("reports saved changes requiring a restart without claiming success", async () => {
+    const { result, request } = setup("upgrade");
+    request.mockResolvedValue({ success: false, restartRequired: true });
+    await act(async () => {
+      await result.current.run();
+    });
+    expect(toast).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        title: "Changes saved — restart required",
+      }),
+    );
+  });
+
+  it.each([
+    {
+      response: { success: false, error: "resolver failed" },
+      description: "resolver failed",
+    },
+    { response: { success: false }, description: expect.any(String) },
+  ])(
+    "reports failed responses as errors: $response",
+    async ({ response, description }) => {
+      const { result, request } = setup("remove");
+      request.mockResolvedValue(response);
+      await act(async () => {
+        await result.current.run();
+      });
+      expect(toast).toHaveBeenCalledExactlyOnceWith(
+        expect.objectContaining({
+          title: "Failed to remove package",
+          description,
+          variant: "danger",
+        }),
+      );
+    },
+  );
+
+  it("reports request errors and allows a retry", async () => {
+    const { result, request } = setup("remove");
+    request.mockRejectedValueOnce(new Error("offline"));
+    await act(async () => {
+      await result.current.run();
+    });
+    expect(toast).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        title: "Failed to remove package",
+        description: "offline",
+        variant: "danger",
+      }),
+    );
+    expect(result.current.loading).toBe(false);
+    request.mockResolvedValue({ success: true });
+    await act(async () => {
+      await result.current.run();
+    });
+    expect(toast).toHaveBeenLastCalledWith(
+      expect.objectContaining({ title: "Package removed" }),
+    );
+  });
+});

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

@@ -0,0 +1,165 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { Provider } from "jotai";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MockRequestClient } from "@/__mocks__/requests";
+import { kernelStartupErrorAtom } from "@/core/errors/state";
+import { connectionAtom } from "@/core/network/connection";
+import { requestClientAtom } from "@/core/network/requests";
+import type {
+  SandboxResponse,
+  SyncSandboxResponse,
+} from "@/core/network/types";
+import { filenameAtom } from "@/core/saving/file-state";
+import { store } from "@/core/state/jotai";
+import { WebSocketState } from "@/core/websocket/types";
+import { HTTPError } from "@/utils/errors";
+import { packageDataVersionAtom } from "../package-data";
+import {
+  sandboxActionsAtom,
+  sandboxAtom,
+  sandboxSyncAtom,
+} from "../sandbox-state";
+import { useSandboxController } from "../useSandboxController";
+
+vi.mock("../toast-components", () => ({
+  showPackageRestartToast: vi.fn(),
+  showSandboxSyncToast: vi.fn(),
+}));
+
+const manifest = 'dependencies = ["numpy"]';
+const sandbox: SandboxResponse = {
+  backend: "uv",
+  manifest,
+  filename: "notebook.py",
+};
+
+beforeEach(() => {
+  store.set(sandboxAtom, null);
+  store.set(sandboxSyncAtom, { pending: false, error: null });
+  store.set(sandboxActionsAtom, null);
+  store.set(connectionAtom, { state: WebSocketState.OPEN });
+  store.set(kernelStartupErrorAtom, null);
+  store.set(filenameAtom, "notebook.py");
+  store.set(packageDataVersionAtom, 0);
+});
+
+function setup() {
+  const client = MockRequestClient.create({
+    getSandbox: vi.fn().mockResolvedValue(sandbox),
+    updateManifest: vi.fn(async ({ contents }) => ({
+      ...sandbox,
+      manifest: contents,
+    })),
+    syncSandbox: vi.fn().mockResolvedValue({ success: true, reconnect: false }),
+  });
+  store.set(requestClientAtom, client);
+  const reconnect = vi.fn<() => Promise<void>>().mockResolvedValue(undefined);
+  return {
+    client,
+    reconnect,
+    ...renderHook(() => useSandboxController(reconnect), {
+      wrapper: ({ children }) => <Provider store={store}>{children}</Provider>,
+    }),
+  };
+}
+
+describe("useSandboxController", () => {
+  it("keeps a conflicting draft across closing and only discards it on explicit reload", async () => {
+    const { result, client } = setup();
+    vi.mocked(client.updateManifest).mockRejectedValue(
+      new HTTPError(409, "Conflict", { detail: "Manifest changed on disk" }),
+    );
+    await act(async () => {
+      await store.get(sandboxActionsAtom)?.editManifest();
+    });
+    act(() => result.current.setDraft("dependencies = []"));
+    await act(async () => {
+      await result.current.saveAndSync();
+    });
+    expect(client.updateManifest).toHaveBeenCalledExactlyOnceWith({
+      fileKey: "notebook.py",
+      previous: manifest,
+      contents: "dependencies = []",
+    });
+    expect(result.current).toMatchObject({
+      open: true,
+      draft: "dependencies = []",
+      dirty: true,
+      conflict: true,
+      diagnostic: "Manifest changed on disk",
+      pending: false,
+    });
+    expect(client.syncSandbox).not.toHaveBeenCalled();
+    act(() => result.current.setOpen(false));
+    await act(async () => {
+      await store.get(sandboxActionsAtom)?.editManifest();
+    });
+    expect(result.current.draft).toBe("dependencies = []");
+    await act(async () => {
+      await result.current.loadManifest();
+    });
+    expect(result.current).toMatchObject({
+      draft: manifest,
+      dirty: false,
+      conflict: false,
+      diagnostic: null,
+    });
+  });
+
+  it("shares sync progress across callers and refreshes packages without reconnecting", async () => {
+    const { client, reconnect } = setup();
+    const { promise, resolve } = Promise.withResolvers<SyncSandboxResponse>();
+    vi.mocked(client.syncSandbox).mockReturnValue(promise);
+    const actions = store.get(sandboxActionsAtom)!;
+    let pending: Promise<boolean>;
+    act(() => {
+      pending = actions.sync();
+    });
+    expect(store.get(sandboxSyncAtom)).toEqual({ pending: true, error: null });
+    await act(async () => {
+      expect(await actions.sync()).toBe(false);
+    });
+    expect(client.syncSandbox).toHaveBeenCalledTimes(1);
+    await act(async () => {
+      resolve({ success: true, reconnect: false });
+      expect(await pending).toBe(true);
+    });
+    expect(store.get(sandboxSyncAtom)).toEqual({ pending: false, error: null });
+    expect(store.get(packageDataVersionAtom)).toBe(1);
+    expect(reconnect).not.toHaveBeenCalled();
+  });
+
+  it("reports sync failure and clears it when retrying", async () => {
+    const { client } = setup();
+    const actions = store.get(sandboxActionsAtom)!;
+    vi.mocked(client.syncSandbox).mockRejectedValueOnce(new Error("offline"));
+    await act(async () => {
+      expect(await actions.sync()).toBe(false);
+    });
+    expect(store.get(sandboxSyncAtom)).toEqual({
+      pending: false,
+      error: "offline",
+    });
+    await act(async () => {
+      expect(await actions.sync()).toBe(true);
+    });
+    expect(store.get(sandboxSyncAtom)).toEqual({ pending: false, error: null });
+  });
+
+  it("ignores stale metadata after a filename change and unregisters actions on unmount", async () => {
+    const { client, unmount } = setup();
+    await waitFor(() => expect(store.get(sandboxAtom)).toEqual(sandbox));
+    const { promise, resolve } = Promise.withResolvers<SandboxResponse>();
+    vi.mocked(client.getSandbox).mockReturnValueOnce(promise);
+    act(() => store.set(filenameAtom, "old.py"));
+    const current = { ...sandbox, filename: "current.py" };
+    vi.mocked(client.getSandbox).mockResolvedValue(current);
+    act(() => store.set(filenameAtom, "current.py"));
+    await waitFor(() => expect(store.get(sandboxAtom)).toEqual(current));
+    await act(async () => resolve({ ...sandbox, filename: "old.py" }));
+    expect(store.get(sandboxAtom)).toEqual(current);
+    unmount();
+    expect(store.get(sandboxActionsAtom)).toBeNull();
+  });
+});