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

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

@@ -51,7 +51,6 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   sendComponentValues: "startConnection",
   sendModelValue: "startConnection",
   sendInstantiate: "startConnectionWithoutKernel",
-  sendRun: "startConnection",
   sendRunScratchpad: "startConnection",
   saveAppConfig: "startConnection",
   discoverDataSources: "startConnection",
@@ -192,7 +191,7 @@ export function createLazyRequests(
         case "waitForConnectionOpen":
           // Wait for connection but don't start it
           await waitForConnectionOpen();
-          await waitForRuntimeRunning();
+          await waitForRuntimeRunning(store);
           return request(...args);
 
         case "startConnectionWithoutKernel":
@@ -201,7 +200,7 @@ export function createLazyRequests(
           await initOnce(runtimeManager);
           await waitForConnectionOpen();
           if (action === "startConnection") {
-            await waitForRuntimeRunning();
+            await waitForRuntimeRunning(store);
           }
           return request(...args);
 

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

@@ -106,15 +106,6 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         .POST("/api/kernel/shutdown")
         .then(handleResponseReturnNull);
     },
-    sendRun: async (request) => {
-      await waitForConnectionOpen();
-      return getClient()
-        .POST("/api/kernel/run", {
-          body: request,
-          params: getParams(),
-        })
-        .then(handleResponseReturnNull);
-    },
     sendRunScratchpad: async (request) => {
       await waitForConnectionOpen();
       return getClient()

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

@@ -40,7 +40,6 @@ export function createStaticRequests(): EditRequests & RunRequests {
       return null;
     },
     sendRestart: throwNotInEditMode,
-    sendRun: throwNotInEditMode,
     sendRunScratchpad: throwNotInEditMode,
     sendRename: throwNotInEditMode,
     saveLayout: throwNotInEditMode,

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

@@ -21,7 +21,6 @@ export function createErrorToastingRequests(
     sendInstantiate: "Failed to instantiate",
     sendFunctionRequest: "Failed to send function request",
     sendRestart: "Failed to restart",
-    sendRun: "Failed to run",
     sendRunScratchpad: "Failed to run scratchpad",
     sendRename: "Failed to rename",
     saveLayout: "", // The save reports it

package/src/core/network/types.ts

@@ -91,7 +91,6 @@ export type SetBreakpointsRequest = schemas["SetBreakpointsRequest"];
 export type ReadCodeResponse = schemas["ReadCodeResponse"];
 export type RecentFilesResponse = schemas["RecentFilesResponse"];
 export type RenameNotebookRequest = schemas["RenameNotebookRequest"];
-export type ExecuteCellsRequest = schemas["ExecuteCellsRequest"];
 export type ExecuteScratchpadRequest = schemas["ExecuteScratchpadRequest"];
 export type SaveAppConfigurationRequest =
   schemas["SaveAppConfigurationRequest"];
@@ -165,7 +164,6 @@ export interface EditRequests {
   saveLayout: (request: SaveLayoutRequest) => Promise<null>;
   sendCopy: (request: CopyNotebookRequest) => Promise<null>;
   sendStdin: (request: StdinRequest) => Promise<null>;
-  sendRun: (request: ExecuteCellsRequest) => Promise<null>;
   sendRunScratchpad: (request: ExecuteScratchpadRequest) => Promise<null>;
   sendInterrupt: () => Promise<null>;
   sendShutdown: () => Promise<null>;

package/src/core/notebook/replica/__tests__/fixtures.ts

@@ -20,16 +20,30 @@ export type FakeSave = (
   ...args: Parameters<Commands["save"]>
 ) => ReturnType<Commands["save"]>;
 
-/** A backend over `transport` whose commands go to `edit` and `save`. */
+export type FakeRun = (
+  notebookId: Protocol.NotebookId,
+  ...args: Parameters<Commands["run"]>
+) => ReturnType<Commands["run"]>;
+
+export type FakeInput = (
+  notebookId: Protocol.NotebookId,
+  ...args: Parameters<Commands["input"]>
+) => ReturnType<Commands["input"]>;
+
+/** A backend over `transport` whose commands go to the given fakes. */
 export function fakeBackend({
   transport = async () => undefined,
   edit = vi.fn<FakeEdit>(),
   save = vi.fn<FakeSave>(),
+  run = vi.fn<FakeRun>(),
+  input = vi.fn<FakeInput>(),
   checkHealth,
 }: {
   transport?: NotebookTransport;
   edit?: FakeEdit;
   save?: FakeSave;
+  run?: FakeRun;
+  input?: FakeInput;
   checkHealth?: () => Promise<boolean>;
 } = {}): NotebookBackend {
   return {
@@ -37,6 +51,8 @@ export function fakeBackend({
     notebook: (notebookId) => ({
       edit: (...args) => edit(notebookId, ...args),
       save: (...args) => save(notebookId, ...args),
+      run: (...args) => run(notebookId, ...args),
+      input: (...args) => input(notebookId, ...args),
     }),
     checkHealth,
   };

package/src/core/notebook/replica/backend.ts

@@ -13,7 +13,9 @@ export interface NotebookBackend {
    *
    * Method presence is not permission. The notebook advertises its operations.
    */
-  notebook(id: NotebookId): Pick<NotebookClient, "edit" | "save">;
+  notebook(
+    id: NotebookId,
+  ): Pick<NotebookClient, "edit" | "save" | "run" | "input">;
   /** Whether the host is reachable before an explicit reconnect. Absent means always. */
   checkHealth?(): Promise<boolean>;
 }

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

@@ -509,6 +509,42 @@ describe("RuntimeManager", () => {
     });
   });
 
+  describe("start", () => {
+    it("starts once and lets later callers join the same attempt", async () => {
+      const runtime = new RuntimeManager(mockConfig, true);
+      const healthySpy = vi
+        .spyOn(runtime, "reconcileFromHealth")
+        .mockResolvedValue(true);
+
+      await Promise.all([runtime.start(), runtime.start()]);
+
+      expect(healthySpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("tries again after an attempt gave up", async () => {
+      const runtime = new RuntimeManager(mockConfig, true);
+      const healthySpy = vi
+        .spyOn(runtime, "reconcileFromHealth")
+        .mockResolvedValue(false);
+      vi.spyOn(runtime, "init").mockImplementation(async () => {
+        await runtime.reconcileFromHealth();
+        throw new Error("Failed to connect after 25 retries");
+      });
+
+      await expect(runtime.start()).rejects.toThrow("Failed to connect");
+      healthySpy.mockResolvedValue(true);
+      vi.spyOn(runtime, "init").mockImplementation(async () => {
+        await runtime.reconcileFromHealth();
+        await runtime.waitForHealthy().catch(() => undefined);
+      });
+
+      // The second attempt is a new one, not the old failure replayed.
+      vi.spyOn(runtime, "waitForHealthy").mockResolvedValue(undefined);
+      await expect(runtime.start()).resolves.toBeUndefined();
+      expect(healthySpy).toHaveBeenCalledTimes(2);
+    });
+  });
+
   describe("headers", () => {
     it("should return headers with auth token", () => {
       const runtime = new RuntimeManager(mockConfig);

package/src/core/runtime/config.ts

@@ -1,8 +1,10 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { atom, useAtom, useAtomValue } from "jotai";
 import useEvent from "react-use-event-hook";
+import { prettyError } from "@/utils/errors";
 import { Logger } from "@/utils/Logger";
 import { connectionAtom } from "../network/connection";
+import { ConnectionClosedReason } from "../notebook/replica";
 import { store } from "../state/jotai";
 import { isAppNotStarted } from "../session/connection-utils";
 import { ConnectionState } from "../session/types";
@@ -37,7 +39,7 @@ export function useConnectToRuntime(): () => Promise<void> {
   return useEvent(async () => {
     if (isAppNotStarted(connection.state)) {
       setConnection({ state: ConnectionState.CONNECTING });
-      await runtimeManager.init();
+      await runtimeManager.start();
     } else {
       Logger.log("Runtime already started or starting...");
     }
@@ -51,6 +53,39 @@ export function getRuntimeManager(): RuntimeManager {
   return store.get(runtimeManagerAtom);
 }
 
+/**
+ * Start a lazy runtime the first time something needs it.
+ *
+ * The connection can already read as connecting before anyone has asked
+ * for the runtime, because the notebook stream waits for the runtime's
+ * health and the editor mirrors that wait. So whether the runtime has
+ * been asked to start is the runtime's own business, and this only keeps
+ * the connection state honest around the attempt. A start that gives up
+ * closes the connection with the reason, which leaves the user a way to
+ * reconnect instead of a connection that looks like it is still coming up.
+ */
+export async function startRuntimeIfLazy(): Promise<void> {
+  const runtimeManager = getRuntimeManager();
+  if (runtimeManager.isServerless || !runtimeManager.isLazy) {
+    return;
+  }
+  if (isAppNotStarted(store.get(connectionAtom).state)) {
+    store.set(connectionAtom, { state: ConnectionState.CONNECTING });
+  }
+  try {
+    await runtimeManager.start();
+  } catch (error) {
+    if (store.get(connectionAtom).state === ConnectionState.CONNECTING) {
+      store.set(connectionAtom, {
+        state: ConnectionState.CLOSED,
+        code: ConnectionClosedReason.KERNEL_STARTUP_ERROR,
+        reason: prettyError(error),
+      });
+    }
+    throw error;
+  }
+}
+
 export function asRemoteURL(path: string): URL {
   if (path.startsWith("http")) {
     return new URL(path);

package/src/core/runtime/runtime.ts

@@ -14,6 +14,7 @@ const knownQueryParams = new Set(Object.values(KnownQueryParams));
 
 export class RuntimeManager {
   private initialHealthyCheck = new Deferred<void>();
+  private starting: Promise<void> | undefined;
   private config: RuntimeConfig;
   private lazy: boolean;
 
@@ -47,7 +48,7 @@ export class RuntimeManager {
     return this.httpURL.origin === window.location.origin;
   }
 
-  private get isServerless(): boolean {
+  public get isServerless(): boolean {
     return isWasm() || isIslands() || isStaticNotebook();
   }
 
@@ -345,6 +346,25 @@ export class RuntimeManager {
     return this.initialHealthyCheck.promise;
   }
 
+  /**
+   * Start the runtime once and wait until it is healthy.
+   *
+   * A run, the connect button, and the notebook stream can each ask for
+   * the runtime, so the first call starts it and later calls join that
+   * attempt. An attempt that gave up is forgotten, so the next call tries
+   * again instead of failing on the old result.
+   */
+  public start(): Promise<void> {
+    this.starting ??= this.init()
+      .then(() => this.waitForHealthy())
+      .catch((error: unknown) => {
+        this.starting = undefined;
+        this.initialHealthyCheck = new Deferred<void>();
+        throw error;
+      });
+    return this.starting;
+  }
+
   public headers(): KnownHeaders {
     const headers: KnownHeaders = {
       "Marimo-Session-Id": getSessionId(),

package/src/core/transports/static.ts

@@ -2,7 +2,6 @@
 
 /** A backend that serves a document snapshot without a host. */
 
-import type { NotebookClient } from "@marimo-team/client";
 import type * as Protocol from "@marimo-team/client/protocol";
 import type { NotebookBackend } from "../notebook/replica";
 
@@ -151,10 +150,10 @@ export function createStaticNotebookBackend(
         }
       }),
     notebook: () => {
-      const unsupported: NotebookClient["save"] = async (options) => {
+      const unsupported = async (options?: { signal?: AbortSignal }) => {
         options?.signal?.throwIfAborted();
         return {
-          ok: false,
+          ok: false as const,
           status: 501,
           problem: {
             type: "tag:marimo.io,2026:host/unsupported-operation",
@@ -167,6 +166,8 @@ export function createStaticNotebookBackend(
       return {
         edit: (_changes, options) => unsupported(options),
         save: unsupported,
+        run: unsupported,
+        input: (_inputId, _reply, options) => unsupported(options),
       };
     },
   };

package/src/core/wasm/bridge.ts

@@ -5,7 +5,6 @@ import { createRPCRequestHandler } from "rpc-anywhere";
 import { toast } from "@/components/ui/use-toast";
 import { userConfigAtom } from "@/core/config/config";
 import { serializeBlob } from "@/utils/blob";
-import { Arrays } from "@/utils/arrays";
 import { Deferred } from "@/utils/Deferred";
 import { throwNotImplemented } from "@/utils/functions";
 import { Logger } from "@/utils/Logger";
@@ -341,22 +340,6 @@ export class PyodideBridge implements RunRequests, EditRequests {
     throwNotImplemented();
   };
 
-  public sendRun: EditRequests["sendRun"] = async (request) => {
-    await this.rpc.proxy.request.loadPackages(request.codes.join("\n"));
-
-    await this.putControlRequest({
-      type: "execute-cells",
-      request: request.request,
-      executionRequests: Arrays.zip(request.cellIds, request.codes).map(
-        ([cellId, code]) => ({
-          type: "execute-cell",
-          cellId,
-          code,
-        }),
-      ),
-    });
-    return null;
-  };
   public sendRunScratchpad: EditRequests["sendRunScratchpad"] = async (
     request,
   ) => {

package/dist/assets/__vite-browser-external-DzTYIHH_.js

@@ -1 +0,0 @@
-import{t as e}from"./worker-BH08I2Il.js";var t=/* @__PURE__ */ e(((e,t)=>{t.exports={}}));export default t();