webext-messenger 0.35.0 → 0.37.0

package/distribution/sender.js

@@ -1,11 +1,9 @@
-import { isExtensionContext } from "webext-detect";
+import { isBackground, isExtensionContext } from "webext-detect";
 import { deserializeError } from "serialize-error";
 import { isObject, MessengerError, ExtensionNotFoundError, __webextMessenger, } from "./shared.js";
 import { log } from "./logging.js";
 import { handlers } from "./handlers.js";
 import { events } from "./events.js";
-import { compareTargets } from "./targetLogic.js";
-import { thisTarget } from "./thisTarget.js";
 const _errorNonExistingTarget = "Could not establish connection. Receiving end does not exist.";
 const _errorTargetClosedEarly = "A listener indicated an asynchronous response by returning true, but the message channel closed before a response was received";
 export const errorTargetClosedEarly = "The target was closed before receiving a response";
@@ -186,17 +184,16 @@ function messenger(type, options, target, ...args) {
         };
         return manageConnection(type, options, target, sendMessage);
     }
-    // Use local methods if the target matches the current context
-    if (compareTargets(target, thisTarget)) {
-        const handler = handlers.get(type);
-        if (handler) {
-            log.warn(type, seq, "is being handled locally");
-            return handler.apply({ trace: [] }, args);
-        }
-        throw new MessengerError("No handler registered locally for " + type);
-    }
     // Message goes to extension page
     if ("page" in target) {
+        if (target.page === "background" && isBackground()) {
+            const handler = handlers.get(type);
+            if (handler) {
+                log.warn(type, seq, "is being handled locally");
+                return handler.apply({ trace: [] }, args);
+            }
+            throw new MessengerError("No handler registered locally for " + type);
+        }
         const sendMessage = async (attemptCount) => {
             log.debug(type, seq, "↗️ sending message to runtime", attemptLog(attemptCount));
             return chrome.runtime.sendMessage(makeMessage(type, args, target, options));

package/distribution/sender.test.d.ts

@@ -1,6 +1,7 @@
+import { type MessengerMeta } from "./types.js";
 declare global {
     interface MessengerMethods {
-        testMethod: () => Promise<string>;
+        /** Stand-in method, only ever registered/targeted by this file. */
+        senderTestMethod: (this: MessengerMeta, ...args: unknown[]) => Promise<unknown>;
     }
 }
-export {};

package/distribution/sender.test.js

@@ -1,160 +1,352 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument, @typescript-eslint/naming-convention */
-import { describe, test, expect, vi, beforeEach } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi, } from "vitest";
+import { isBackground, isExtensionContext } from "webext-detect";
+import { errorTabDoesntExist, errorTabWasDiscarded, errorTargetClosedEarly, getMethod, getNotifier, messenger, } from "./sender.js";
 import { handlers } from "./handlers.js";
-import * as thisTargetModule from "./thisTarget.js";
-// Mock dependencies
-vi.mock("webext-detect", () => ({
-    isBackground: vi.fn(() => false),
-    isExtensionContext: vi.fn(() => true),
-    isOffscreenDocument: vi.fn(() => false),
-    isContentScript: vi.fn(() => true),
-}));
-vi.mock("./logging.js", () => ({
-    log: {
-        debug: vi.fn(),
-        warn: vi.fn(),
-    },
-}));
-vi.mock("./events.js", () => ({
-    events: {
-        dispatchEvent: vi.fn(),
-    },
-}));
-// Mock chrome APIs - simulate content script environment (no chrome.tabs)
-globalThis.chrome = {
-    runtime: {
-        id: "test-extension-id",
-        sendMessage: vi.fn(),
-    },
-    // Note: chrome.tabs is undefined in content scripts
-};
-describe("messenger with tab targets and local methods", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        handlers.clear();
-    });
-    test("should use local method when targeting same tab and frame", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to same tab and frame
-        const result = await messenger("testMethod", {}, { tabId: 1, frameId: 0 });
-        // Verify: Handler was called locally
-        expect(mockHandler).toHaveBeenCalledOnce();
-        expect(mockHandler).toHaveBeenCalledWith();
-        expect(result).toBe("local result");
-        // Verify: No message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).not.toHaveBeenCalled();
-    });
-    test("should send message when targeting different tab", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
+import { events } from "./events.js";
+import { ExtensionNotFoundError, MessengerError } from "./shared.js";
+vi.mock("webext-detect");
+// The verbatim strings the browser throws. `sender.ts` matches on them to decide
+// whether an error is retryable, so a change in either place must break a test.
+const browserErrorNoReceiver = "Could not establish connection. Receiving end does not exist.";
+const browserErrorClosedEarly = "A listener indicated an asynchronous response by returning true, but the message channel closed before a response was received";
+/** `sender.ts` only unwraps responses carrying this marker; anything else is a third-party reply. */
+function messengerReply(value) {
+    return { __webextMessenger: true, value };
+}
+function messengerErrorReply(name, message) {
+    return { __webextMessenger: true, error: { name, message } };
+}
+/**
+ * @param tabs Contexts without the tabs API (content scripts, offscreen documents)
+ * take a different route through `messenger()`, so this must be switchable.
+ * @param invalidated Drops `runtime.id`, which is how the browser signals that the
+ * extension was reloaded out from under this context.
+ */
+function stubChrome({ tabs = true, invalidated = false } = {}) {
+    const chromeStub = {
+        runtime: {
+            id: invalidated ? undefined : "this-extension-id",
+            sendMessage: vi.fn(),
+        },
+    };
+    if (tabs) {
+        chromeStub.tabs = {
+            sendMessage: vi.fn(),
+            get: vi
+                .fn()
+                .mockResolvedValue({ discarded: false }),
         };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler (should not be used)
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Mock chrome.runtime.sendMessage to return a messenger response
-        vi.mocked(chrome.runtime.sendMessage).mockResolvedValue({
+    }
+    vi.stubGlobal("chrome", chromeStub);
+    return chromeStub;
+}
+/** The message envelope is always the last argument of a `runtime.sendMessage` call. */
+function sentEnvelope(mock, index = 0) {
+    return mock.mock.calls[index].at(-1);
+}
+const eventCleanups = [];
+function trackEvent(name) {
+    const listener = vi.fn();
+    events.addEventListener(name, listener);
+    eventCleanups.push(() => {
+        events.removeEventListener(name, listener);
+    });
+    return listener;
+}
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.resetAllMocks();
+    handlers.clear();
+    for (const cleanup of eventCleanups.splice(0)) {
+        cleanup();
+    }
+});
+describe("messenger() routing", () => {
+    test("sends to another extension via runtime.sendMessage(extensionId, message)", async () => {
+        const chromeStub = stubChrome();
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply(3));
+        await expect(messenger("senderTestMethod", {}, { extensionId: "other-extension" }, 1)).resolves.toBe(3);
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledWith("other-extension", expect.objectContaining({
             __webextMessenger: true,
-            value: "remote result",
+            type: "senderTestMethod",
+            args: [1],
+            target: { extensionId: "other-extension" },
+        }));
+    });
+    test("throws synchronously when the browser cannot message other extensions", () => {
+        vi.stubGlobal("chrome", {});
+        expect(() => {
+            void messenger("senderTestMethod", {}, { extensionId: "other-extension" }, 1);
+        }).toThrow(ExtensionNotFoundError);
+    });
+    test("invokes the local handler when the background page targets itself", async () => {
+        const chromeStub = stubChrome();
+        vi.mocked(isBackground).mockReturnValue(true);
+        const handler = vi.fn().mockResolvedValue(42);
+        handlers.set("senderTestMethod", handler);
+        await expect(messenger("senderTestMethod", {}, { page: "background" }, 1, 2)).resolves.toBe(42);
+        expect(handler).toHaveBeenCalledWith(1, 2);
+        expect(chromeStub.runtime.sendMessage).not.toHaveBeenCalled();
+    });
+    test("throws when the background page targets itself without a registered handler", () => {
+        stubChrome();
+        vi.mocked(isBackground).mockReturnValue(true);
+        expect(() => {
+            void messenger("senderTestMethod", {}, { page: "background" }, 1);
+        }).toThrow("No handler registered locally for senderTestMethod");
+    });
+    test("sends to an extension page via runtime.sendMessage(message)", async () => {
+        const chromeStub = stubChrome();
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        await expect(messenger("senderTestMethod", {}, { page: "/options.html" }, 1)).resolves.toBe("ok");
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+        // A single argument, otherwise the browser reads it as an extension id
+        expect(chromeStub.runtime.sendMessage.mock.calls[0]).toHaveLength(1);
+    });
+    test("routes tab targets through the runtime when the context has no tabs API", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        await expect(messenger("senderTestMethod", {}, { tabId: 1, frameId: 3 }, 1)).resolves.toBe("ok");
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+    });
+    test.each([
+        ["defaults to the top frame", { tabId: 1 }, { frameId: 0 }],
+        ["forwards an explicit frame", { tabId: 1, frameId: 5 }, { frameId: 5 }],
+        [
+            "drops frameId to reach every frame",
+            { tabId: 1, frameId: "allFrames" },
+            {},
+        ],
+    ])("sends to a tab and %s", async (_name, target, expectedOptions) => {
+        const chromeStub = stubChrome();
+        chromeStub.tabs.sendMessage.mockResolvedValue(messengerReply("ok"));
+        await expect(messenger("senderTestMethod", {}, target, 1)).resolves.toBe("ok");
+        expect(chromeStub.tabs.sendMessage).toHaveBeenCalledWith(1, expect.objectContaining({ type: "senderTestMethod" }), expectedOptions);
+    });
+    test("stamps every message with the marker and an increasing seq", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        await messenger("senderTestMethod", {}, { page: "/options.html" }, 1);
+        await messenger("senderTestMethod", {}, { page: "/options.html" }, 2);
+        const first = sentEnvelope(chromeStub.runtime.sendMessage, 0);
+        const second = sentEnvelope(chromeStub.runtime.sendMessage, 1);
+        expect(first.__webextMessenger).toBe(true);
+        expect(second.options.seq).toBe(first.options.seq + 1);
+    });
+});
+/**
+ * Regression guard for #409: 0.35.0 hoisted a `compareTargets()` short-circuit onto
+ * the send path, which threw `TypeError: Invalid URL` in opaque-origin frames and
+ * mis-routed same-tab messages to the sending frame. Reverted in #410.
+ */
+describe("sending from a content script (regression: #409)", () => {
+    beforeEach(() => {
+        // A sandboxed `about:srcdoc` frame has an opaque origin, so `location.origin`
+        // is the literal string "null" and `new URL(page, location.origin)` throws.
+        vi.stubGlobal("location", {
+            origin: "null",
+            protocol: "about:",
+            pathname: "srcdoc",
+            search: "",
         });
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to different tab
-        const result = await messenger("testMethod", {}, { tabId: 2, frameId: 0 });
-        // Verify: Message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).toHaveBeenCalledOnce();
-        expect(result).toBe("remote result");
-        // Verify: Local handler was not called
-        expect(mockHandler).not.toHaveBeenCalled();
-    });
-    test("should send message when targeting different frame in same tab", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler (should not be used)
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Mock chrome.runtime.sendMessage to return a messenger response
-        vi.mocked(chrome.runtime.sendMessage).mockResolvedValue({
-            __webextMessenger: true,
-            value: "remote result",
+    });
+    test("reaches the runtime from an opaque-origin frame", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        const localHandler = vi.fn();
+        handlers.set("senderTestMethod", localHandler);
+        // `{page: "any"}` is the target used by `storeTabData()`, the first message
+        // every content script sends; in 0.35.0 it threw before routing.
+        await expect(messenger("senderTestMethod", {}, { page: "any" }, 1)).resolves.toBe("ok");
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+        expect(localHandler).not.toHaveBeenCalled();
+    });
+    test("does not handle a same-tab target locally", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        const localHandler = vi.fn();
+        handlers.set("senderTestMethod", localHandler);
+        // A frame sending to `{tabId}` means the *top* frame, never itself.
+        await expect(messenger("senderTestMethod", {}, { tabId: 1 }, 1)).resolves.toBe("ok");
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+        expect(localHandler).not.toHaveBeenCalled();
+    });
+});
+describe("messenger() responses", () => {
+    test("returns the value from a messenger reply", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply({ a: 1 }));
+        await expect(messenger("senderTestMethod", {}, { page: "/options.html" }, 1)).resolves.toEqual({ a: 1 });
+    });
+    test("rethrows a deserialized error from a messenger reply", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerErrorReply("TypeError", "Handler exploded"));
+        await expect(messenger("senderTestMethod", {}, { page: "/options.html" }, 1)).rejects.toThrow("Handler exploded");
+        // A genuine error from the target must not be retried
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+    });
+    test("reports a missing page target when nobody answers", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(undefined);
+        await expect(messenger("senderTestMethod", { retry: false }, { page: "/options.html" }, 1)).rejects.toThrow('The target {"page":"/options.html"} for senderTestMethod was not found');
+    });
+    test("reports a messenger-less tab when nobody answers", async () => {
+        const chromeStub = stubChrome();
+        chromeStub.tabs.sendMessage.mockResolvedValue(undefined);
+        await expect(messenger("senderTestMethod", { retry: false }, { tabId: 1 }, 1)).rejects.toThrow("Messenger was not available in the target");
+    });
+    test("reports a conflict when a third-party listener answers", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue("not a messenger reply");
+        await expect(messenger("senderTestMethod", { retry: false }, { page: "/options.html" }, 1)).rejects.toThrow("Conflict: The message senderTestMethod was handled by a third-party listener");
+    });
+});
+describe("retry behaviour", () => {
+    test("retries until the receiving end exists", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage
+            .mockRejectedValueOnce(new Error(browserErrorNoReceiver))
+            .mockResolvedValueOnce(messengerReply("ok"));
+        const promise = messenger("senderTestMethod", {}, { page: "/options.html" }, 1);
+        const assertion = expect(promise).resolves.toBe("ok");
+        await vi.advanceTimersByTimeAsync(500);
+        await assertion;
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledTimes(2);
+    });
+    test("retries a MessengerError, which means the target is still booting", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage
+            .mockResolvedValueOnce(messengerErrorReply("MessengerError", "No handlers registered in x"))
+            .mockResolvedValueOnce(messengerReply("ok"));
+        const promise = messenger("senderTestMethod", {}, { page: "/options.html" }, 1);
+        const assertion = expect(promise).resolves.toBe("ok");
+        await vi.advanceTimersByTimeAsync(500);
+        await assertion;
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledTimes(2);
+    });
+    test("makes a single attempt when retry is disabled", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error(browserErrorNoReceiver));
+        await expect(messenger("senderTestMethod", { retry: false }, { page: "/options.html" }, 1)).rejects.toThrow('The target {"page":"/options.html"} for senderTestMethod was not found');
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+    });
+    test("does not retry once the target has closed early", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error(browserErrorClosedEarly));
+        await expect(messenger("senderTestMethod", {}, { page: "/options.html" }, 1)).rejects.toThrow(errorTargetClosedEarly);
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+    });
+    test("does not retry a missing external extension", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error(browserErrorNoReceiver));
+        await expect(messenger("senderTestMethod", {}, { extensionId: "other-extension" }, 1)).rejects.toThrow(ExtensionNotFoundError);
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+    });
+    test("stops as soon as the extension context is invalidated", async () => {
+        const chromeStub = stubChrome({ tabs: false, invalidated: true });
+        vi.mocked(isExtensionContext).mockReturnValue(true);
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error(browserErrorNoReceiver));
+        await expect(messenger("senderTestMethod", {}, { page: "/options.html" }, 1)).rejects.toThrow("Extension context invalidated.");
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+    });
+    test("stops retrying when the target tab is gone", async () => {
+        const chromeStub = stubChrome();
+        chromeStub.tabs.sendMessage.mockRejectedValue(new Error(browserErrorNoReceiver));
+        chromeStub.tabs.get.mockRejectedValue(new Error("No tab with id: 1."));
+        await expect(messenger("senderTestMethod", {}, { tabId: 1 }, 1)).rejects.toThrow(errorTabDoesntExist);
+        expect(chromeStub.tabs.sendMessage).toHaveBeenCalledOnce();
+    });
+    test("stops retrying when the target tab was discarded", async () => {
+        const chromeStub = stubChrome();
+        chromeStub.tabs.sendMessage.mockRejectedValue(new Error(browserErrorNoReceiver));
+        chromeStub.tabs.get.mockResolvedValue({ discarded: true });
+        await expect(messenger("senderTestMethod", {}, { tabId: 1 }, 1)).rejects.toThrow(errorTabWasDiscarded);
+        expect(chromeStub.tabs.sendMessage).toHaveBeenCalledOnce();
+    });
+    test("gives up after the retry window and announces attempts-exhausted", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error("No handlers registered in background"));
+        const failedAttempt = trackEvent("failed-attempt");
+        const attemptsExhausted = trackEvent("attempts-exhausted");
+        const promise = messenger("senderTestMethod", {}, { page: "/options.html" }, 1);
+        const assertion = expect(promise).rejects.toThrow("No handlers registered in background");
+        await vi.advanceTimersByTimeAsync(10_000);
+        await assertion;
+        expect(attemptsExhausted).toHaveBeenCalledOnce();
+        expect(failedAttempt.mock.calls.length).toBe(chromeStub.runtime.sendMessage.mock.calls.length);
+        expect(chromeStub.runtime.sendMessage.mock.calls.length).toBeGreaterThan(1);
+    });
+    test("backs off exponentially rather than hammering the target", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error(browserErrorNoReceiver));
+        const promise = messenger("senderTestMethod", {}, { page: "/options.html" }, 1);
+        const assertion = expect(promise).rejects.toThrow(MessengerError);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledTimes(2);
+        // The second wait is longer than the first, so no third attempt yet
+        await vi.advanceTimersByTimeAsync(100);
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(10_000);
+        await assertion;
+        // The safety cap in `manageMessage` must never be the reason we stopped
+        expect(chromeStub.runtime.sendMessage.mock.calls.length).toBeLessThan(15);
+    });
+});
+describe("notifications", () => {
+    test("return undefined, send once, and swallow errors", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error(browserErrorNoReceiver));
+        // Re-typed to capture the runtime value: notifications are typed `void`, and
+        // callers rely on nothing awaitable coming back.
+        const send = messenger;
+        const result = send("senderTestMethod", { isNotification: true }, { page: "/options.html" }, 1);
+        expect(result).toBeUndefined();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
+    });
+});
+describe("getMethod() and getNotifier()", () => {
+    test("getMethod binds a fixed target", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        const method = getMethod("senderTestMethod", { page: "/options.html" });
+        await expect(method(1, 2)).resolves.toBe("ok");
+        expect(sentEnvelope(chromeStub.runtime.sendMessage)).toMatchObject({
+            args: [1, 2],
+            target: { page: "/options.html" },
         });
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to different frame in same tab
-        const result = await messenger("testMethod", {}, { tabId: 1, frameId: 1 });
-        // Verify: Message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).toHaveBeenCalledOnce();
-        expect(result).toBe("remote result");
-        // Verify: Local handler was not called
-        expect(mockHandler).not.toHaveBeenCalled();
-    });
-    test("should send message when targeting allFrames", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler (should not be used for allFrames)
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Mock chrome.runtime.sendMessage to return a messenger response
-        vi.mocked(chrome.runtime.sendMessage).mockResolvedValue({
-            __webextMessenger: true,
-            value: "remote result",
+    });
+    test("getMethod awaits a promised target", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        const method = getMethod("senderTestMethod", Promise.resolve({ tabId: 1, frameId: 2 }));
+        await expect(method(1)).resolves.toBe("ok");
+        expect(sentEnvelope(chromeStub.runtime.sendMessage)).toMatchObject({
+            target: { tabId: 1, frameId: 2 },
         });
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to allFrames in same tab
-        const result = await messenger("testMethod", {}, { tabId: 1, frameId: "allFrames" });
-        // Verify: Message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).toHaveBeenCalledOnce();
-        expect(result).toBe("remote result");
-        // Verify: Local handler was not called
-        expect(mockHandler).not.toHaveBeenCalled();
-    });
-    test("should throw error when no local handler registered for same tab/frame", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // No handler registered
-        // Import messenger and MessengerError after mocks are set up
-        const { messenger } = await import("./sender.js");
-        const { MessengerError } = await import("./shared.js");
-        // Test: Send message to same tab and frame without handler
-        try {
-            await messenger("testMethod", {}, { tabId: 1, frameId: 0 });
-            expect.fail("Should have thrown an error");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(MessengerError);
-            expect(error.message).toBe("No handler registered locally for testMethod");
-        }
-        // Verify: No message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).not.toHaveBeenCalled();
+    });
+    test("getMethod without a target takes it as the first argument", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockResolvedValue(messengerReply("ok"));
+        const method = getMethod("senderTestMethod");
+        await expect(method({ page: "/options.html" }, 1)).resolves.toBe("ok");
+        expect(sentEnvelope(chromeStub.runtime.sendMessage)).toMatchObject({
+            args: [1],
+            target: { page: "/options.html" },
+        });
+    });
+    test("getNotifier returns void and never rejects", async () => {
+        const chromeStub = stubChrome({ tabs: false });
+        chromeStub.runtime.sendMessage.mockRejectedValue(new Error("boom"));
+        const notify = getNotifier("senderTestMethod", { page: "/options.html" });
+        const result = notify(1);
+        expect(result).toBeUndefined();
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(chromeStub.runtime.sendMessage).toHaveBeenCalledOnce();
     });
 });

package/distribution/targetLogic.test.js

@@ -16,6 +16,7 @@ const tab = {
     selected: true,
     autoDiscardable: false,
     groupId: -1,
+    lastAccessed: 0,
 };
 const senders = {
     contentScript: { tab },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webext-messenger",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "Browser Extension component messaging framework",
   "keywords": [],
   "repository": "pixiebrix/webext-messenger",
@@ -27,18 +27,18 @@
     "watch": "tsc --watch"
   },
   "dependencies": {
-    "one-event": "^4.3.0",
-    "serialize-error": "^12.0.0",
-    "type-fest": "^5.0.1",
-    "webext-detect": "^5.3.2"
+    "one-event": "^4.4.0",
+    "serialize-error": "^13.0.2",
+    "type-fest": "^5.10.0",
+    "webext-detect": "^6.0.0"
   },
   "@parcel/resolver-default": {
     "packageExports": true
   },
   "devDependencies": {
-    "@parcel/config-webextension": "^2.16.0",
-    "@sindresorhus/tsconfig": "^8.0.1",
-    "@types/chrome": "^0.1.22",
+    "@parcel/config-webextension": "^2.16.3",
+    "@sindresorhus/tsconfig": "^8.1.0",
+    "@types/chrome": "^0.3.0",
     "@types/tape": "^5.8.1",
     "buffer": "^6.0.3",
     "eslint": "^8.57.0",
@@ -49,9 +49,9 @@
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
     "stream-browserify": "^3.0.0",
-    "tape": "^5.9.0",
-    "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "tape": "^5.10.2",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.2"
   },
   "targets": {
     "main": false,