@marimo-team/islands 0.23.6-dev8 → 0.23.6

package/src/core/cells/__tests__/document-changes.test.ts

@@ -203,6 +203,8 @@ describe("toDocumentChanges", () => {
         [
           {
             "cellId": "0",
+            "column": null,
+            "disabled": false,
             "hideCode": true,
             "type": "set-config",
           },
@@ -246,6 +248,8 @@ describe("toDocumentChanges", () => {
           {
             "cellId": "1",
             "column": 1,
+            "disabled": false,
+            "hideCode": false,
             "type": "set-config",
           },
           {
@@ -273,11 +277,15 @@ describe("toDocumentChanges", () => {
           {
             "cellId": "1",
             "column": 1,
+            "disabled": false,
+            "hideCode": false,
             "type": "set-config",
           },
           {
             "cellId": "2",
             "column": 1,
+            "disabled": false,
+            "hideCode": false,
             "type": "set-config",
           },
           {
@@ -310,11 +318,15 @@ describe("toDocumentChanges", () => {
           {
             "cellId": "1",
             "column": 0,
+            "disabled": false,
+            "hideCode": false,
             "type": "set-config",
           },
           {
             "cellId": "2",
             "column": 0,
+            "disabled": false,
+            "hideCode": false,
             "type": "set-config",
           },
           {
@@ -358,6 +370,8 @@ describe("toDocumentChanges", () => {
           {
             "cellId": "1",
             "column": 1,
+            "disabled": false,
+            "hideCode": false,
             "type": "set-config",
           },
           {

package/src/core/cells/document-changes.ts

@@ -156,10 +156,13 @@ function columnChanges(
   for (const [cellId, newCol] of newColumns) {
     const prevCol = prevColumns.get(cellId);
     if (prevCol !== newCol) {
+      const cell = getCell(cellId, newState);
       changes.push({
         type: "set-config",
         cellId: cellId,
         column: newCol,
+        disabled: cell?.config.disabled ?? false,
+        hideCode: cell?.config.hide_code ?? false,
       });
     }
   }
@@ -257,18 +260,21 @@ export function toDocumentChanges(
     }
 
     // updateCellConfig → set-config
-    // Maps CellConfig's snake_case hide_code to the change's camelCase hideCode.
-    // Only includes fields that were actually specified in the partial config
-    // (from the action payload, not the full cell config).
+    // SetConfig is full-replacement: emit the cell's complete config from
+    // newState (which already merged the action's partial payload).
     case "updateCellConfig": {
-      const { cellId, config } = action.payload;
+      const { cellId } = action.payload;
+      const cell = getCell(cellId, newState);
+      if (!cell) {
+        return [];
+      }
       return [
         {
           type: "set-config",
           cellId: cellId,
-          ...(config.hide_code != null && { hideCode: config.hide_code }),
-          ...(config.disabled != null && { disabled: config.disabled }),
-          ...(config.column != null && { column: config.column }),
+          column: cell.config.column ?? null,
+          disabled: cell.config.disabled ?? false,
+          hideCode: cell.config.hide_code ?? false,
         },
       ];
     }
@@ -538,18 +544,15 @@ export function fromDocumentChanges(
         break;
 
       // set-config → updateCellConfig
-      // Maps the change's camelCase hideCode back to CellConfig's snake_case
-      // hide_code. Only includes fields that are non-null (null means
-      // "not specified" on the wire, not "clear the value").
       case "set-config":
         actions.push({
           type: "updateCellConfig",
           payload: {
             cellId: change.cellId,
             config: {
-              ...(change.hideCode != null && { hide_code: change.hideCode }),
-              ...(change.disabled != null && { disabled: change.disabled }),
-              ...(change.column != null && { column: change.column }),
+              column: change.column,
+              disabled: change.disabled,
+              hide_code: change.hideCode,
             },
           },
         });
@@ -650,7 +653,7 @@ export function applyTransactionChanges(
     ) {
       continue;
     }
-    if (change.type === "set-config" && change.column != null) {
+    if (change.type === "set-config") {
       hasColumnChange = true;
     }
     if (change.type === "create-cell" && change.config?.column != null) {

package/src/core/codemirror/markdown/__tests__/commands.test.ts

@@ -385,6 +385,42 @@ describe("insertImage", () => {
     );
   });
 
+  test("normalizes Windows backslash paths to forward slashes in image URL", async () => {
+    view = createEditor("Hello, world!");
+    view.dispatch({
+      selection: { anchor: 7, head: 7 },
+    });
+
+    vi.spyOn(store, "get").mockImplementation((atom) => {
+      if (atom === filenameAtom) {
+        return "C:\\Users\\user\\project\\notebook.py";
+      }
+      if (atom === requestClientAtom) {
+        return mockRequestClient;
+      }
+    });
+
+    mockRequestClient.sendCreateFileOrFolder.mockResolvedValueOnce({
+      success: true,
+      message: null,
+      info: {
+        path: "C:\\Users\\user\\project\\public\\hello.png",
+        name: "hello.png",
+        children: [],
+        id: "",
+        isDirectory: false,
+        isMarimoFile: false,
+        lastModified: null,
+      },
+    });
+
+    await insertImage(view, mockPngFile());
+
+    expect(view.state.doc.toString()).toMatchInlineSnapshot(
+      `"Hello, ![alt](public/hello.png)world!"`,
+    );
+  });
+
   test("saves image as file different extension", async () => {
     view = createEditor("Hello, world!");
     view.dispatch({

package/src/core/codemirror/markdown/commands.ts

@@ -360,7 +360,10 @@ export async function insertImage(view: EditorView, file: File) {
             notebookDir &&
             savedFilePath.startsWith(notebookDir)
           ) {
-            savedFilePath = Paths.rest(savedFilePath, notebookDir);
+            savedFilePath = Paths.rest(savedFilePath, notebookDir).replaceAll(
+              "\\",
+              "/",
+            );
           }
 
           toast({

package/src/core/config/config-schema.ts

@@ -166,6 +166,7 @@ export const UserConfigSchema = z
         ollama: AiConfigSchema.optional(),
         openrouter: AiConfigSchema.optional(),
         wandb: AiConfigSchema.optional(),
+        opencode_go: AiConfigSchema.optional(),
         open_ai_compatible: AiConfigSchema.optional(),
         azure: AiConfigSchema.optional(),
         bedrock: z

package/src/core/edit-app.tsx

@@ -137,6 +137,7 @@ export const EditApp: React.FC<AppProps> = ({
       mode={viewState.mode}
       userConfig={userConfig}
       appConfig={appConfig}
+      hideControls={hideControls}
     />
   );
 

package/src/core/run-app.tsx

@@ -10,7 +10,11 @@ import { buttonVariants } from "@/components/ui/button";
 import { DelayMount } from "@/components/utils/delay-mount";
 import { cn } from "@/utils/cn";
 import { CellsRenderer } from "../components/editor/renderers/cells-renderer";
-import { notebookIsRunningAtom, useCellActions } from "./cells/cells";
+import {
+  hasCellsAtom,
+  notebookIsRunningAtom,
+  useCellActions,
+} from "./cells/cells";
 import type { AppConfig } from "./config/config-schema";
 import { RuntimeState } from "./kernel/RuntimeState";
 import { getSessionId } from "./kernel/session";
@@ -42,10 +46,13 @@ export const RunApp: React.FC<AppProps> = ({ appConfig }) => {
 
   const isRunning = useAtomValue(notebookIsRunningAtom);
   const isConnecting = isAppConnecting(connection.state);
+  // Skip the "Connecting..." gate when we already have cells to show — from
+  // an embedded snapshot or a prior connection.
+  const hasExistingCells = useAtomValue(hasCellsAtom);
 
   const renderCells = () => {
     // If we are connecting for more than 2 seconds, show a spinner
-    if (isConnecting) {
+    if (isConnecting && !hasExistingCells) {
       return (
         <DelayMount milliseconds={2000} fallback={null}>
           <Spinner className="mx-auto" />

package/src/core/runtime/runtime.ts

@@ -5,6 +5,7 @@ import { Logger } from "@/utils/Logger";
 import { KnownQueryParams } from "../constants";
 import { isIslands } from "../islands/utils";
 import { getSessionId, type SessionId } from "../kernel/session";
+import { isStaticNotebook } from "../static/static-state";
 import { isWasm } from "../wasm/utils";
 import type { RuntimeConfig } from "./types";
 
@@ -178,8 +179,8 @@ export class RuntimeManager {
   }
 
   async isHealthy(): Promise<boolean> {
-    // Always healthy if WASM
-    if (isWasm() || isIslands()) {
+    // Always healthy if WASM, Islands, or a static notebook (no server)
+    if (isWasm() || isIslands() || isStaticNotebook()) {
       return true;
     }
 

package/src/core/static/static-state.ts

@@ -43,7 +43,11 @@ function isMarimoStaticState(
 }
 
 function getMarimoStaticState(): Readonly<MarimoStaticState> | undefined {
-  const state = window?.__MARIMO_STATIC__;
+  // `typeof window` guard handles the identifier-undeclared case (e.g.
+  // leaked async work firing after jsdom teardown in tests); `?.` only
+  // short-circuits on null/undefined.
+  const state =
+    typeof window === "undefined" ? undefined : window.__MARIMO_STATIC__;
   return isMarimoStaticState(state) ? state : undefined;
 }
 

package/src/core/wasm/PyodideLoader.tsx

@@ -3,13 +3,18 @@
 import { useAtomValue } from "jotai";
 import type React from "react";
 import type { PropsWithChildren } from "react";
+import { useEffect, useRef } from "react";
 import { LargeSpinner } from "@/components/icons/large-spinner";
+import { toast } from "@/components/ui/use-toast";
+import { hasCellsAtom } from "@/core/cells/cells";
 import { showCodeInRunModeAtom } from "@/core/meta/state";
 import { store } from "@/core/state/jotai";
 import { useAsyncData } from "@/hooks/useAsyncData";
+import { prettyError } from "@/utils/errors";
+import { Logger } from "@/utils/Logger";
 import { hasQueryParam } from "@/utils/urls";
 import { KnownQueryParams } from "../constants";
-import { getInitialAppMode } from "../mode";
+import { type AppMode, getInitialAppMode } from "../mode";
 import { PyodideBridge } from "./bridge";
 import { hasAnyOutputAtom, wasmInitializationAtom } from "./state";
 import { isWasm } from "./utils";
@@ -26,30 +31,44 @@ export const PyodideLoader: React.FC<PropsWithChildren> = ({ children }) => {
 };
 
 const PyodideLoaderInner: React.FC<PropsWithChildren> = ({ children }) => {
-  // isPyodide() is constant, so this is safe
-  const { isPending, error } = useAsyncData(async () => {
+  // Don't block render on Pyodide: a hydrated snapshot can paint immediately
+  // while Pyodide downloads in the background.
+  const { error } = useAsyncData(async () => {
     await PyodideBridge.INSTANCE.initialized.promise;
     return true;
   }, []);
 
+  const hasCells = useAtomValue(hasCellsAtom);
   const hasOutput = useAtomValue(hasAnyOutputAtom);
+  const nothingToShow = shouldShowSpinner({
+    hasCells,
+    hasOutput,
+    mode: getInitialAppMode(),
+    codeHidden: isCodeHidden(),
+  });
 
-  if (isPending) {
-    return <WasmSpinner />;
-  }
+  const didToastErrorRef = useRef(false);
+  useEffect(() => {
+    // With snapshot content on-screen, toast instead of throwing so the
+    // snapshot stays readable. The ref ensures we only toast once even if
+    // nothingToShow toggles later.
+    if (error && !nothingToShow && !didToastErrorRef.current) {
+      didToastErrorRef.current = true;
+      Logger.error("Pyodide failed to initialize", error);
+      toast({
+        title: "Failed to start the notebook runtime",
+        description: prettyError(error),
+        variant: "danger",
+      });
+    }
+  }, [error, nothingToShow]);
 
-  // If ALL are true:
-  // - are in read mode
-  // - we are not showing the code
-  // - and there is no output
-  // then show the spinner
-  if (!hasOutput && getInitialAppMode() === "read" && isCodeHidden()) {
-    return <WasmSpinner />;
+  if (error && nothingToShow) {
+    throw error;
   }
 
-  // Propagate back up to our error boundary
-  if (error) {
-    throw error;
+  if (nothingToShow) {
+    return <WasmSpinner />;
   }
 
   return children;
@@ -65,6 +84,25 @@ function isCodeHidden() {
   );
 }
 
+/**
+ * Pure predicate: should the WASM loader render a spinner instead of its
+ * children? We block render only when nothing user-visible would appear:
+ *   - no cells have been hydrated (Pyodide hasn't parsed the notebook), or
+ *   - we are in headless run mode (code hidden) with no outputs to display.
+ */
+export function shouldShowSpinner(input: {
+  hasCells: boolean;
+  hasOutput: boolean;
+  mode: AppMode;
+  codeHidden: boolean;
+}): boolean {
+  const { hasCells, hasOutput, mode, codeHidden } = input;
+  if (!hasCells) {
+    return true;
+  }
+  return !hasOutput && mode === "read" && codeHidden;
+}
+
 export const WasmSpinner: React.FC<PropsWithChildren> = ({ children }) => {
   const wasmInitialization = useAtomValue(wasmInitializationAtom);
 

package/src/core/wasm/__tests__/PyodideLoader.test.ts

@@ -0,0 +1,72 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, it } from "vitest";
+import { shouldShowSpinner } from "../PyodideLoader";
+
+describe("shouldShowSpinner", () => {
+  it("shows the spinner when there are no cells yet (Pyodide hasn't parsed)", () => {
+    expect(
+      shouldShowSpinner({
+        hasCells: false,
+        hasOutput: false,
+        mode: "read",
+        codeHidden: false,
+      }),
+    ).toBe(true);
+
+    expect(
+      shouldShowSpinner({
+        hasCells: false,
+        hasOutput: true,
+        mode: "edit",
+        codeHidden: false,
+      }),
+    ).toBe(true);
+  });
+
+  it("renders children once cells exist with code visible", () => {
+    // run mode, code visible, no outputs yet — the user can read the code
+    expect(
+      shouldShowSpinner({
+        hasCells: true,
+        hasOutput: false,
+        mode: "read",
+        codeHidden: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("renders children once cells exist with cached outputs (snapshot case)", () => {
+    expect(
+      shouldShowSpinner({
+        hasCells: true,
+        hasOutput: true,
+        mode: "read",
+        codeHidden: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("keeps the spinner up in headless run mode with no outputs", () => {
+    // read mode + code hidden + no outputs = nothing visible to render
+    expect(
+      shouldShowSpinner({
+        hasCells: true,
+        hasOutput: false,
+        mode: "read",
+        codeHidden: true,
+      }),
+    ).toBe(true);
+  });
+
+  it("never blocks edit mode once cells exist", () => {
+    expect(
+      shouldShowSpinner({
+        hasCells: true,
+        hasOutput: false,
+        mode: "edit",
+        codeHidden: true,
+      }),
+    ).toBe(false);
+  });
+});

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

@@ -58,7 +58,7 @@ vi.mock("@/core/wasm/store", () => ({
 // Import after all mocks are set up
 import { store } from "@/core/state/jotai";
 import { initialModeAtom } from "@/core/mode";
-import { PyodideBridge } from "../bridge";
+import { getWasmWorkerName, PyodideBridge } from "../bridge";
 
 // Access INSTANCE once at module level so the constructor runs (and
 // addMessageListener populates rpcListeners) before any test executes.
@@ -111,3 +111,28 @@ describe("PyodideBridge.readCode", () => {
     expect(mockNotebookReadFile).not.toHaveBeenCalled();
   });
 });
+
+describe("getWasmWorkerName", () => {
+  afterEach(() => {
+    delete (window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: boolean })
+      .__MARIMO_HAS_WASM_CONTROLLER__;
+  });
+
+  it("returns the version without suffix by default", () => {
+    expect(getWasmWorkerName()).toBe("0.0.0-test");
+  });
+
+  it("appends ::controller when the host opts in", () => {
+    (
+      window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: boolean }
+    ).__MARIMO_HAS_WASM_CONTROLLER__ = true;
+    expect(getWasmWorkerName()).toBe("0.0.0-test::controller");
+  });
+
+  it("does not append the suffix for non-true values", () => {
+    (
+      window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: unknown }
+    ).__MARIMO_HAS_WASM_CONTROLLER__ = "true";
+    expect(getWasmWorkerName()).toBe("0.0.0-test");
+  });
+});

package/src/core/wasm/bridge.ts

@@ -37,7 +37,7 @@ import type { IConnectionTransport } from "../websocket/transports/transport";
 import { PyodideRouter } from "./router";
 import { getWorkerRPC } from "./rpc";
 import { createShareableLink } from "./share";
-import { wasmInitializationAtom } from "./state";
+import { wasmInitializationAtom, wasmInitStatusAtom } from "./state";
 import { fallbackFileStore, notebookFileStore } from "./store";
 import { isWasm } from "./utils";
 import type { SaveWorkerSchema } from "./worker/save-worker";
@@ -81,9 +81,9 @@ export class PyodideBridge implements RunRequests, EditRequests {
       new URL("./worker/save-worker.ts", import.meta.url),
       {
         type: "module",
-        // Pass the version to the worker
+        // Pass the version (and optional capability suffix) to the worker
         /* @vite-ignore */
-        name: getMarimoVersion(),
+        name: getWasmWorkerName(),
       },
     );
 
@@ -101,9 +101,9 @@ export class PyodideBridge implements RunRequests, EditRequests {
       new URL("./worker/worker.ts", import.meta.url),
       {
         type: "module",
-        // Pass the version to the worker
+        // Pass the version (and optional capability suffix) to the worker
         /* @vite-ignore */
-        name: getMarimoVersion(),
+        name: getWasmWorkerName(),
       },
     );
 
@@ -119,13 +119,15 @@ export class PyodideBridge implements RunRequests, EditRequests {
       // By initializing after, we get hits on cached network requests
       this.saveRpc = this.getSaveWorker();
       this.setInterruptBuffer();
+      store.set(wasmInitStatusAtom, "ready");
       this.initialized.resolve();
     });
     this.rpc.addMessageListener("initializingMessage", ({ message }) => {
       store.set(wasmInitializationAtom, message);
     });
     this.rpc.addMessageListener("initializedError", ({ error }) => {
-      // If already resolved, show a toast
+      // If already initialized, surface as a toast and leave the deferred /
+      // init status alone — the worker is healthy, this is a runtime error.
       if (this.initialized.status === "resolved") {
         Logger.error(error);
         toast({
@@ -133,7 +135,9 @@ export class PyodideBridge implements RunRequests, EditRequests {
           description: error,
           variant: "danger",
         });
+        return;
       }
+      store.set(wasmInitStatusAtom, "error");
       this.initialized.reject(new Error(error));
     });
     this.rpc.addMessageListener("kernelMessage", ({ message }) => {
@@ -634,3 +638,17 @@ export function createPyodideConnection(): IConnectionTransport {
     PyodideBridge.INSTANCE.attachMessageConsumer(callback);
   });
 }
+
+// Compose the worker name. The version prefix is read by getMarimoVersion()
+// in the worker; the optional "::controller" suffix tells getController.ts
+// that the host page provides a custom /wasm/controller.js and that the
+// dynamic import should be attempted. Hosts opt in by setting
+// `window.__MARIMO_HAS_WASM_CONTROLLER__ = true` before
+// PyodideBridge/worker initialization.
+export function getWasmWorkerName(): string {
+  const hasCustomController =
+    typeof window !== "undefined" &&
+    (window as unknown as { __MARIMO_HAS_WASM_CONTROLLER__?: boolean })
+      .__MARIMO_HAS_WASM_CONTROLLER__ === true;
+  return getMarimoVersion() + (hasCustomController ? "::controller" : "");
+}

package/src/core/wasm/state.ts

@@ -5,6 +5,9 @@ import { isOutputEmpty } from "../cells/outputs";
 
 export const wasmInitializationAtom = atom<string>("Initializing...");
 
+export type WasmInitStatus = "loading" | "ready" | "error";
+export const wasmInitStatusAtom = atom<WasmInitStatus>("loading");
+
 export const hasAnyOutputAtom = atom<boolean>((get) => {
   const notebook = get(notebookAtom);
   const runtimeStates = Object.values(notebook.cellRuntime);

package/src/core/wasm/worker/getController.ts

@@ -5,6 +5,13 @@ import type { WasmController } from "./types";
 // Load the controller
 // Falls back to the default controller
 export async function getController(version: string): Promise<WasmController> {
+  // Hosts that provide a custom /wasm/controller.js opt in via the worker
+  // name (see bridge.ts). Default: skip the dynamic import to avoid a
+  // guaranteed-404 round trip on the standard build.
+  const hasCustomController = self.name?.includes("::controller") ?? false;
+  if (!hasCustomController) {
+    return new DefaultWasmController();
+  }
   try {
     const controller = await import(
       /* @vite-ignore */ `/wasm/controller.js?version=${version}`

package/src/core/wasm/worker/save-worker.ts

@@ -103,5 +103,6 @@ const rpc = createRPC<SaveWorkerSchema, ParentSchema>({
 rpc.send("ready", {});
 
 function getMarimoVersion() {
-  return self.name; // We store the version in the worker name
+  // Worker name is "<version>" or "<version>::<capability>" — see bridge.ts.
+  return self.name.split("::")[0];
 }

package/src/core/wasm/worker/worker.ts

@@ -375,7 +375,8 @@ const namesThatRequireSync = new Set<keyof RawBridge>([
 ]);
 
 function getMarimoVersion() {
-  return self.name; // We store the version in the worker name
+  // Worker name is "<version>" or "<version>::<capability>" — see bridge.ts.
+  return self.name.split("::")[0];
 }
 
 const pyodideReadyPromise = t.wrapAsync(loadPyodideAndPackages)();