@marimo-team/islands 0.25.3-dev322 → 0.25.3-dev348

package/src/components/editor/chrome/wrapper/__tests__/document-sync-status.test.tsx

@@ -20,15 +20,18 @@ afterEach(() => {
 });
 
 const conflict = {
-  ok: false as const,
-  status: 409,
+  ok: false,
+  status: 412,
   problem: {
-    type: "tag:marimo.io,2026:host/conflict",
-    title: "Conflict",
-    status: 409,
+    type: "urn:marimo:problem:precondition-failed",
+    title: "Precondition failed",
+    status: 412,
     detail: "cell c1 has changed since it was read.",
+    index: 0,
+    cell: document().cells.get("c1")!,
+    document: document().revision,
   },
-};
+} satisfies Awaited<ReturnType<FakeEdit>>;
 
 function setup(edit: FakeEdit) {
   const store = createStore();

package/src/components/slides/slide-cell-view.tsx

@@ -117,7 +117,8 @@ export const SlideCellView = ({ cell }: { cell: RuntimeCell }) => {
         code={cell.code}
         editorViewRef={editorViewRef}
         currentLanguageAdapter={languageAdapter}
-        onAfterToggle={afterToggleLanguage}
+        onAfterToggleSQL={afterToggleLanguage}
+        onAfterToggleMarkdown={afterToggleLanguage}
         className="flex items-center gap-1"
       />
       <div className="flex items-center shadow-none gap-1">

package/src/components/ui/__tests__/fullscreen.test.tsx

@@ -1,8 +1,63 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { act, render, renderHook } from "@testing-library/react";
 import { useRef } from "react";
+import { createPortal } from "react-dom";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useFullScreenClass, useIsFullScreen } from "../fullscreen";
+import {
+  useFullScreenClass,
+  useFullScreenElement,
+  useIsFullScreen,
+  withFullScreenAsRoot,
+} from "../fullscreen";
+
+describe("full screen element inside a shadow root", () => {
+  let host: HTMLElement;
+  let target: HTMLElement;
+
+  beforeEach(() => {
+    host = document.createElement("div");
+    host.append(document.createElement("div"));
+    const shadowRoot = host.attachShadow({ mode: "open" });
+    target = document.createElement("div");
+    shadowRoot.append(target);
+    document.body.append(host);
+
+    // The browser retargets document.fullscreenElement to the shadow host and
+    // reports the element itself on the shadow root.
+    Object.defineProperty(document, "fullscreenElement", {
+      configurable: true,
+      get: () => host,
+    });
+    Object.defineProperty(shadowRoot, "fullscreenElement", {
+      configurable: true,
+      get: () => target,
+    });
+  });
+
+  afterEach(() => {
+    Reflect.deleteProperty(document, "fullscreenElement");
+    host.remove();
+  });
+
+  it("resolves the element that is actually full screen", () => {
+    const { result } = renderHook(useFullScreenElement);
+    expect(result.current).toBe(target);
+  });
+
+  it("portals into that element, not the host's light DOM", () => {
+    const Portal = withFullScreenAsRoot(
+      ({ container }: { container?: Element | DocumentFragment | null }) =>
+        createPortal(
+          <span data-testid="portalled" />,
+          container ?? document.body,
+        ),
+    );
+    render(<Portal />);
+
+    expect(host.children).toHaveLength(1);
+    expect(target.querySelector('[data-testid="portalled"]')).not.toBeNull();
+  });
+});
 
 describe("useFullScreenClass", () => {
   let fullscreenElement: Element | null = null;

package/src/components/ui/fullscreen.tsx

@@ -38,15 +38,31 @@ export function useFullScreenClass() {
   }, []);
 }
 
+/**
+ * The element that is actually full screen.
+ *
+ * `document.fullscreenElement` is retargeted to the outermost shadow host, so
+ * for a target inside a plugin's shadow root it reports the plugin host.
+ * Portalling into the host appends to its light DOM, which is not rendered and
+ * which the host observes to rebuild its children.
+ */
+export function getFullScreenElement(): Element | null {
+  let element = document.fullscreenElement;
+  while (element?.shadowRoot?.fullscreenElement) {
+    element = element.shadowRoot.fullscreenElement;
+  }
+  return element;
+}
+
 /**
  * Get the full screen element if we are in full screen mode
  */
 export function useFullScreenElement() {
   const [fullScreenElement, setFullScreenElement] = useState<Element | null>(
-    document.fullscreenElement,
+    getFullScreenElement,
   );
   useEventListener(document, "fullscreenchange", () => {
-    setFullScreenElement(document.fullscreenElement);
+    setFullScreenElement(getFullScreenElement());
   });
   return fullScreenElement;
 }

package/src/components/ui/slider.tsx

@@ -18,8 +18,9 @@ const Slider = React.forwardRef<
   React.ElementRef<typeof SliderPrimitive.Root>,
   React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> & {
     valueMap: (sliderValue: number) => number;
+    maximumFractionDigits?: number;
   }
->(({ className, valueMap, ...props }, ref) => {
+>(({ className, valueMap, maximumFractionDigits, ...props }, ref) => {
   const [open, openActions] = useBoolean(false);
   const { locale } = useLocale();
 
@@ -70,7 +71,10 @@ const Slider = React.forwardRef<
           <TooltipPortal>
             {props.value != null && props.value.length === 1 && (
               <TooltipContent key={props.value[0]}>
-                {prettyScientificNumber(valueMap(props.value[0]), { locale })}
+                {prettyScientificNumber(valueMap(props.value[0]), {
+                  locale,
+                  maximumFractionDigits,
+                })}
               </TooltipContent>
             )}
           </TooltipPortal>

package/src/core/codemirror/copilot/getCodes.ts

@@ -9,7 +9,7 @@ import type { Variables } from "@/core/variables/types";
 import { Objects } from "@/utils/objects";
 import { getEditorCodeAsPython } from "../language/utils";
 
-const notebookCellCodes = atom((get) => {
+export const notebookCellCodes = atom((get) => {
   const notebook = get(notebookAtom);
   const codes = Objects.fromEntries(
     notebook.cellIds.map((id) => {

package/src/core/edit-app.tsx

@@ -27,7 +27,8 @@ import { CellArray } from "../components/editor/renderers/cell-array";
 import { CellsRenderer } from "../components/editor/renderers/cells-renderer";
 import { useHotkey } from "../hooks/useHotkey";
 import { hasCellsAtom } from "./cells/cells";
-import { notebookIsRunningAtom } from "./executions";
+import { interruptRuntime, notebookIsRunningAtom } from "./executions";
+import { store } from "./state/jotai";
 import { numColumnsAtom } from "./cells/layout";
 import { useCellActions } from "./cells/actions";
 import type { AppConfig, UserConfig } from "./config/config-schema";
@@ -73,7 +74,7 @@ export const EditApp: React.FC<EditAppProps> = ({
   const viewState = useAtomValue(viewStateAtom);
   const numColumns = useAtomValue(numColumnsAtom);
   const filename = useFilename();
-  const { sendComponentValues, sendInterrupt } = useRequestClient();
+  const { sendComponentValues } = useRequestClient();
 
   const isEditing = viewState.mode === "edit";
   const isPresenting = viewState.mode === "present";
@@ -115,7 +116,7 @@ export const EditApp: React.FC<EditAppProps> = ({
     runStaleCells();
   });
   useHotkey("global.interrupt", () => {
-    sendInterrupt();
+    void interruptRuntime(store);
   });
   useHotkey("global.hideCode", () => {
     togglePresenting();
@@ -208,7 +209,7 @@ export const EditApp: React.FC<EditAppProps> = ({
           <Controls
             presenting={isPresenting}
             onTogglePresenting={togglePresenting}
-            onInterrupt={sendInterrupt}
+            onInterrupt={() => interruptRuntime(store)}
             onRun={runStaleCells}
             connectionState={connection.state}
             running={isRunning}

package/src/core/executions/__tests__/input.test.ts

@@ -58,7 +58,7 @@ describe("replyInput", () => {
       ok: false,
       status: 409,
       problem: {
-        type: "tag:marimo.io,2026:host/conflict",
+        type: "urn:marimo:problem:conflict",
         title: "Conflict",
         status: 409,
         detail: "input prompt-1 has already ended.",

package/src/core/executions/__tests__/interrupt.test.ts

@@ -0,0 +1,200 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { ProblemOf } from "@marimo-team/client";
+import type * as Protocol from "@marimo-team/client/protocol";
+import { createStore } from "jotai";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MockExecutions } from "@/__mocks__/executions";
+import {
+  fakeBackend,
+  type FakeInterrupt,
+} from "@/core/notebook/replica/__tests__/fixtures";
+import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
+import { interruptRuntime } from "../interrupt";
+
+type Refusal = ProblemOf<"runtime.interrupt">;
+
+const toast = vi.fn();
+vi.mock("@/components/ui/use-toast", () => ({
+  toast: (...args: unknown[]) => toast(...args),
+}));
+
+function run(
+  id: string,
+  status: Protocol.Lifecycle = "running",
+  runtimeId = "r1",
+): Protocol.Run {
+  return {
+    id,
+    notebook_id: "n1",
+    runtime_id: runtimeId,
+    cells: [],
+    status,
+    outcome: status === "completed" ? "succeeded" : null,
+    started_at: status === "queued" ? null : MockExecutions.T0,
+    completed_at: status === "completed" ? MockExecutions.T1 : null,
+  };
+}
+
+function setup(runs: Protocol.Run[]) {
+  const store = createStore();
+  const replica = MockExecutions.seed(
+    store,
+    [],
+    MockExecutions.runtime("running"),
+  );
+  const interrupt = vi.fn<FakeInterrupt>(async () => ({
+    ok: true,
+    status: 202,
+    data: MockExecutions.runtime("running"),
+  }));
+  store.set(replica.backendAtom, fakeBackend({ interrupt }));
+  store.set(replica.executionsAtom, {
+    runs: new Map(runs.map((run) => [run.id, run])),
+    executions: new Map(),
+    latest: new Map(),
+  });
+  return { store, replica, interrupt };
+}
+
+describe("interruptRuntime", () => {
+  beforeEach(() => toast.mockClear());
+
+  it.each([
+    { runs: [] },
+    { runs: [run("queued", "queued")] },
+    { runs: [run("browser"), run("code-mode"), run("queued", "queued")] },
+  ])(
+    "interrupts the runtime once regardless of recorded runs: %j",
+    async ({ runs }) => {
+      const { store, replica, interrupt } = setup(runs);
+
+      await interruptRuntime(store);
+
+      expect(interrupt.mock.calls).toEqual([["n1"]]);
+      // The stream, not the acknowledgement, determines the work's outcome.
+      expect([...store.get(replica.executionsAtom).runs.values()]).toEqual(
+        runs,
+      );
+      expect(toast).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each<Refusal>([
+    {
+      type: "urn:marimo:problem:no-runtime",
+      title: "The runtime has stopped",
+      status: 409,
+    },
+    {
+      type: "urn:marimo:problem:conflict",
+      title: "The runtime has stopped",
+      status: 409,
+    },
+  ])(
+    "tolerates a runtime that stopped before the request: $type",
+    async (problem) => {
+      const { store, interrupt } = setup([]);
+      interrupt.mockResolvedValue({
+        ok: false,
+        status: problem.status,
+        problem,
+      });
+
+      await interruptRuntime(store);
+
+      expect(interrupt.mock.calls).toEqual([["n1"]]);
+      expect(toast).not.toHaveBeenCalled();
+    },
+  );
+
+  it("sends the request even when the local runtime record is absent", async () => {
+    const { store, replica, interrupt } = setup([]);
+    store.set(replica.runtimeAtom, null);
+
+    await interruptRuntime(store);
+
+    expect(interrupt.mock.calls).toEqual([["n1"]]);
+  });
+
+  it("does nothing without a connected notebook", async () => {
+    const { store, replica, interrupt } = setup([]);
+    store.set(replica.backendAtom, null);
+    await interruptRuntime(store);
+    store.set(activeNotebookReplicaAtom, null);
+    await interruptRuntime(store);
+
+    expect(interrupt).not.toHaveBeenCalled();
+    expect(toast).not.toHaveBeenCalled();
+  });
+
+  it.each<{ problem: Refusal; toasts: unknown[] }>([
+    {
+      problem: {
+        type: "urn:marimo:problem:forbidden",
+        title: "Interrupt refused",
+        status: 403,
+      },
+      toasts: [],
+    },
+    {
+      problem: {
+        type: "urn:marimo:problem:not-found",
+        title: "Interrupt refused",
+        status: 404,
+      },
+      toasts: [
+        [
+          {
+            title: "Failed to interrupt",
+            description: "Interrupt refused",
+            variant: "danger",
+          },
+        ],
+      ],
+    },
+    {
+      problem: {
+        type: "urn:marimo:problem:internal",
+        title: "Interrupt refused",
+        status: 500,
+      },
+      toasts: [
+        [
+          {
+            title: "Failed to interrupt",
+            description: "Interrupt refused",
+            variant: "danger",
+          },
+        ],
+      ],
+    },
+  ])(
+    "handles a host refusal with status $problem.status",
+    async ({ problem, toasts }) => {
+      const { store, interrupt } = setup([run("running")]);
+      interrupt.mockResolvedValue({
+        ok: false,
+        status: problem.status,
+        problem,
+      });
+
+      await interruptRuntime(store);
+
+      expect(toast.mock.calls).toEqual(toasts);
+    },
+  );
+
+  it("reports transport failures without leaving an unhandled rejection", async () => {
+    const { store, interrupt } = setup([run("running")]);
+    interrupt.mockRejectedValue(new Error("Disconnected"));
+
+    await interruptRuntime(store);
+
+    expect(toast).toHaveBeenCalledExactlyOnceWith({
+      title: "Failed to interrupt",
+      description: "Disconnected",
+      variant: "danger",
+    });
+  });
+});

package/src/core/executions/__tests__/run.test.ts

@@ -265,7 +265,7 @@ describe("runCells", () => {
       ok: false,
       status: 409,
       problem: {
-        type: "tag:marimo.io,2026:host/conflict",
+        type: "urn:marimo:problem:conflict",
         title: "Conflict",
         status: 409,
         detail: "the runtime is starting.",
@@ -286,7 +286,7 @@ describe("runCells", () => {
       ok: false,
       status: 403,
       problem: {
-        type: "tag:marimo.io,2026:host/forbidden",
+        type: "urn:marimo:problem:forbidden",
         title: "Forbidden",
         status: 403,
       },
@@ -355,7 +355,7 @@ describe("runCells", () => {
               ok: false,
               status: 409,
               problem: {
-                type: "tag:marimo.io,2026:host/conflict",
+                type: "urn:marimo:problem:conflict",
                 title: "Conflict",
                 status: 409,
               },

package/src/core/executions/index.ts

@@ -22,6 +22,7 @@ export {
 } from "./atoms";
 export type { CellFreshness, CellFreshnessLookup } from "./freshness";
 export { replyInput } from "./input";
+export { interruptRuntime } from "./interrupt";
 export { runCells, syncEdits } from "./run";
 export {
   useCellExecution,

package/src/core/executions/interrupt.ts

@@ -0,0 +1,49 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { createStore } from "jotai";
+import { toast } from "@/components/ui/use-toast";
+import { activeNotebookReplicaAtom } from "@/core/session/active-notebook";
+import { prettyError } from "@/utils/errors";
+import { Logger } from "@/utils/Logger";
+
+/** Interrupt active runtime work and end queued runs. */
+export async function interruptRuntime(
+  store: ReturnType<typeof createStore>,
+): Promise<void> {
+  const replica = store.get(activeNotebookReplicaAtom);
+  if (replica === null) {
+    return;
+  }
+  const notebook = store.get(replica.notebookAtom);
+  const backend = store.get(replica.backendAtom);
+  if (notebook === null || backend === null) {
+    return;
+  }
+  try {
+    const result = await backend.notebook(notebook.id).interrupt();
+    if (result.ok) {
+      return;
+    }
+    // The runtime can stop before the request arrives.
+    if (result.status === 409) {
+      return;
+    }
+    if (result.status === 403) {
+      Logger.warn("Interrupt refused, connection is read-only", result.problem);
+      return;
+    }
+    Logger.error("The host refused the interrupt", result.problem);
+    toast({
+      title: "Failed to interrupt",
+      description: result.problem.detail ?? result.problem.title,
+      variant: "danger",
+    });
+  } catch (error) {
+    Logger.error("Failed to interrupt", error);
+    toast({
+      title: "Failed to interrupt",
+      description: prettyError(error),
+      variant: "danger",
+    });
+  }
+}

package/src/core/islands/bridge.ts

@@ -375,8 +375,6 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   public saveLayout = throwNotImplemented;
   public sendCopy = throwNotImplemented;
   public sendRunScratchpad = throwNotImplemented;
-  public sendStdin = throwNotImplemented;
-  public sendInterrupt = throwNotImplemented;
   public sendShutdown = throwNotImplemented;
   public sendFormat = throwNotImplemented;
   public sendInstallMissingPackages = throwNotImplemented;

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

@@ -94,13 +94,6 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponse);
     },
-    sendInterrupt: () => {
-      return getClient()
-        .POST("/api/kernel/interrupt", {
-          params: getParams(),
-        })
-        .then(handleResponseReturnNull);
-    },
     sendShutdown: () => {
       return getClient()
         .POST("/api/kernel/shutdown")
@@ -165,14 +158,6 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
-    sendStdin: (request) => {
-      return getClient()
-        .POST("/api/kernel/stdin", {
-          body: request,
-          params: getParams(),
-        })
-        .then(handleResponseReturnNull);
-    },
     sendInstallMissingPackages: (request) => {
       return getClient()
         .POST("/api/kernel/install_missing_packages", {

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

@@ -44,13 +44,11 @@ export function createStaticRequests(): EditRequests & RunRequests {
     sendRename: throwNotInEditMode,
     saveLayout: throwNotInEditMode,
     sendCopy: throwNotInEditMode,
-    sendInterrupt: throwNotInEditMode,
     sendShutdown: throwNotInEditMode,
     sendFormat: throwNotInEditMode,
     sendCodeCompletionRequest: throwNotInEditMode,
     saveUserConfig: throwNotInEditMode,
     saveAppConfig: throwNotInEditMode,
-    sendStdin: throwNotInEditMode,
     readCode: throwNotInEditMode,
     readSnippets: throwNotInEditMode,
     previewDatasetColumn: throwNotInEditMode,

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

@@ -19,13 +19,11 @@ export function createErrorToastingRequests(
     sendRename: "Failed to rename",
     saveLayout: "", // The save reports it
     sendCopy: "Failed to copy",
-    sendInterrupt: "Failed to interrupt",
     sendShutdown: "Failed to shutdown",
     sendFormat: "Failed to format",
     sendCodeCompletionRequest: "Failed to complete code",
     saveUserConfig: "Failed to save user config",
     saveAppConfig: "Failed to save app config",
-    sendStdin: "Failed to send stdin",
     readCode: "Failed to read code",
     readSnippets: "Failed to fetch snippets",
     previewDatasetColumn: "Failed to fetch data sources",

package/src/core/network/types.ts

@@ -116,7 +116,6 @@ export type ShutdownSessionRequest = schemas["ShutdownSessionRequest"];
 export type Snippet = schemas["Snippet"];
 export type SnippetSection = schemas["SnippetSection"];
 export type Snippets = schemas["Snippets"];
-export type StdinRequest = schemas["StdinRequest"];
 export type SuccessResponse = schemas["SuccessResponse"];
 export type UpdateUIElementValuesRequest =
   schemas["UpdateUIElementValuesRequest"];
@@ -163,9 +162,7 @@ export interface EditRequests {
    */
   saveLayout: (request: SaveLayoutRequest) => Promise<null>;
   sendCopy: (request: CopyNotebookRequest) => Promise<null>;
-  sendStdin: (request: StdinRequest) => Promise<null>;
   sendRunScratchpad: (request: ExecuteScratchpadRequest) => Promise<null>;
-  sendInterrupt: () => Promise<null>;
   sendShutdown: () => Promise<null>;
   sendFormat: (request: FormatCellsRequest) => Promise<FormatResponse>;
   sendCodeCompletionRequest: (request: CodeCompletionRequest) => Promise<null>;

package/src/core/notebook/document/__tests__/model.test.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import type { Result } from "@marimo-team/client";
+import type { ResultOf } from "@marimo-team/client";
 import type * as Protocol from "@marimo-team/client/protocol";
 import { atom, createStore } from "jotai/vanilla";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -11,7 +11,7 @@ import { createDocumentModel } from "../model";
 import { type FakeEdit, fakeBackend } from "../../replica/__tests__/fixtures";
 import { cell, document, withCells } from "./fixtures";
 
-function response(confirmed: Document): Result<Protocol.EditResponseOutput> {
+function response(confirmed: Document): ResultOf<"notebook.edit"> {
   return {
     ok: true,
     status: 200,
@@ -41,9 +41,9 @@ function setup({ connected = true } = {}) {
   const source = atom<Document | null>(document());
   const unmounted = vi.fn();
   source.onMount = () => unmounted;
-  const replies: Deferred<Result<Protocol.EditResponseOutput>>[] = [];
+  const replies: Deferred<ResultOf<"notebook.edit">>[] = [];
   const sent = vi.fn((_edit: SentEdit) => {
-    const reply = new Deferred<Result<Protocol.EditResponseOutput>>();
+    const reply = new Deferred<ResultOf<"notebook.edit">>();
     replies.push(reply);
     return reply.promise;
   });

package/src/core/notebook/document/__tests__/test-host.test.ts

@@ -24,16 +24,16 @@ it("matches the portable host examples for accepted and conflicting edits", () =
     notebookId: "n1",
     idempotencyKey: "rejected",
     changes: Protocol.EditRequest.parse(
-      protocolFixture("edit-conflict-request.json"),
+      protocolFixture("stale-edit-request.json"),
     ).changes,
   });
   const problem = Protocol.Problem.parse(
-    protocolFixture("problems/edit-conflict.json"),
+    protocolFixture("problems/precondition-failed.json"),
   );
   expect(rejected).toEqual({
     result: {
       ok: false,
-      status: 409,
+      status: 412,
       problem: { ...problem, detail: expect.any(String) },
     },
   });
@@ -48,7 +48,7 @@ it("rejects an entire batch when a later precondition is stale", () => {
     { kind: "delete_cell", id: "c3", base_etag: "stale" },
   ]);
   expect(result).toMatchObject({
-    result: { ok: false, status: 409, problem: { edit: { change: 1 } } },
+    result: { ok: false, status: 412, problem: { index: 1 } },
   });
   expect(host.document()).toEqual(initial);
   expect(result.update).toBeUndefined();
@@ -67,7 +67,7 @@ it("keeps successful and rejected receipts tied to their original payload and re
     notebookId: "n1",
     idempotencyKey: "stale",
     changes: Protocol.EditRequest.parse(
-      protocolFixture("edit-conflict-request.json"),
+      protocolFixture("stale-edit-request.json"),
     ).changes,
   };
   const rejected = host.process(stale);
@@ -86,7 +86,7 @@ it("keeps successful and rejected receipts tied to their original payload and re
   vi.advanceTimersByTime(300_000);
   expect(host.process(request).result).toMatchObject({
     ok: false,
-    status: 409,
+    status: 412,
   });
   expect(host.document()).toEqual(latest);
 });