@marimo-team/islands 0.25.2-dev99 → 0.25.3-dev10

package/src/core/islands/__tests__/bootstrap.test.ts

@@ -3,6 +3,8 @@
 import { createStore } from "jotai";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { RuntimeState } from "@/core/kernel/RuntimeState";
+import { attachmentsAtom } from "@/core/attachments/state";
+import { Logger } from "@/utils/Logger";
 import { initializeIslands } from "../bootstrap";
 import type { IslandsPyodideBridge } from "../bridge";
 import { islandsHydratedAtom, islandsPendingInitialRunsAtom } from "../state";
@@ -48,6 +50,30 @@ describe("initializeIslands", () => {
     expect(store.get(islandsHydratedAtom)).toBe(false);
     store.set(islandsPendingInitialRunsAtom, new Set([1, 2]));
 
+    const errors = vi.spyOn(Logger, "error");
+    consumeMessage?.({
+      sessionGeneration: 1,
+      message: JSON.stringify({
+        op: "attachments",
+        data: {
+          op: "attachments",
+          attachments: [
+            {
+              id: "a1",
+              kind: "agent",
+              name: "Pi",
+              since: "2026-10-14T00:00:00Z",
+              notebook_id: "nb-test",
+              identity: "pi-thread",
+            },
+          ],
+        },
+      }) as IslandsKernelMessage["message"],
+    });
+    expect(errors).not.toHaveBeenCalled();
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(islandsPendingInitialRunsAtom)).toEqual(new Set([1, 2]));
+
     consumeMessage?.(completedRun(1));
     expect(store.get(islandsHydratedAtom)).toBe(false);
 

package/src/core/islands/bootstrap.ts

@@ -209,6 +209,7 @@ function handleMessage(
       case "cache-info":
       case "kernel-startup-error":
       case "notebook-document-transaction":
+      case "attachments":
         return;
 
       case "completed-run":

package/src/core/islands/bridge.ts

@@ -7,7 +7,7 @@ import { throwNotImplemented } from "@/utils/functions";
 import { Logger } from "@/utils/Logger";
 import { generateUUID } from "@/utils/uuid";
 import { initialNotebookState, notebookAtom } from "../cells/cells";
-import type { CommandMessage } from "../kernel/messages";
+import type { ClientCommand } from "../kernel/messages";
 import type { EditRequests, RunRequests } from "../network/types";
 import { store as defaultStore } from "../state/jotai";
 import { getMarimoExportContext } from "../static/export-context";
@@ -392,7 +392,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   // The kernel uses msgspec to parse control requests, which requires a 'type'
   // field for discriminated union deserialization.
   private async putControlRequest(
-    operation: CommandMessage,
+    operation: ClientCommand,
     session?: AppSession,
   ): Promise<void> {
     session ??= await this.getActiveSession();

package/src/core/kernel/messages.ts

@@ -2,7 +2,7 @@
 import type { components } from "@marimo-team/marimo-api";
 
 export type schemas = components["schemas"];
-export type DataType = schemas["KnownUnions"]["data_type"];
+export type DataType = schemas["DataType"];
 export const DATA_TYPES = [
   "string",
   "boolean",
@@ -24,10 +24,7 @@ export type DatabaseSchema = schemas["Schema"];
 export type DataSourceConnection = schemas["DataSourceConnection"];
 export type OutputChannel = schemas["CellChannel"];
 export type CellOutput = schemas["CellOutput"];
-export type MarimoError = Extract<
-  CellOutput["data"],
-  { type: string }[]
->[number];
+export type MarimoError = schemas["MarimoError"];
 export type OutputMessage = schemas["CellOutput"];
 export type CompletionOption =
   schemas["CompletionResultNotification"]["options"][0];
@@ -54,8 +51,8 @@ export type Capabilities =
   NotificationMessageData<"kernel-ready">["capabilities"];
 export type CacheInfoFetched = NotificationMessageData<"cache-info">;
 
-export type NotificationMessage = schemas["KnownUnions"]["notification"];
-export type CommandMessage = schemas["KnownUnions"]["command"];
+export type NotificationMessage = schemas["NotificationMessage"];
+export type ClientCommand = schemas["ClientCommand"];
 
 export type NotificationMessageType = NotificationMessage["op"];
 export interface NotificationPayload {

package/src/core/network/__tests__/api.test.ts

@@ -1,7 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { HTTPError } from "@/utils/errors";
+import { Logger } from "@/utils/Logger";
 import { API } from "../api";
 
 // Mock fetch globally
@@ -25,6 +26,118 @@ describe("API", () => {
     baseUrl = "http://localhost:8000";
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it.each(["before fetch", "during fetch"])(
+    "API.post propagates cancellation %s without logging it",
+    async (timing) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const controller = new AbortController();
+      mockFetch.mockImplementation(
+        (_url: string, { signal }: RequestInit) =>
+          new Promise<Response>((_resolve, reject) => {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            } else {
+              signal?.addEventListener("abort", () => reject(signal.reason), {
+                once: true,
+              });
+            }
+          }),
+      );
+      if (timing === "before fetch") {
+        controller.abort();
+      }
+
+      const response = API.post("/foo", {}, { signal: controller.signal });
+      controller.abort();
+
+      await expect(response).rejects.toBe(controller.signal.reason);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "http://localhost:8000/api/foo",
+        expect.objectContaining({ signal: controller.signal }),
+      );
+      expect(log).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(["application/json", "text/plain"])(
+    "API.post propagates an abort while reading %s without logging it",
+    async (contentType) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const error = new DOMException("Body read aborted", "AbortError");
+      const readBody = vi.fn().mockRejectedValue(error);
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ "Content-Type": contentType }),
+        json: readBody,
+        text: readBody,
+      });
+
+      await expect(API.post("/foo", {})).rejects.toBe(error);
+      expect(readBody).toHaveBeenCalledExactlyOnceWith();
+      expect(log).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each([new TypeError("Failed to fetch"), null, "Request failed"])(
+    "API.post logs and preserves non-abort fetch failures: %s",
+    async (error) => {
+      const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+      const controller = new AbortController();
+      controller.abort();
+      mockFetch.mockRejectedValue(error);
+
+      await expect(
+        API.post("/foo", {}, { signal: controller.signal }),
+      ).rejects.toBe(error);
+      expect(log).toHaveBeenCalledExactlyOnceWith(
+        "Error requesting http://localhost:8000/api/foo",
+        error,
+      );
+    },
+  );
+
+  it("API.post logs HTTP failures and preserves their status and body", async () => {
+    const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+    const body = { detail: "Service unavailable" };
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(body), {
+        status: 503,
+        statusText: "Service Unavailable",
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+
+    await expect(API.post("/foo", {})).rejects.toMatchObject({
+      name: "HTTPError",
+      status: 503,
+      message: "Service Unavailable",
+      cause: body,
+    });
+    expect(log).toHaveBeenCalledExactlyOnceWith(
+      "Error requesting http://localhost:8000/api/foo",
+      expect.any(HTTPError),
+    );
+  });
+
+  it("API.post logs malformed JSON responses", async () => {
+    const log = vi.spyOn(Logger, "error").mockReturnValue(undefined);
+    mockFetch.mockResolvedValue(
+      new Response("invalid json", {
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+
+    await expect(API.post("/foo", {})).rejects.toBeInstanceOf(SyntaxError);
+    expect(log).toHaveBeenCalledExactlyOnceWith(
+      "Error requesting http://localhost:8000/api/foo",
+      expect.any(SyntaxError),
+    );
+  });
+
   it("API.post calls fetch with POST and correct URL", async () => {
     mockFetch.mockResolvedValue({
       ok: true,

package/src/core/network/api.ts

@@ -101,8 +101,9 @@ export const API = {
         return response.text() as unknown as RESP;
       })
       .catch((error) => {
-        // Catch and rethrow
-        Logger.error(`Error requesting ${fullUrl}`, error);
+        if (error?.name !== "AbortError") {
+          Logger.error(`Error requesting ${fullUrl}`, error);
+        }
         throw error;
       });
   },

package/src/core/wasm/bridge.ts

@@ -11,7 +11,7 @@ import { reloadSafe } from "@/utils/reload-safe";
 import { generateUUID } from "@/utils/uuid";
 import { createModuleWorker } from "@/utils/worker";
 import { notebookIsRunningAtom } from "../cells/cells";
-import type { CommandMessage } from "../kernel/messages";
+import type { ClientCommand } from "../kernel/messages";
 import { getInitialAppMode } from "../mode";
 import { API } from "../network/api";
 import { withDevAssetUrl } from "../network/export-asset-url";
@@ -711,7 +711,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
   public listStorageEntries = throwNotImplemented;
   public downloadStorage = throwNotImplemented;
 
-  private async putControlRequest(operation: CommandMessage) {
+  private async putControlRequest(operation: ClientCommand) {
     await this.rpc.proxy.request.bridge({
       functionName: "put_control_request",
       payload: operation,

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

@@ -3,7 +3,7 @@ import type { PyodideInterface } from "pyodide";
 import type { WasmRuntimeConfig } from "../runtime-config";
 import type { UserConfig } from "@/core/config/config-schema";
 import type {
-  CommandMessage,
+  ClientCommand,
   NotificationPayload,
 } from "@/core/kernel/messages";
 import type { JsonString } from "@/utils/json/base64";
@@ -74,7 +74,7 @@ export interface WasmController {
 }
 
 export interface RawBridge {
-  put_control_request(operation: CommandMessage): Promise<string>;
+  put_control_request(operation: ClientCommand): Promise<string>;
   put_input(input: string): Promise<string>;
   code_complete(request: CodeCompletionRequest): Promise<string>;
   read_code(): Promise<{ contents: string }>;

package/src/core/websocket/__tests__/useMarimoKernelConnection.hook.test.tsx

@@ -43,6 +43,11 @@ vi.mock("@/core/runtime/config", async () => {
 import { MockNotebook } from "@/__mocks__/notebook";
 import { cellId } from "@/__tests__/branded";
 import { alertAtom, getPackageAlert } from "@/core/alerts/state";
+import {
+  type Attachment,
+  attachmentsAtom,
+  agentAttachmentsAtom,
+} from "@/core/attachments/state";
 import { notebookAtom } from "@/core/cells/cells";
 import { AppConfigSchema } from "@/core/config/config-schema";
 import { ConnectionNotice } from "@/components/editor/alerts/connection-notice";
@@ -184,6 +189,46 @@ describe("useMarimoKernelConnection.reconnect()", () => {
 });
 
 describe("useMarimoKernelConnection messages", () => {
+  it("replaces attachment snapshots, including the last detach", () => {
+    const store = createStore();
+    vi.mocked(useConnectionTransport).mockReturnValue(
+      makeTransport(WebSocket.OPEN),
+    );
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    renderConnectionHook(store);
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+    const agent: Attachment = {
+      id: "a1",
+      kind: "agent",
+      name: "Pi",
+      since: "2026-10-14T00:00:00Z",
+      notebook_id: "nb-test",
+      identity: "pi-thread",
+    };
+    const client: Attachment = {
+      id: "c1",
+      kind: "client",
+      name: null,
+      since: "2026-10-14T00:00:01Z",
+      notebook_id: "nb-test",
+    };
+    for (const attachments of [[agent, client], [client], []]) {
+      act(() =>
+        options.onMessage(
+          new MessageEvent("message", {
+            data: JSON.stringify({
+              op: "attachments",
+              data: { op: "attachments", attachments },
+            }),
+          }),
+        ),
+      );
+      expect(store.get(attachmentsAtom)).toEqual(attachments);
+    }
+  });
+
   it("records completion of the initial run", () => {
     const store = createStore();
     vi.mocked(useConnectionTransport).mockClear();
@@ -211,6 +256,101 @@ describe("useMarimoKernelConnection messages", () => {
   });
 });
 
+describe("attachment snapshots across browser connections", () => {
+  const agent: Attachment = {
+    id: "a1",
+    kind: "agent",
+    name: "Pi",
+    since: "2026-10-14T00:00:00Z",
+    notebook_id: "nb-test",
+    identity: "pi-thread",
+  };
+
+  function connectedSession() {
+    const store = createStore();
+    store.set(connectionAtom, { state: ConnectionState.OPEN });
+    store.set(attachmentsAtom, [agent]);
+    const transport = makeTransport(WebSocket.OPEN);
+    vi.mocked(useConnectionTransport).mockReturnValue(transport);
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    renderConnectionHook(store);
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+    const receive = (data: NotificationPayload["data"]) =>
+      act(() => {
+        options.onMessage(
+          new MessageEvent("message", {
+            data: JSON.stringify({ op: data.op, data }),
+          }),
+        );
+      });
+    return { store, transport, options, receive };
+  }
+
+  it.each([
+    "MARIMO_NO_FILE_KEY",
+    "MARIMO_NO_SESSION_ID",
+    "MARIMO_NO_SESSION",
+    "MARIMO_SHUTDOWN",
+    "MARIMO_KERNEL_STARTUP_ERROR",
+    "MARIMO_UNAUTHORIZED",
+    "MARIMO_KIOSK_NOT_ALLOWED",
+    "MARIMO_TRANSPORT_EXHAUSTED",
+  ])("clears cached attachments on %s", (reason) => {
+    const { store, transport, options } = connectedSession();
+    act(() => options.onClose(new CloseEvent("close", { reason })));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.CLOSED);
+    expect(transport.reconnect).not.toHaveBeenCalled();
+  });
+
+  it("clears the snapshot on transport error", () => {
+    const { store, options } = connectedSession();
+    act(() => options.onError(new Event("error")));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+  });
+
+  it("waits for a fresh snapshot after a transient reconnect", async () => {
+    const { store, transport, options, receive } = connectedSession();
+    act(() => options.onClose(new CloseEvent("close")));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.CONNECTING);
+    expect(transport.reconnect).toHaveBeenCalledOnce();
+
+    await act(async () => options.onOpen(new Event("open")));
+    receive({ op: "reconnected" });
+    expect(store.get(connectionAtom).state).toBe(ConnectionState.OPEN);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+
+    const refreshed = { ...agent, id: "a2", name: "Codex" };
+    receive({ op: "attachments", attachments: [refreshed] });
+    expect(store.get(agentAttachmentsAtom)).toEqual([refreshed]);
+    receive({ op: "attachments", attachments: [] });
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+  });
+
+  it("keeps a fresh snapshot hidden until the session is ready", async () => {
+    const { store, options, receive } = connectedSession();
+    act(() => options.onClose(new CloseEvent("close")));
+    await act(async () => options.onOpen(new Event("open")));
+    receive({ op: "attachments", attachments: [agent] });
+    expect(store.get(attachmentsAtom)).toEqual([agent]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+    receive({ op: "reconnected" });
+    expect(store.get(agentAttachmentsAtom)).toEqual([agent]);
+  });
+
+  it("invalidates an old snapshot when a new transport opens", async () => {
+    const { store, options } = connectedSession();
+    await act(async () => options.onOpen(new Event("open")));
+    expect(store.get(attachmentsAtom)).toEqual([]);
+    expect(store.get(agentAttachmentsAtom)).toEqual([]);
+  });
+});
+
 it.each(["kernel-ready", "reconnected"])(
   "waits for %s before marking the session connected",
   async (op) => {
@@ -261,6 +401,59 @@ it.each(["kernel-ready", "reconnected"])(
   },
 );
 
+it.each([true, false])(
+  "keeps attachments only when kernel-ready resumes the session: %s",
+  (resumed) => {
+    const store = createStore();
+    const attachments: Attachment[] = [
+      {
+        id: "a1",
+        kind: "agent",
+        name: "Pi",
+        since: "2026-10-14T00:00:00Z",
+        notebook_id: "nb-test",
+        identity: "pi-thread",
+      },
+    ];
+    store.set(attachmentsAtom, attachments);
+    vi.mocked(useConnectionTransport).mockReturnValue(
+      makeTransport(WebSocket.OPEN),
+    );
+    vi.mocked(useRuntimeManager).mockReturnValue(
+      makeRuntimeManager() as unknown as ReturnType<typeof useRuntimeManager>,
+    );
+    renderConnectionHook(store);
+    const options = vi.mocked(useConnectionTransport).mock.calls.at(-1)![0];
+    act(() =>
+      options.onMessage(
+        new MessageEvent("message", {
+          data: JSON.stringify({
+            op: "kernel-ready",
+            data: {
+              op: "kernel-ready",
+              cell_ids: [],
+              codes: [],
+              names: [],
+              configs: [],
+              layout: null,
+              resumed,
+              ui_values: {},
+              last_executed_code: {},
+              last_execution_time: {},
+              app_config: { width: "normal" },
+              kiosk: false,
+              capabilities: { terminal: false },
+              auto_instantiated: true,
+              consumer_capabilities: { edit: true, interact: true },
+            },
+          }),
+        }),
+      ),
+    );
+    expect(store.get(attachmentsAtom)).toEqual(resumed ? attachments : []);
+  },
+);
+
 describe("connection notice", () => {
   beforeEach(() => vi.useFakeTimers());
   afterEach(() => vi.useRealTimers());

package/src/core/websocket/useMarimoKernelConnection.tsx

@@ -5,6 +5,7 @@ import { useAtom, useAtomValue, useSetAtom } from "jotai";
 import { useRef } from "react";
 import { useErrorBoundary } from "react-error-boundary";
 import { toast } from "@/components/ui/use-toast";
+import { attachmentsAtom } from "@/core/attachments/state";
 import { getNotebook, useCellActions } from "@/core/cells/cells";
 import { applyTransactionChanges } from "@/core/cells/document-changes";
 import { AUTOCOMPLETER } from "@/core/codemirror/completion/Autocompleter";
@@ -236,6 +237,7 @@ export function useMarimoKernelConnection(opts: {
   } = useAlertActions();
   const setKioskMode = useSetAtom(kioskModeAtom);
   const setStableSessionId = useSetAtom(stableSessionIdAtom);
+  const setAttachments = useSetAtom(attachmentsAtom);
   const setCapabilities = useSetAtom(capabilitiesAtom);
   const runtimeManager = useRuntimeManager();
   const transportType = useAtomValue(connectionTransportTypeAtom);
@@ -252,6 +254,9 @@ export function useMarimoKernelConnection(opts: {
       case "reload":
         reloadSafe();
         return;
+      case "attachments":
+        setAttachments(msg.data.attachments);
+        return;
       case "startup-progress": {
         const { phase } = msg.data;
         updateStartupProgress(msg.data);
@@ -283,6 +288,7 @@ export function useMarimoKernelConnection(opts: {
           existingCells,
         });
         if (!msg.data.resumed) {
+          setAttachments([]);
           // A freshly started kernel may expose a different environment
           // (e.g. new env vars); re-run discovery instead of reusing stale
           // suggestions from the previous kernel instance.
@@ -561,6 +567,7 @@ export function useMarimoKernelConnection(opts: {
      */
     onOpen: async () => {
       updateStartupProgress(null);
+      setAttachments([]);
       // If we are open, we can reset our reconnecting flag.
       shouldTryReconnecting.current = true;
     },
@@ -603,6 +610,7 @@ export function useMarimoKernelConnection(opts: {
      */
     onClose: (e) => {
       Logger.warn("WebSocket closed", e.code, e.reason);
+      setAttachments([]);
       const decision = classifyCloseEvent(e);
       setConnection((previous) => {
         const status = decision.status;
@@ -641,6 +649,7 @@ export function useMarimoKernelConnection(opts: {
      */
     onError: (e) => {
       Logger.warn("WebSocket error", e);
+      setAttachments([]);
       setConnection({
         state: ConnectionState.CLOSED,
         code: WebSocketClosedReason.KERNEL_DISCONNECTED,

package/src/css/katex-css.test.ts

@@ -32,7 +32,7 @@ describe("copied KaTeX stylesheet", () => {
       if (change === "added") {
         root.append(
           postcss.parse(
-            ".katex .reflectbox { display: inline-block; transform: scaleX(-1); }",
+            ".katex .upstream-drift-probe { display: inline-block; }",
           ),
         );
       } else {

package/src/css/katex.min.css

@@ -35,7 +35,7 @@
 }
 
 .katex .katex-version::after {
-  content: "0.18.5";
+  content: "0.18.7";
 }
 
 .katex .katex-mathml {
@@ -1131,6 +1131,11 @@
   padding: 0 0.03889em;
 }
 
+.katex .reflectbox {
+  display: inline-block;
+  transform: scaleX(-1);
+}
+
 .katex .eqn-num::before {
   content: "(" counter(katexEqnNo) ")";
   counter-increment: katexEqnNo;

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

@@ -2,7 +2,7 @@
 
 import { renderHook } from "@testing-library/react";
 import { useRef } from "react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   type HTMLElementNotDerivedFromRef,
   isRefObject,
@@ -28,6 +28,50 @@ describe("isRefObject", () => {
   });
 });
 
+describe.each([1, 2])("with %i anchors named current", (count) => {
+  let iframe: HTMLIFrameElement;
+  let browserWindow: Window;
+
+  beforeEach(() => {
+    // An iframe preserves named properties hidden by Vitest's global window.
+    iframe = document.createElement("iframe");
+    document.body.append(iframe);
+    if (!iframe.contentWindow) {
+      throw new Error("Expected an iframe window");
+    }
+    browserWindow = iframe.contentWindow;
+    const anchors = Array.from({ length: count }, () => {
+      const anchor = browserWindow.document.createElement("a");
+      anchor.id = "current";
+      return anchor;
+    });
+    browserWindow.document.body.append(...anchors);
+  });
+
+  afterEach(() => {
+    iframe.remove();
+  });
+
+  it("does not mistake window for a React ref", () => {
+    expect("current" in browserWindow).toBe(true);
+    expect(isRefObject(browserWindow)).toBe(false);
+  });
+
+  it("attaches and removes the listener on window", () => {
+    const listener = vi.fn();
+    const { unmount } = renderHook(() =>
+      useEventListener(browserWindow, "resize", listener),
+    );
+
+    browserWindow.dispatchEvent(new Event("resize"));
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    unmount();
+    browserWindow.dispatchEvent(new Event("resize"));
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe("useEventListener", () => {
   beforeEach(() => {
     vi.clearAllMocks();

package/src/hooks/useEventListener.ts

@@ -13,7 +13,12 @@ export type HTMLElementNotDerivedFromRef<T = HTMLElement> = T & {
 };
 
 export function isRefObject<T>(target: unknown): target is RefObject<T | null> {
-  return target !== null && typeof target === "object" && "current" in target;
+  return (
+    target !== null &&
+    typeof target === "object" &&
+    !("addEventListener" in target) &&
+    "current" in target
+  );
 }
 
 export function useEventListener<K extends keyof DocumentEventMap>(