@marimo-team/islands 0.23.15-dev1 → 0.23.15-dev11

package/src/components/editor/renderers/vertical-layout/vertical-layout.tsx

@@ -33,11 +33,14 @@ import { getReadonlyCodeDisplay } from "@/core/cells/readonly-code-display";
 import { MarkdownLanguageAdapter } from "@/core/codemirror/language/languages/markdown";
 import { useResolvedMarimoConfig } from "@/core/config/config";
 import { CSSClasses, KnownQueryParams } from "@/core/constants";
-import type { MarimoError, OutputMessage } from "@/core/kernel/messages";
+import type { OutputMessage } from "@/core/kernel/messages";
 import { kernelStateAtom } from "@/core/kernel/state";
 import { useNotebookCodeAvailable } from "@/core/meta/code-visibility";
 import { showCodeInRunModeAtom } from "@/core/meta/state";
-import { isErrorMime } from "@/core/mime";
+import {
+  publishedCellClasses,
+  shouldHidePublishedCell,
+} from "@/core/cells/utils";
 import { type AppMode, kioskModeAtom } from "@/core/mode";
 import { useRequestClient } from "@/core/network/requests";
 import type { CellConfig } from "@/core/network/types";
@@ -362,12 +365,13 @@ const VerticalCell = memo(
     const className = cn(
       "marimo-cell",
       "hover-actions-parent empty:invisible",
-      {
-        published: published,
-        "has-error": errored,
-        stopped: stopped,
-        borderless: isPureMarkdown && !published,
-      },
+      published
+        ? publishedCellClasses({ errored, stopped })
+        : {
+            "has-error": errored,
+            stopped: stopped,
+            borderless: isPureMarkdown,
+          },
     );
 
     // Read mode and show code
@@ -419,19 +423,15 @@ const VerticalCell = memo(
       );
     }
 
-    const outputIsError = isErrorMime(output?.mimetype);
     // When show_tracebacks is enabled, show error outputs inline
     // instead of hiding them
-    const hasTraceback =
-      showErrorTracebacks &&
-      outputIsError &&
-      Array.isArray(output?.data) &&
-      output.data.some(
-        (e: MarimoError) =>
-          e.type === "exception" && "traceback" in e && e.traceback,
-      );
-    const hidden =
-      (errored || interrupted || stopped || outputIsError) && !hasTraceback;
+    const hidden = shouldHidePublishedCell({
+      errored,
+      interrupted,
+      stopped,
+      output,
+      showErrorTracebacks,
+    });
     if (hidden) {
       return null;
     }

package/src/core/cells/__tests__/utils.test.ts

@@ -8,11 +8,13 @@ import {
 } from "@/core/cells/cells";
 import { CellId } from "@/core/cells/ids";
 import type { CellData, CellRuntimeState } from "@/core/cells/types";
+import type { OutputMessage } from "@/core/kernel/messages";
 import { MultiColumn } from "@/utils/id-tree";
 import {
   disabledCellIds,
   enabledCellIds,
   isUninstantiated,
+  shouldHidePublishedCell,
   staleCellIds,
 } from "../utils";
 
@@ -426,3 +428,60 @@ describe("enabledCellIds", () => {
     expect(result).toEqual([cellId2, cellId3]);
   });
 });
+
+describe("shouldHidePublishedCell", () => {
+  const base = {
+    errored: false,
+    interrupted: false,
+    stopped: false,
+    output: null,
+    showErrorTracebacks: false,
+  };
+  const errorOutput = (traceback?: string): OutputMessage => ({
+    channel: "marimo-error",
+    mimetype: "application/vnd.marimo+error",
+    data: [
+      { type: "exception", exception_type: "ValueError", msg: "!", traceback },
+    ],
+    timestamp: 0,
+  });
+
+  it("does not hide a healthy cell", () => {
+    expect(shouldHidePublishedCell(base)).toBe(false);
+  });
+
+  it.each(["errored", "interrupted", "stopped"] as const)(
+    "hides a %s cell",
+    (key) => {
+      expect(shouldHidePublishedCell({ ...base, [key]: true })).toBe(true);
+    },
+  );
+
+  it("hides error outputs", () => {
+    expect(shouldHidePublishedCell({ ...base, output: errorOutput() })).toBe(
+      true,
+    );
+  });
+
+  it("shows error outputs with a traceback when show_tracebacks is enabled", () => {
+    expect(
+      shouldHidePublishedCell({
+        ...base,
+        errored: true,
+        output: errorOutput("Traceback (most recent call last) ..."),
+        showErrorTracebacks: true,
+      }),
+    ).toBe(false);
+  });
+
+  it("hides error outputs without a traceback even when show_tracebacks is enabled", () => {
+    expect(
+      shouldHidePublishedCell({
+        ...base,
+        errored: true,
+        output: errorOutput(),
+        showErrorTracebacks: true,
+      }),
+    ).toBe(true);
+  });
+});

package/src/core/cells/utils.ts

@@ -2,6 +2,8 @@
 
 import type { EditorView } from "@codemirror/view";
 import { Objects } from "@/utils/objects";
+import type { MarimoError, OutputMessage } from "../kernel/messages";
+import { isErrorMime } from "../mime";
 import type { RuntimeState } from "../network/types";
 import type { NotebookState } from "./cells";
 import type { CellId } from "./ids";
@@ -196,3 +198,52 @@ export function cellStatusClasses({
     stale: status === "disabled-transitively",
   };
 }
+
+/**
+ * Status classes for a published cell (read or present mode, output only).
+ */
+export function publishedCellClasses({
+  errored,
+  stopped,
+}: {
+  errored: boolean;
+  stopped: boolean;
+}) {
+  return {
+    published: true,
+    "has-error": errored,
+    stopped: stopped,
+  };
+}
+
+/**
+ * Whether a published cell (read or present mode) should be hidden.
+ *
+ * Errored, interrupted, and stopped cells (and error outputs) are hidden in
+ * published views, unless `show_tracebacks` is enabled and the output carries
+ * an exception traceback to display inline.
+ */
+export function shouldHidePublishedCell({
+  errored,
+  interrupted,
+  stopped,
+  output,
+  showErrorTracebacks,
+}: {
+  errored: boolean;
+  interrupted: boolean;
+  stopped: boolean;
+  output: OutputMessage | null;
+  showErrorTracebacks: boolean;
+}): boolean {
+  const outputIsError = isErrorMime(output?.mimetype);
+  const hasTraceback =
+    showErrorTracebacks &&
+    outputIsError &&
+    Array.isArray(output?.data) &&
+    output.data.some(
+      (e: MarimoError) =>
+        e.type === "exception" && "traceback" in e && e.traceback,
+    );
+  return (errored || interrupted || stopped || outputIsError) && !hasTraceback;
+}

package/src/css/app/Cell.css

@@ -255,6 +255,12 @@
     border: none;
     box-shadow: none;
 
+    /* No dividers between sections. Tailwind v4's divide-y is structural
+     * (`> :not(:last-child)`), so hidden-but-mounted children (e.g. the tray
+     * while presenting) still count as siblings and would otherwise draw a
+     * stray rule under the output. */
+    @apply divide-y-0;
+
     .output-area {
       /* flow-root interferes with margin collapsing, but appears to be unneeded
             * when cell outlines are hidden; clear:both is sufficient.
@@ -443,6 +449,10 @@
   /* Set a fixed gutter width to ensure the hover area is always wide enough */
   /* And make the gutter bigger when the window is super wide */
   --gutter-width: 100px;
+
+  /* Vertical gap between notebook cells (gap-5). Overridable via custom css;
+   * zeroed while presenting, when published cells flow together. */
+  --notebook-cell-gap: 1.25rem;
 }
 
 /* ------------------------ CodeMirror Editor ----------------------------- */

package/src/hooks/__tests__/useHotkey.test.tsx

@@ -0,0 +1,88 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { renderHook } from "@testing-library/react";
+import { createStore, Provider } from "jotai";
+import { describe, expect, it, vi } from "vitest";
+import { Functions } from "@/utils/functions";
+import { useHotkey } from "../useHotkey";
+
+// global.hideCode is bound to "Mod-." by default; "mod" accepts ctrl or meta.
+const SHORTCUT = "global.hideCode";
+
+function createWrapper() {
+  const store = createStore();
+  return ({ children }: { children: React.ReactNode }) => (
+    <Provider store={store}>{children}</Provider>
+  );
+}
+
+function press() {
+  const event = new KeyboardEvent("keydown", {
+    key: ".",
+    ctrlKey: true,
+    cancelable: true,
+    bubbles: true,
+  });
+  document.dispatchEvent(event);
+  return event;
+}
+
+describe("useHotkey", () => {
+  it("invokes the callback and prevents default", () => {
+    const callback = vi.fn();
+    renderHook(() => useHotkey(SHORTCUT, callback), {
+      wrapper: createWrapper(),
+    });
+
+    const event = press();
+    expect(callback).toHaveBeenCalledOnce();
+    expect(event.defaultPrevented).toBe(true);
+  });
+
+  it("does not prevent default when the callback returns false", () => {
+    const callback = vi.fn(() => false);
+    renderHook(() => useHotkey(SHORTCUT, callback), {
+      wrapper: createWrapper(),
+    });
+
+    const event = press();
+    expect(callback).toHaveBeenCalledOnce();
+    expect(event.defaultPrevented).toBe(false);
+  });
+
+  it("still swallows the keystroke for NOOP catch-all handlers", () => {
+    renderHook(() => useHotkey(SHORTCUT, Functions.NOOP), {
+      wrapper: createWrapper(),
+    });
+
+    const event = press();
+    expect(event.defaultPrevented).toBe(true);
+  });
+
+  it("neither runs the callback nor prevents default when disabled", () => {
+    const callback = vi.fn();
+    renderHook(() => useHotkey(SHORTCUT, callback, { disabled: true }), {
+      wrapper: createWrapper(),
+    });
+
+    const event = press();
+    expect(callback).not.toHaveBeenCalled();
+    expect(event.defaultPrevented).toBe(false);
+  });
+
+  it("re-enables when disabled flips back to false", () => {
+    const callback = vi.fn();
+    const { rerender } = renderHook(
+      ({ disabled }: { disabled: boolean }) =>
+        useHotkey(SHORTCUT, callback, { disabled }),
+      { wrapper: createWrapper(), initialProps: { disabled: true } },
+    );
+
+    press();
+    expect(callback).not.toHaveBeenCalled();
+
+    rerender({ disabled: false });
+    const event = press();
+    expect(callback).toHaveBeenCalledOnce();
+    expect(event.defaultPrevented).toBe(true);
+  });
+});

package/src/hooks/useHotkey.ts

@@ -17,13 +17,31 @@ type HotkeyHandler = (
   // oxlint-disable-next-line typescript/no-invalid-void-type
 ) => boolean | void | undefined | Promise<void>;
 
+interface HotkeyOptions {
+  /**
+   * If true, the hotkey is not handled at all: the callback does not run, the
+   * event's default is not prevented, and the action is not registered in the
+   * shortcut registry.
+   *
+   * This differs from passing `Functions.NOOP` as the callback, which still
+   * swallows the keystroke (preventDefault) to suppress native browser/OS
+   * behavior.
+   */
+  disabled?: boolean;
+}
+
 /**
  * Registers a hotkey listener for the given shortcut.
  *
  * @param callback The callback to run when the shortcut is pressed. It does not need to be memoized as this hook will always use the latest callback.
  * If the callback returns false, preventDefault will not be called on the event.
  */
-export function useHotkey(shortcut: HotkeyAction, callback: HotkeyHandler) {
+export function useHotkey(
+  shortcut: HotkeyAction,
+  callback: HotkeyHandler,
+  options: HotkeyOptions = {},
+) {
+  const { disabled = false } = options;
   const { registerAction, unregisterAction } = useSetRegisteredAction();
   const hotkeys = useAtomValue(hotkeysAtom);
 
@@ -31,7 +49,7 @@ export function useHotkey(shortcut: HotkeyAction, callback: HotkeyHandler) {
   const memoizeCallback = useEvent((evt?: KeyboardEvent) => callback(evt));
 
   const listener = useEvent((e: KeyboardEvent) => {
-    if (e.defaultPrevented) {
+    if (disabled || e.defaultPrevented) {
       return;
     }
 
@@ -51,11 +69,18 @@ export function useHotkey(shortcut: HotkeyAction, callback: HotkeyHandler) {
 
   // Register with the shortcut registry
   useEffect(() => {
-    if (!isNOOP) {
+    if (!isNOOP && !disabled) {
       registerAction(shortcut, memoizeCallback);
       return () => unregisterAction(shortcut);
     }
-  }, [memoizeCallback, shortcut, isNOOP, registerAction, unregisterAction]);
+  }, [
+    memoizeCallback,
+    shortcut,
+    isNOOP,
+    disabled,
+    registerAction,
+    unregisterAction,
+  ]);
 }
 
 /**

package/src/plugins/impl/anywidget/__tests__/host.test.ts

@@ -277,25 +277,22 @@ describe("WidgetBinding receives a host in render props", () => {
   });
 });
 
-describe("host-mounted views hydrate like display-mounted ones", () => {
-  it("replays current state to a child's render listeners", async () => {
-    const childId = asModelId("host-hydration-child");
+describe("host-mounted views", () => {
+  it("render with the child's current model state", async () => {
+    const childId = asModelId("host-child-state");
     const parentController = new AbortController();
     const getModuleSpy = vi.spyOn(WIDGET_DEF_REGISTRY, "getModule");
     try {
       const childWidget = {
         render: vi.fn(({ model, el }) => {
-          el.textContent = "count is 5";
-          model.on("change:count", () => {
-            el.textContent = `count is ${model.get("count")}`;
-          });
+          el.textContent = `count is ${model.get("count")}`;
         }),
       };
       const childModel = new Model<ModelState>({ count: 8 }, createMockComm());
       WIDGET_REGISTRY.setModel(childId, childModel);
       WIDGET_REGISTRY.setSpec(childId, {
-        url: "./@file/10-host-hydration-child.js",
-        hash: "hash-host-hydration-child",
+        url: "./@file/10-host-child-state.js",
+        hash: "hash-host-child-state",
       });
       getModuleSpy.mockResolvedValue({ default: childWidget });
 

package/src/plugins/impl/anywidget/__tests__/widget-binding.test.ts

@@ -337,13 +337,12 @@ describe("WidgetBinding", () => {
       { el: document.createElement("div") },
       { signal: controller.signal },
     );
-    // Called once by the hydration replay at mount, once by the set.
     model.set("count", 1);
-    expect(onCount).toHaveBeenCalledTimes(2);
+    expect(onCount).toHaveBeenCalledTimes(1);
 
     controller.abort();
     model.set("count", 2);
-    expect(onCount).toHaveBeenCalledTimes(2);
+    expect(onCount).toHaveBeenCalledTimes(1);
   });
 
   it("should auto-clear initialize listeners on destroy", async () => {
@@ -366,92 +365,54 @@ describe("WidgetBinding", () => {
   });
 });
 
-describe("WidgetBinding hydration replay", () => {
-  it("replays current state to render listeners exactly once", async () => {
+describe("WidgetBinding render listeners", () => {
+  it("fire only for changes after mount, never for pre-existing state", async () => {
     const model = new Model<ModelState>({ count: 8 }, createMockComm());
-    const el = document.createElement("div");
-    const widgetDef = {
-      render: vi.fn(({ model, el }) => {
-        // A widget view that starts with a local default and relies on
-        // change events for hydration.
-        el.textContent = "count is 5";
-        model.on("change:count", () => {
-          el.textContent = `count is ${model.get("count")}`;
-        });
-      }),
-    };
-    const binding = await createBinding(widgetDef, model);
-
-    const controller = new AbortController();
-    await binding.createView({ el }, { signal: controller.signal });
-    expect(el.textContent).toBe("count is 8");
-  });
-
-  it("does not re-fire listeners of already-mounted views", async () => {
-    // Mounting view B must not double-paint view A: the replay is
-    // scoped to the listeners the new render attached.
-    const model = new Model<ModelState>({ count: 0 }, createMockComm());
-    const listeners: Array<ReturnType<typeof vi.fn>> = [];
+    const onCount = vi.fn();
+    const onAnyChange = vi.fn();
     const widgetDef = {
       render: vi.fn(({ model }) => {
-        const listener = vi.fn();
-        listeners.push(listener);
-        model.on("change:count", listener);
+        model.on("change:count", onCount);
+        model.on("change", onAnyChange);
       }),
     };
     const binding = await createBinding(widgetDef, model);
     const controller = new AbortController();
-
     await binding.createView(
       { el: document.createElement("div") },
       { signal: controller.signal },
     );
-    expect(listeners[0]).toHaveBeenCalledTimes(1);
+    expect(onCount).not.toHaveBeenCalled();
+    expect(onAnyChange).not.toHaveBeenCalled();
 
-    await binding.createView(
-      { el: document.createElement("div") },
-      { signal: controller.signal },
-    );
-    // View B's listener hydrated once; view A's was left alone.
-    expect(listeners[1]).toHaveBeenCalledTimes(1);
-    expect(listeners[0]).toHaveBeenCalledTimes(1);
+    model.set("count", 9);
+    expect(onCount).toHaveBeenCalledTimes(1);
+    expect(onCount).toHaveBeenCalledWith(9);
   });
 
-  it("replays the any-change event to its listeners", async () => {
-    const model = new Model<ModelState>({ count: 1 }, createMockComm());
-    const onAnyChange = vi.fn();
+  it("mounting a second view does not fire the first view's listeners", async () => {
+    const model = new Model<ModelState>({ count: 0 }, createMockComm());
+    const listeners: Array<ReturnType<typeof vi.fn>> = [];
     const widgetDef = {
       render: vi.fn(({ model }) => {
-        model.on("change", onAnyChange);
+        const listener = vi.fn();
+        listeners.push(listener);
+        model.on("change:count", listener);
       }),
     };
     const binding = await createBinding(widgetDef, model);
     const controller = new AbortController();
+
     await binding.createView(
       { el: document.createElement("div") },
       { signal: controller.signal },
     );
-    expect(onAnyChange).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not replay initialize listeners", async () => {
-    // The guarantee is per-view: initialize listeners existed before
-    // any view, and replaying at them would fire once per mount.
-    const model = new Model<ModelState>({ count: 1 }, createMockComm());
-    const initListener = vi.fn();
-    const widgetDef = {
-      initialize: vi.fn(({ model }) => {
-        model.on("change:count", initListener);
-      }),
-      render: vi.fn(),
-    };
-    const binding = await createBinding(widgetDef, model);
-    const controller = new AbortController();
     await binding.createView(
       { el: document.createElement("div") },
       { signal: controller.signal },
     );
-    expect(initListener).not.toHaveBeenCalled();
+    expect(listeners[0]).not.toHaveBeenCalled();
+    expect(listeners[1]).not.toHaveBeenCalled();
   });
 
   it("clears the element before rendering into it", async () => {

package/src/plugins/impl/anywidget/model-proxy.ts

@@ -5,15 +5,6 @@ import type { ModelState } from "./types";
 
 type ModelEventCallback = Parameters<AnyModel<ModelState>["on"]>[1];
 
-/**
- * A listener registered through a model proxy (see the hydration
- * replay in `WidgetBinding.createView`).
- */
-export interface ProxyRegistration {
-  event: string;
-  callback: ModelEventCallback;
-}
-
 /**
  * Wrap a model so every `on()` call from inside `initialize` or `render`
  * is auto-tied to a lifetime `AbortSignal`. When the signal aborts,
@@ -27,14 +18,11 @@ export interface ProxyRegistration {
  * The proxy is purely a host-side ergonomic helper. The widget author
  * still writes `model.on("change:foo", handler)` exactly as before; the
  * cleanup signal is supplied transparently.
- *
- * `onRegister`, when given, observes each `on()` registration.
  */
 // oxlint-disable-next-line marimo/prefer-object-params -- concise internal helper used at protocol call sites
 export function modelProxy<T extends ModelState>(
   model: AnyModel<T>,
   signal: AbortSignal,
-  onRegister?: (registration: ProxyRegistration) => void,
 ): AnyModel<T> {
   return {
     get(key) {
@@ -55,7 +43,6 @@ export function modelProxy<T extends ModelState>(
       signal.addEventListener("abort", () => model.off(name, callback), {
         once: true,
       });
-      onRegister?.({ event: name, callback });
     },
     off(name?: string | null, callback?: ModelEventCallback | null): void {
       model.off(name ?? null, callback ?? null);

package/src/plugins/impl/anywidget/widget-binding.ts

@@ -12,7 +12,7 @@ import { isTrustedVirtualFileUrl } from "@/plugins/core/trusted-url";
 import { Logger } from "@/utils/Logger";
 import type { Host } from "./host";
 import type { Model } from "./model";
-import { modelProxy, type ProxyRegistration } from "./model-proxy";
+import { modelProxy } from "./model-proxy";
 import type { ModelState } from "./types";
 
 export const experimental: Experimental = {
@@ -266,9 +266,8 @@ export class WidgetBinding<T extends ModelState = ModelState> {
    * when the caller's `signal` fires or the binding is destroyed, and
    * listeners registered inside `render` auto-clear on abort.
    *
-   * Hydration guarantee: listeners attached during `render` observe
-   * current model state exactly once, after `render` settles. Scoped
-   * to this view's listeners; re-firing at other views double-paints.
+   * `render` reads current state via `model.get`; change listeners
+   * observe only subsequent changes, matching Jupyter semantics.
    */
   async createView(
     target: { el: HTMLElement },
@@ -305,11 +304,8 @@ export class WidgetBinding<T extends ModelState = ModelState> {
     // Each view gets a host scoped to its own signal so child views tear
     // down with this view.
     const host = this.#createHost(renderSignal);
-    const registrations: ProxyRegistration[] = [];
     const renderCleanup = await widget.render({
-      model: modelProxy(this.#model, renderSignal, (registration) =>
-        registrations.push(registration),
-      ),
+      model: modelProxy(this.#model, renderSignal),
       el: target.el,
       experimental,
       signal: renderSignal,
@@ -333,7 +329,6 @@ export class WidgetBinding<T extends ModelState = ModelState> {
         once: true,
       });
     }
-    this.#replayState(registrations, renderSignal);
   }
 
   #trackCleanup(cleanup: Cleanup, reason: string): Promise<void> {
@@ -343,31 +338,6 @@ export class WidgetBinding<T extends ModelState = ModelState> {
     return task;
   }
 
-  /**
-   * The hydration guarantee documented on `createView`.
-   */
-  #replayState(
-    registrations: readonly ProxyRegistration[],
-    renderSignal: AbortSignal,
-  ): void {
-    const changePrefix = "change:";
-    for (const { event, callback } of registrations) {
-      if (renderSignal.aborted) {
-        return;
-      }
-      try {
-        if (event.startsWith(changePrefix)) {
-          const key = event.slice(changePrefix.length);
-          callback(this.#model.get(key));
-        } else if (event === "change") {
-          callback();
-        }
-      } catch (error) {
-        Logger.error("[WidgetBinding] Error replaying state", error);
-      }
-    }
-  }
-
   /**
    * Destroy this generation, running initialize/render cleanups and
    * clearing listeners registered through its model proxies.