@marimo-team/islands 0.23.10-dev35 → 0.23.10-dev36

package/dist/{mermaid-zuLgJ8J8.js → mermaid-BotvIKg9.js}

@@ -5,7 +5,7 @@ import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
 import "./react-dom-BTJzcVJ9.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";
 import "./zod-aLSua2NL.js";
-import { n as ErrorBanner } from "./error-banner-Cc0I3C9e.js";
+import { n as ErrorBanner } from "./error-banner-CJXYJ6Sb.js";
 import { t as isEmpty_default } from "./isEmpty-CJJMn-QP.js";
 import { n as useTheme } from "./useTheme-DEhDzATN.js";
 import { t as purify } from "./purify.es-H92eMd9-.js";

package/dist/{process-output-CyMLTogj.js → process-output-MAetFLBT.js}

@@ -1,6 +1,6 @@
 import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { at as parseHtmlContent, it as ansiToPlainText } from "./html-to-image-UEH5lFDZ.js";
+import { at as parseHtmlContent, it as ansiToPlainText } from "./html-to-image-D3CbHZwH.js";
 import { u as createLucideIcon } from "./dist-Dk6PV_d3.js";
 import { t as Strings } from "./strings-J57tzLr3.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";

package/dist/{reveal-component-ClnQ3_A3.js → reveal-component-BBpwXvOt.js}

@@ -6,10 +6,10 @@ import { s as __toESM } from "./chunk-BNovOVIE.js";
 import { _ as Logger, g as cn, h as Events, l as useEventListener, t as Button } from "./button-C5K9fIPF.js";
 import { t as require_react } from "./react-DA-nE2FX.js";
 import { t as require_compiler_runtime } from "./compiler-runtime-CEbnTgxf.js";
-import { lt as kioskModeAtom } from "./html-to-image-UEH5lFDZ.js";
+import { lt as kioskModeAtom } from "./html-to-image-D3CbHZwH.js";
 import "./chunk-5FQGJX7Z-BNjes6Yx.js";
 import { u as createLucideIcon } from "./dist-Dk6PV_d3.js";
-import { a as DEFAULT_SLIDE_TYPE, c as Slide, ct as PanelResizeHandle, i as DEFAULT_DECK_TRANSITION, in as Expand, ot as Panel, rn as EyeOff, s as SlideSidebar, sn as Code, st as PanelGroup, t as useNotebookCodeAvailable } from "./code-visibility-Bl-iLKlC.js";
+import { a as DEFAULT_SLIDE_TYPE, c as Slide, ct as PanelResizeHandle, i as DEFAULT_DECK_TRANSITION, in as Expand, ot as Panel, rn as EyeOff, s as SlideSidebar, sn as Code, st as PanelGroup, t as useNotebookCodeAvailable } from "./code-visibility-DC9HexXh.js";
 import { J as useDebouncedCallback } from "./input-CMYy4hzj.js";
 import "./toDate-d8RCRrRd.js";
 import "./react-dom-BTJzcVJ9.js";

package/dist/{vega-component-9h1ACS78.js → vega-component-DGPUhbDs.js}

@@ -6,7 +6,7 @@ import { c as asRemoteURL, v as CircleQuestionMark } from "./toDate-d8RCRrRd.js"
 import "./react-dom-BTJzcVJ9.js";
 import { t as require_jsx_runtime } from "./jsx-runtime-DebpN0FN.js";
 import "./zod-aLSua2NL.js";
-import { n as ErrorBanner } from "./error-banner-Cc0I3C9e.js";
+import { n as ErrorBanner } from "./error-banner-CJXYJ6Sb.js";
 import { t as Tooltip } from "./tooltip-DpcyNkQ2.js";
 import { i as debounce_default } from "./constants-T20xxyNf.js";
 import { T as useEvent_default, n as useTheme } from "./useTheme-DEhDzATN.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.23.10-dev35",
+  "version": "0.23.10-dev36",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/plugins/core/__test__/registerReactComponent.test.ts

@@ -3,11 +3,20 @@
 import ReactDOM from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { z } from "zod";
+import { FUNCTIONS_REGISTRY } from "@/core/functions/FunctionRegistry";
+import type { FunctionCallResultMessage } from "@/core/kernel/messages";
+import { FunctionNotFoundError } from "@/utils/errors";
 import {
   isCustomMarimoElement,
   registerReactComponent,
 } from "../registerReactComponent";
 
+vi.mock("@/core/functions/FunctionRegistry", () => ({
+  FUNCTIONS_REGISTRY: { request: vi.fn() },
+}));
+
+const requestMock = vi.mocked(FUNCTIONS_REGISTRY.request);
+
 // Each custom element name can only be registered once per jsdom window,
 // so we use a counter to generate unique tag names across tests.
 let tagCounter = 0;
@@ -202,3 +211,90 @@ describe("connectedCallback - light DOM nesting detection", () => {
     outer.remove();
   });
 });
+
+describe("plugin function: not-found recovery", () => {
+  const NOT_FOUND: FunctionCallResultMessage = {
+    function_call_id:
+      "call-id" as FunctionCallResultMessage["function_call_id"],
+    status: { code: "error", message: "Function not found" },
+    found: false,
+    return_value: null,
+  };
+  const OK: FunctionCallResultMessage = {
+    function_call_id:
+      "call-id" as FunctionCallResultMessage["function_call_id"],
+    status: { code: "ok" },
+    found: true,
+    return_value: { ok: true },
+  };
+
+  // Mount a plugin exposing a single callable function and resolve the
+  // function map that PluginSlot hands to render(), so tests can invoke the
+  // request path directly.
+  async function mountWithFunction(): Promise<
+    (args: Record<string, unknown>) => Promise<unknown>
+  > {
+    const tag = uniqueTag("fn");
+    let captured:
+      | ((args: Record<string, unknown>) => Promise<unknown>)
+      | undefined;
+    registerReactComponent({
+      tagName: tag,
+      validator: z.any(),
+      functions: { run: { input: z.any(), output: z.any() } },
+      render: ({ functions }) => {
+        captured = (functions as Record<string, typeof captured>).run;
+        return null as never;
+      },
+    });
+
+    const wrapper = document.createElement("marimo-ui-element");
+    wrapper.setAttribute("object-id", "test-object-id");
+    const el = document.createElement(tag);
+    wrapper.append(el);
+    document.body.append(wrapper);
+
+    await vi.waitFor(() => expect(captured).toBeDefined());
+    return captured as (args: Record<string, unknown>) => Promise<unknown>;
+  }
+
+  beforeEach(() => {
+    requestMock.mockReset();
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = "";
+  });
+
+  test("retries on found:false and resolves once the function appears", async () => {
+    const run = await mountWithFunction();
+    requestMock.mockResolvedValueOnce(NOT_FOUND).mockResolvedValueOnce(OK);
+
+    await expect(run({})).resolves.toEqual({ ok: true });
+    expect(requestMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("throws FunctionNotFoundError after retries are exhausted", async () => {
+    const run = await mountWithFunction();
+    requestMock.mockResolvedValue(NOT_FOUND);
+
+    await expect(run({})).rejects.toBeInstanceOf(FunctionNotFoundError);
+    // Initial attempt plus three retries.
+    expect(requestMock).toHaveBeenCalledTimes(4);
+  });
+
+  test("does not retry once the function is found (found:true)", async () => {
+    const run = await mountWithFunction();
+    requestMock.mockResolvedValue({
+      function_call_id:
+        "call-id" as FunctionCallResultMessage["function_call_id"],
+      status: { code: "error", message: "boom" },
+      found: true,
+      return_value: null,
+    });
+
+    const promise = run({});
+    await expect(promise).rejects.toThrow("boom");
+    expect(requestMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/plugins/core/registerReactComponent.tsx

@@ -40,7 +40,10 @@ import {
 } from "@/hooks/useEventListener";
 import { StyleNamespace } from "@/theme/namespace";
 import { useTheme } from "@/theme/useTheme";
-import { CellNotInitializedError } from "@/utils/errors.ts";
+import {
+  CellNotInitializedError,
+  FunctionNotFoundError,
+} from "@/utils/errors.ts";
 import { Functions } from "@/utils/functions";
 import { shallowCompare } from "@/utils/shallow-compare";
 import { defineCustomElement } from "../../core/dom/defineCustomElement";
@@ -80,6 +83,12 @@ export interface IMarimoHTMLElement extends HTMLElement {
   rerender: () => void;
 }
 
+// Bounded exponential backoff for re-issuing a request whose function the
+// kernel reported as not found. Short enough to fail fast on a genuinely
+// missing function, long enough to outlast a transient object-id desync.
+const FUNCTION_NOT_FOUND_MAX_RETRIES = 3;
+const FUNCTION_NOT_FOUND_BASE_DELAY_MS = 150;
+
 interface PluginSlotProps<T> {
   hostElement: HTMLElement;
   plugin: IPlugin<T, unknown>;
@@ -188,8 +197,6 @@ function PluginSlotInternal<T>(
           args.length <= 1,
           `Plugin functions only supports a single argument. Called ${key}`,
         );
-        const objectId = getUIElementObjectId(hostElement);
-        invariant(objectId, "Object ID should exist");
 
         const isStatic = isStaticNotebook();
 
@@ -218,16 +225,41 @@ function PluginSlotInternal<T>(
           Logger.warn(`Cell ID ${cellId} cannot be found`);
         }
 
-        const response = await FUNCTIONS_REGISTRY.request({
-          args: prettyParse(input, args[0]),
-          functionName: key,
-          namespace: objectId,
-        });
-        if (response.status.code !== "ok") {
+        // A "function not found" response means the kernel never ran the
+        // function, so re-issuing the request is side-effect-safe regardless
+        // of whether the function is idempotent. This recovers from a
+        // transient window where the frontend's object-id leads the kernel's
+        // registry. The object-id is re-read each attempt so a corrected id
+        // from a re-render is picked up. Once the function is found
+        // (found === true) the request is never retried, since the failure
+        // is unrelated to lookup and retrying would not help.
+        const parsedArgs = prettyParse(input, args[0]);
+        for (let attempt = 0; ; attempt++) {
+          const namespace = getUIElementObjectId(hostElement);
+          invariant(namespace, "Object ID should exist");
+
+          const response = await FUNCTIONS_REGISTRY.request({
+            args: parsedArgs,
+            functionName: key,
+            namespace,
+          });
+          if (response.status.code === "ok") {
+            return prettyParse(output, response.return_value);
+          }
+
+          const recoverable = response.found === false;
+          if (recoverable && attempt < FUNCTION_NOT_FOUND_MAX_RETRIES) {
+            const delay = FUNCTION_NOT_FOUND_BASE_DELAY_MS * 2 ** attempt;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            continue;
+          }
+
           Logger.error(response.status);
+          if (recoverable) {
+            throw new FunctionNotFoundError();
+          }
           throw new Error(response.status.message || "Unknown error");
         }
-        return prettyParse(output, response.return_value);
       };
     }
 

package/src/utils/errors.ts

@@ -71,6 +71,15 @@ export class CellNotInitializedError extends Error {
   }
 }
 
+export class FunctionNotFoundError extends Error {
+  constructor(
+    message = "This UI element could not reach its function on the kernel. Try re-running the cell.",
+  ) {
+    super(message);
+    this.name = "FunctionNotFoundError";
+  }
+}
+
 export class NoKernelConnectedError extends Error {
   constructor(message = "Not yet connected to a kernel.") {
     super(message);