@marimo-team/islands 0.25.3-dev308 → 0.25.3-dev310

package/src/core/islands/__tests__/bridge.test.ts

@@ -2,12 +2,7 @@
 
 import type { components } from "@marimo-team/marimo-api";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  cellId,
-  requestId,
-  uiElementId,
-  widgetModelId,
-} from "@/__tests__/branded";
+import { requestId, uiElementId, widgetModelId } from "@/__tests__/branded";
 import { notebookAtom } from "@/core/cells/cells";
 import { islandsPendingInitialRunsAtom } from "@/core/islands/state";
 
@@ -50,6 +45,7 @@ vi.stubGlobal("URL", MockURL);
 const {
   mockBridge,
   mockLoadPackages,
+  mockNotebookCall,
   mockReplaceSessionRequest,
   mockStopSessionRequest,
   mockStartSessionRequest,
@@ -61,6 +57,7 @@ const {
 } = vi.hoisted(() => ({
   mockBridge: vi.fn(),
   mockLoadPackages: vi.fn(),
+  mockNotebookCall: vi.fn(),
   mockReplaceSessionRequest: vi.fn(),
   mockStopSessionRequest: vi.fn(),
   mockStartSessionRequest: vi.fn(),
@@ -84,6 +81,7 @@ vi.mock("@/core/wasm/rpc", () => ({
       request: {
         bridge: mockBridge,
         loadPackages: mockLoadPackages,
+        notebookCall: mockNotebookCall,
         replaceSession: mockReplaceSessionRequest,
         startSession: mockStartSessionRequest,
         stopSession: mockStopSessionRequest,
@@ -411,9 +409,6 @@ describe("IslandsPyodideBridge", () => {
       sendKernelMessage(1);
 
       expect(handlers.message.mock.calls).toEqual([[cell]]);
-      expect(() => bridge.notebookBackend.notebook("n1")).toThrow(
-        "Islands do not edit",
-      );
     });
 
     it("resets the notebook stream when the managed session is replaced or stopped", async () => {
@@ -754,60 +749,47 @@ describe("IslandsPyodideBridge", () => {
     });
   });
 
-  describe("sendRun", () => {
+  describe("notebookBackend.notebook", () => {
     beforeEach(initializeSingleApp);
 
-    it("should include type field in control request", async () => {
-      const request = {
-        cellIds: [cellId("cell-1"), cellId("cell-2")],
-        codes: ["print('hello')", "print('world')"],
-      };
-
-      await bridge.sendRun(request);
-
-      expect(mockBridge).toHaveBeenCalledWith({
-        appId: "app-1",
-        functionName: "put_control_request",
-        payload: {
-          type: "execute-cells",
-          request: undefined,
-          executionRequests: [
-            {
-              type: "execute-cell",
-              cellId: "cell-1",
-              code: "print('hello')",
-            },
-            {
-              type: "execute-cell",
-              cellId: "cell-2",
-              code: "print('world')",
-            },
-          ],
+    it("sends notebook commands to the managed session's host", async () => {
+      mockNotebookCall.mockResolvedValue({
+        status: 202,
+        body: {
+          id: "run-1",
+          notebook_id: "n1",
+          runtime_id: "r1",
+          cells: ["c1"],
+          status: "queued",
+          outcome: null,
+          started_at: null,
+          completed_at: null,
         },
-        sessionGeneration: 1,
       });
-    });
-
-    it("should call loadPackages before putControlRequest", async () => {
-      const request = {
-        cellIds: [cellId("cell-1")],
-        codes: ["import pandas"],
-      };
 
-      await bridge.sendRun(request);
+      const result = await bridge.notebookBackend
+        .notebook("n1")
+        .run({ cells: [{ id: "c1" }], idempotencyKey: "key-1" });
 
-      // Verify loadPackages was called with joined codes
-      expect(mockLoadPackages).toHaveBeenCalledWith({
+      expect(result.ok).toBe(true);
+      expect(mockNotebookCall).toHaveBeenCalledWith({
         appId: "app-1",
-        code: "import pandas",
         sessionGeneration: 1,
+        call: expect.objectContaining({
+          operation: "runtime.run",
+          params: { notebook_id: "n1" },
+          headers: { "idempotency-key": "key-1" },
+          body: { cells: [{ id: "c1" }] },
+        }),
       });
+    });
+
+    it("has no commands without an active session", async () => {
+      await bridge.stopSession();
 
-      // Verify order: loadPackages should be called before bridge
-      const loadPackagesCallOrder =
-        mockLoadPackages.mock.invocationCallOrder[0];
-      const bridgeCallOrder = mockBridge.mock.invocationCallOrder[0];
-      expect(loadPackagesCallOrder).toBeLessThan(bridgeCallOrder);
+      expect(() => bridge.notebookBackend.notebook("n1")).toThrow(
+        "No island session is active",
+      );
     });
   });
 
@@ -857,7 +839,6 @@ describe("IslandsPyodideBridge", () => {
         functionName: "",
         args: {},
       });
-      await bridge.sendRun({ cellIds: [], codes: [] });
       await bridge.sendModelValue({
         modelId: widgetModelId(""),
         message: { method: "update", state: {}, bufferPaths: [] },

package/src/core/islands/bootstrap.ts

@@ -36,7 +36,10 @@ import { queryParamHandlers } from "../kernel/queryParamHandlers";
 import { RuntimeState } from "../kernel/RuntimeState";
 import { initialModeAtom } from "../mode";
 import { requestClientAtom } from "../network/requests";
-import { activeNotebookReplicaAtom } from "../session/active-notebook";
+import {
+  activeDocumentModelAtom,
+  activeNotebookReplicaAtom,
+} from "../session/active-notebook";
 import { store as defaultStore } from "../state/jotai";
 import type { IslandsPyodideBridge } from "./bridge";
 import { MarimoIslandElement } from "./components/web-components";
@@ -141,6 +144,7 @@ export async function initializeIslands(
   });
   const lifetime = new AbortController();
   documentModel.start({ signal: lifetime.signal });
+  store.set(activeDocumentModelAtom, documentModel);
   followDocument({
     store,
     model: documentModel,

package/src/core/islands/bridge.ts

@@ -1,9 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 /* oxlint-disable typescript/no-explicit-any */
 
-import type { NotebookTransport } from "@marimo-team/client";
+import { NotebookClient, type NotebookTransport } from "@marimo-team/client";
 import { getWorkerRPC } from "@/core/wasm/rpc";
-import { Arrays } from "@/utils/arrays";
 import { Deferred } from "@/utils/Deferred";
 import { throwNotImplemented } from "@/utils/functions";
 import { Logger } from "@/utils/Logger";
@@ -99,8 +98,21 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
           { once: true },
         );
       }),
-    notebook: () => {
-      throw new Error("Islands do not edit notebooks");
+    notebook: (notebookId) => {
+      const session = this.session;
+      if (session === undefined) {
+        throw new Error("No island session is active");
+      }
+      const { appId, sessionGeneration } = session;
+      return NotebookClient.unstable_over(
+        (call) =>
+          this.rpc.proxy.request.notebookCall({
+            appId,
+            sessionGeneration,
+            call,
+          }),
+        { notebookId },
+      );
     },
   };
 
@@ -353,30 +365,6 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   // EditRequests Implementation
   // ============================================================================
 
-  public sendRun: EditRequests["sendRun"] = async (request): Promise<null> => {
-    const session = await this.getActiveSession();
-    await this.rpc.proxy.request.loadPackages({
-      appId: session.appId,
-      code: request.codes.join("\n"),
-      sessionGeneration: session.sessionGeneration,
-    });
-    await this.putControlRequest(
-      {
-        type: "execute-cells",
-        request: request.request,
-        executionRequests: Arrays.zip(request.cellIds, request.codes).map(
-          ([cellId, code]) => ({
-            type: "execute-cell",
-            cellId,
-            code,
-          }),
-        ),
-      },
-      session,
-    );
-    return null;
-  };
-
   // ============================================================================
   // Not Implemented (Read-Only Mode)
   // ============================================================================

package/src/core/islands/components/IslandControls.tsx

@@ -1,11 +1,13 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import { useAtomValue, useStore } from "jotai";
 import { CopyIcon, PlayIcon } from "lucide-react";
 import type { JSX } from "react";
 import { Button } from "@/components/ui/button";
 import { Tooltip } from "@/components/ui/tooltip";
 import type { CellId } from "@/core/cells/ids";
-import { useRequestClient } from "@/core/network/requests";
+import { runCells } from "@/core/executions";
+import { activeDocumentModelAtom } from "@/core/session/active-notebook";
 import { copyToClipboard } from "@/utils/copy";
 import { Logger } from "@/utils/Logger";
 
@@ -66,21 +68,27 @@ export const IslandControls: React.FC<IslandControlsProps> = ({
   codeCallback,
   visible,
 }) => {
-  const { sendRun } = useRequestClient();
+  const store = useStore();
+  const model = useAtomValue(activeDocumentModelAtom);
 
   const handleCopy = () => {
     copyToClipboard(codeCallback());
   };
 
+  // The island's editor is a UI element, so its code reaches the document
+  // here rather than through an editor binding.
   const handleRun = async () => {
+    if (model === null) {
+      return;
+    }
+    const code = codeCallback();
     try {
-      await sendRun({
-        cellIds: [cellId],
-        codes: [codeCallback()],
-      });
+      store.set(model.editAtom, (tx) => tx.setCode(cellId, code));
     } catch (error) {
-      Logger.error("Failed to run cell:", error);
+      Logger.error("The island's cell is not in the document", error);
+      return;
     }
+    await runCells(store, [cellId]);
   };
 
   return (

package/src/core/islands/components/__tests__/IslandControls.test.tsx

@@ -1,17 +1,21 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 
 import { fireEvent, render, screen } from "@testing-library/react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { MockRequestClient } from "@/__mocks__/requests";
+import { Provider } from "jotai";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mockDocumentModel } from "@/__mocks__/document";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import type { CellId } from "@/core/cells/ids";
-import * as requestsModule from "@/core/network/requests";
+import type { runCells } from "@/core/executions";
+import { cell, document } from "@/core/notebook/document/__tests__/fixtures";
+import { store } from "@/core/state/jotai";
 import * as copyModule from "@/utils/copy";
 import { IslandControls } from "../IslandControls";
 
-// Mock the dependencies
-vi.mock("@/core/network/requests", () => ({
-  useRequestClient: vi.fn(),
+const mockRunCells = vi.fn<typeof runCells>();
+
+vi.mock("@/core/executions", () => ({
+  runCells: (...args: Parameters<typeof runCells>) => mockRunCells(...args),
 }));
 
 vi.mock("@/utils/copy", () => ({
@@ -19,30 +23,43 @@ vi.mock("@/utils/copy", () => ({
 }));
 
 describe("IslandControls", () => {
-  const mockSendRun =
-    vi.fn<ReturnType<typeof requestsModule.useRequestClient>["sendRun"]>();
   const mockCopyToClipboard = vi.fn();
   const mockCodeCallback = vi.fn(() => "print('test code')");
   const cellId = "test-cell-id" as CellId;
+  let model: ReturnType<typeof mockDocumentModel>;
+
+  function cellCode() {
+    return store.get(model.model.documentAtom)?.cells.get(cellId)?.code;
+  }
 
   // Helper to render with required providers
   const renderWithProviders = (component: React.ReactElement) => {
-    return render(<TooltipProvider>{component}</TooltipProvider>);
+    return render(
+      <Provider store={store}>
+        <TooltipProvider>{component}</TooltipProvider>
+      </Provider>,
+    );
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockSendRun.mockResolvedValue(null);
-
-    vi.spyOn(requestsModule, "useRequestClient").mockReturnValue(
-      MockRequestClient.create({ sendRun: mockSendRun }),
-    );
+    mockRunCells.mockResolvedValue(undefined);
+    const confirmed = document();
+    model = mockDocumentModel(store, {
+      ...confirmed,
+      cells: new Map([[cellId, cell(cellId, "print('old')")]]),
+      revision: { ...confirmed.revision, order: [cellId] },
+    });
 
     vi.spyOn(copyModule, "copyToClipboard").mockImplementation(
       mockCopyToClipboard,
     );
   });
 
+  afterEach(() => {
+    model.stop();
+  });
+
   it("should not display when visible is false", () => {
     const { container } = renderWithProviders(
       <IslandControls
@@ -102,7 +119,7 @@ describe("IslandControls", () => {
     expect(mockCopyToClipboard).toHaveBeenCalledWith("print('test code')");
   });
 
-  it("should run cell when run button is clicked", async () => {
+  it("writes the editor's code to the cell and runs it through the host", async () => {
     renderWithProviders(
       <IslandControls
         cellId={cellId}
@@ -116,42 +133,10 @@ describe("IslandControls", () => {
 
     fireEvent.click(runButton);
 
-    // Wait for async operation
-    await vi.waitFor(() => {
-      expect(mockCodeCallback).toHaveBeenCalled();
-      expect(mockSendRun).toHaveBeenCalledWith({
-        cellIds: [cellId],
-        codes: ["print('test code')"],
-      });
-    });
-  });
-
-  it("should handle run errors gracefully", async () => {
-    const consoleErrorSpy = vi
-      .spyOn(console, "error")
-      .mockImplementation(() => {});
-
-    mockSendRun.mockRejectedValueOnce(new Error("Run failed"));
-
-    renderWithProviders(
-      <IslandControls
-        cellId={cellId}
-        codeCallback={mockCodeCallback}
-        visible={true}
-      />,
-    );
-
-    const buttons = screen.getAllByRole("button");
-    const runButton = buttons[1];
-
-    fireEvent.click(runButton);
-
-    // Wait for error to be logged
     await vi.waitFor(() => {
-      expect(consoleErrorSpy).toHaveBeenCalled();
+      expect(mockRunCells).toHaveBeenCalledWith(store, [cellId]);
     });
-
-    consoleErrorSpy.mockRestore();
+    expect(cellCode()).toBe("print('test code')");
   });
 
   it("should get fresh code on each button click", async () => {
@@ -175,11 +160,9 @@ describe("IslandControls", () => {
 
     fireEvent.click(runButton);
     await vi.waitFor(() => {
-      expect(mockSendRun).toHaveBeenCalledWith({
-        cellIds: [cellId],
-        codes: ["code version 2"],
-      });
+      expect(mockRunCells).toHaveBeenCalledWith(store, [cellId]);
     });
+    expect(cellCode()).toBe("code version 2");
 
     fireEvent.click(copyButton);
     expect(mockCopyToClipboard).toHaveBeenCalledWith("code version 3");

package/src/core/islands/worker/worker.tsx

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import type { unstable_NotebookCall } from "@marimo-team/client";
 import type { PyodideInterface } from "pyodide";
 import {
   createRPC,
@@ -76,6 +77,13 @@ async function startSession(
     // Follow before the session instantiates. Each subscription begins with
     // its own kernel-ready and the session's retained notifications.
     try {
+      const host = session.bridge.notebook;
+      try {
+        // Host runs name cells, so the worker loads their imports itself.
+        host.set_package_loader(loadPackagesForCode);
+      } finally {
+        host.destroy();
+      }
       await follow(session.bridge, opts.sessionGeneration);
     } catch (error) {
       await session.stop();
@@ -100,6 +108,27 @@ async function startSession(
   }
 }
 
+async function loadPackagesForCode(code: string): Promise<void> {
+  if (shouldLoadDuckDBPackages(code)) {
+    // Add pandas and duckdb to the code for mo.sql and for remote duckdb sources
+    code = `import pandas\n${code}`;
+    code = `import duckdb\n${code}`;
+    code = `import sqlglot\n${code}`;
+
+    // Polars + SQL requires pyarrow, and installing
+    // after notebook load does not work. As a heuristic,
+    // if it appears that the notebook uses polars, add pyarrow.
+    if (code.includes("polars")) {
+      code = `import pyarrow\n${code}`;
+    }
+  }
+
+  await self.pyodide.loadPackagesFromImports(code, {
+    messageCallback: Logger.log,
+    errorCallback: Logger.error,
+  });
+}
+
 async function stopActiveSession(): Promise<void> {
   // Stopping closes every session and its notebook subscriptions.
   await self.controller.stopSession();
@@ -166,27 +195,24 @@ const requestHandler = createRPCRequestHandler({
     await pyodideReadyPromise; // Make sure loading is done
     await enqueueSession(async () => {
       requireActiveBridge(opts);
+      await loadPackagesForCode(opts.code);
+    });
+  },
 
-      let { code } = opts;
-
-      if (shouldLoadDuckDBPackages(code)) {
-        // Add pandas and duckdb to the code for mo.sql and for remote duckdb sources
-        code = `import pandas\n${code}`;
-        code = `import duckdb\n${code}`;
-        code = `import sqlglot\n${code}`;
-
-        // Polars + SQL requires pyarrow, and installing
-        // after notebook load does not work. As a heuristic,
-        // if it appears that the notebook uses polars, add pyarrow.
-        if (code.includes("polars")) {
-          code = `import pyarrow\n${code}`;
-        }
+  /** Deliver a notebook operation to the active session's host. */
+  notebookCall: async (opts: {
+    appId: string;
+    sessionGeneration: number;
+    call: unstable_NotebookCall;
+  }): Promise<unknown> => {
+    await pyodideReadyPromise;
+    return enqueueSession(async () => {
+      const { notebook } = requireActiveBridge(opts);
+      try {
+        return JSON.parse(await notebook.call(JSON.stringify(opts.call)));
+      } finally {
+        notebook.destroy();
       }
-
-      await self.pyodide.loadPackagesFromImports(code, {
-        messageCallback: Logger.log,
-        errorCallback: Logger.error,
-      });
     });
   },
 

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

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { cellId, requestId, uiElementId } from "@/__tests__/branded";
+import { requestId, uiElementId } from "@/__tests__/branded";
 import { waitForRuntimeRunning } from "../../executions";
 import type { RuntimeManager } from "../../runtime/runtime";
 import { waitForConnectionOpen } from "../connection";
@@ -49,7 +49,6 @@ describe("createLazyRequests", () => {
 
     // Mock delegate with some sample methods
     mockDelegate = {
-      sendRun: vi.fn().mockResolvedValue({ success: true }),
       sendInstantiate: vi.fn().mockResolvedValue({ instantiated: true }),
       sendFunctionRequest: vi.fn().mockResolvedValue({ result: "data" }),
       sendRestart: vi.fn().mockResolvedValue({ restarted: true }),
@@ -149,7 +148,7 @@ describe("createLazyRequests", () => {
       mockGetRuntimeManager,
     );
 
-    await lazyRequests.sendRun({ cellIds: [cellId("cell1")], codes: ["code"] });
+    await lazyRequests.sendRunScratchpad({ code: "code" });
 
     expect(mockInit).toHaveBeenCalledTimes(1);
   });
@@ -175,7 +174,7 @@ describe("createLazyRequests", () => {
       mockGetRuntimeManager,
     );
 
-    await lazyRequests.sendRun({ cellIds: [cellId("cell1")], codes: ["code"] });
+    await lazyRequests.sendRunScratchpad({ code: "code" });
     await lazyRequests.sendInstantiate({
       objectIds: [uiElementId("obj1")],
       values: [],
@@ -197,7 +196,7 @@ describe("createLazyRequests", () => {
       mockGetRuntimeManager,
     );
 
-    await lazyRequests.sendRun({ cellIds: [cellId("cell1")], codes: ["code"] });
+    await lazyRequests.sendRunScratchpad({ code: "code" });
 
     expect(waitForConnectionOpen).toHaveBeenCalled();
   });
@@ -208,10 +207,10 @@ describe("createLazyRequests", () => {
       mockGetRuntimeManager,
     );
 
-    const args = { cellIds: [cellId("cell1")], codes: ["code"] };
-    await lazyRequests.sendRun(args);
+    const args = { code: "code" };
+    await lazyRequests.sendRunScratchpad(args);
 
-    expect(mockDelegate.sendRun).toHaveBeenCalledWith(args);
+    expect(mockDelegate.sendRunScratchpad).toHaveBeenCalledWith(args);
   });
 
   it("should return the result from delegate method", async () => {
@@ -236,7 +235,7 @@ describe("createLazyRequests", () => {
       mockGetRuntimeManager,
     );
 
-    expect(lazyRequests.sendRun).toBeDefined();
+    expect(lazyRequests.sendRunScratchpad).toBeDefined();
     expect(lazyRequests.sendInstantiate).toBeDefined();
     expect(lazyRequests.sendFunctionRequest).toBeDefined();
   });
@@ -251,13 +250,13 @@ describe("createLazyRequests", () => {
     );
 
     await expect(
-      lazyRequests.sendRun({ cellIds: [cellId("cell1")], codes: ["code"] }),
+      lazyRequests.sendRunScratchpad({ code: "code" }),
     ).rejects.toThrow("Init failed");
   });
 
   it("should handle errors from delegate method", async () => {
     const error = new Error("Request failed");
-    mockDelegate.sendRun = vi.fn().mockRejectedValue(error);
+    mockDelegate.sendRunScratchpad = vi.fn().mockRejectedValue(error);
 
     const lazyRequests = createLazyRequests(
       mockDelegate,
@@ -265,7 +264,7 @@ describe("createLazyRequests", () => {
     );
 
     await expect(
-      lazyRequests.sendRun({ cellIds: [cellId("cell1")], codes: ["code"] }),
+      lazyRequests.sendRunScratchpad({ code: "code" }),
     ).rejects.toThrow("Request failed");
   });
 
@@ -277,10 +276,7 @@ describe("createLazyRequests", () => {
       );
 
       // First request with first runtime manager
-      await lazyRequests.sendRun({
-        cellIds: [cellId("cell1")],
-        codes: ["code"],
-      });
+      await lazyRequests.sendRunScratchpad({ code: "code" });
       expect(mockInit).toHaveBeenCalledTimes(1);
 
       // Create a new runtime manager
@@ -298,10 +294,7 @@ describe("createLazyRequests", () => {
       );
 
       // Second request with second runtime manager
-      await lazyRequests2.sendRun({
-        cellIds: [cellId("cell2")],
-        codes: ["code2"],
-      });
+      await lazyRequests2.sendRunScratchpad({ code: "code" });
 
       // Both inits should have been called
       expect(mockInit).toHaveBeenCalledTimes(1);
@@ -315,10 +308,7 @@ describe("createLazyRequests", () => {
       );
 
       // Multiple requests
-      await lazyRequests.sendRun({
-        cellIds: [cellId("cell1")],
-        codes: ["code"],
-      });
+      await lazyRequests.sendRunScratchpad({ code: "code" });
       await lazyRequests.sendInstantiate({
         objectIds: [uiElementId("obj1")],
         values: [],

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

@@ -14,7 +14,7 @@ import type { EditRequests, RunRequests } from "../types";
 
 function requestsThatReject(error: unknown): EditRequests & RunRequests {
   return createErrorToastingRequests({
-    sendRun: vi.fn().mockRejectedValue(error),
+    sendRunScratchpad: vi.fn().mockRejectedValue(error),
   } as unknown as EditRequests & RunRequests);
 }
 
@@ -29,17 +29,17 @@ describe("createErrorToastingRequests", () => {
         detail: "This connection is read-only for this action.",
       }),
     );
-    await expect(requests.sendRun({} as never)).rejects.toBeInstanceOf(
-      HTTPError,
-    );
+    await expect(
+      requests.sendRunScratchpad({} as never),
+    ).rejects.toBeInstanceOf(HTTPError);
     expect(toastMock).not.toHaveBeenCalled();
   });
 
   it("shows a danger toast for other request errors", async () => {
     const requests = requestsThatReject(new HTTPError(500, "Server Error"));
-    await expect(requests.sendRun({} as never)).rejects.toBeInstanceOf(
-      HTTPError,
-    );
+    await expect(
+      requests.sendRunScratchpad({} as never),
+    ).rejects.toBeInstanceOf(HTTPError);
     expect(toastMock).toHaveBeenCalledWith(
       expect.objectContaining({ variant: "danger" }),
     );