chrome-in-iframe 2.0.0 → 2.0.1

package/dist/index.js

@@ -1,6 +1,22 @@
 import { nanoid } from 'nanoid';
 import { LRUCache } from 'lru-cache';
 
+const PREFIX = 'chrome-in-iframe';
+const defaultLogger = (scope, ...args) => {
+    if (typeof console !== 'undefined' && typeof console.warn === 'function') {
+        console.warn(`[${PREFIX}] ${scope}`, ...args);
+    }
+};
+let activeLogger = defaultLogger;
+function setLogger(logger) {
+    activeLogger = logger;
+}
+function warn(scope, ...args) {
+    if (!activeLogger)
+        return;
+    activeLogger(scope, ...args);
+}
+
 const WELL_KNOWN_SYMBOLS = {
     asyncIterator: Symbol.asyncIterator,
     hasInstance: Symbol.hasInstance,
@@ -16,12 +32,9 @@ const WELL_KNOWN_SYMBOLS = {
     toStringTag: Symbol.toStringTag,
     unscopables: Symbol.unscopables,
 };
+const WELL_KNOWN_SYMBOL_NAMES = new Map(Object.entries(WELL_KNOWN_SYMBOLS).map(([name, symbol]) => [symbol, name]));
 function getWellKnownSymbolName(value) {
-    for (const [name, symbol] of Object.entries(WELL_KNOWN_SYMBOLS)) {
-        if (symbol === value)
-            return name;
-    }
-    return undefined;
+    return WELL_KNOWN_SYMBOL_NAMES.get(value);
 }
 function getWellKnownSymbol(name) {
     return WELL_KNOWN_SYMBOLS[name];
@@ -32,6 +45,11 @@ function serializeThrownError(err) {
     }
     return { message: String(err) };
 }
+function isPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
 
 function serializePath(path) {
     return path.map((key) => {
@@ -117,15 +135,23 @@ function serializeMessageData(type, data) {
 
 function createMessageChannel(poster, key, instanceId, context, processorRegistry) {
     const sender = createMessageSender(poster, key, instanceId);
+    const keyMatch = `"key":${JSON.stringify(key)}`;
     const listener = (event) => {
+        if (typeof event.data !== 'string')
+            return;
+        if (event.data.length === 0 || event.data.charCodeAt(0) !== 123 /* '{' */)
+            return;
+        if (event.data.indexOf(keyMatch) === -1)
+            return;
         let body;
         try {
             body = JSON.parse(event.data);
         }
-        catch {
+        catch (err) {
+            warn('createMessageChannel', 'failed to parse incoming message as JSON', err);
             return;
         }
-        if (!isMessageBody(body))
+        if (!isMessageEnvelope(body))
             return;
         if (body.key !== key)
             return;
@@ -136,6 +162,8 @@ function createMessageChannel(poster, key, instanceId, context, processorRegistr
         const handler = processorRegistry.get(body.type);
         if (!handler)
             return;
+        if (!isValidMessagePayload(body))
+            return;
         const meta = { senderInstanceId: body.senderInstanceId };
         try {
             handler(deserializeMessageData(body), context, meta);
@@ -149,34 +177,25 @@ function createMessageChannel(poster, key, instanceId, context, processorRegistr
         getSender() {
             return sender;
         },
-        getContext() {
-            return context;
-        },
-        getPoster() {
-            return poster;
-        },
-        getKey() {
-            return key;
-        },
-        getInstanceId() {
-            return instanceId;
-        },
         destroy() {
             poster.removeEventListener('message', listener);
         },
     };
 }
-function isMessageBody(value) {
+function isMessageEnvelope(value) {
     if (!isRecord(value))
         return false;
-    if (typeof value.type !== 'string')
+    if (typeof value.type !== 'string' || value.type.length === 0)
         return false;
     if (typeof value.key !== 'string')
         return false;
-    if (typeof value.senderInstanceId !== 'string')
+    if (typeof value.senderInstanceId !== 'string' || value.senderInstanceId.length === 0)
         return false;
     if ('targetInstanceId' in value && typeof value.targetInstanceId !== 'string' && value.targetInstanceId !== undefined)
         return false;
+    return true;
+}
+function isValidMessagePayload(value) {
     switch (value.type) {
         case 'invokeRequest':
             return isInvokeRequest(value.data);
@@ -265,7 +284,7 @@ function sendProcessorError(body, sender, err) {
     if (body.type === 'invokeFunctionByIdRequest') {
         const data = body.data;
         const error = serializeThrownError(err);
-        console.warn(`chrome-in-iframe: callback '${data.id}' failed: ${error.message}`);
+        warn('sendProcessorError', `callback '${data.id}' failed: ${error.message}`);
         sender.sendMessage('invokeFunctionByIdResponse', {
             id: data.callId,
             error,
@@ -570,8 +589,8 @@ function deserializeError(source, generateCallback, getRemoteCallback) {
         try {
             error.name = name;
         }
-        catch {
-            // ignore non-writable name
+        catch (err) {
+            warn('deserializeError', 'failed to set error.name', name, err);
         }
     }
     if (typeof source.stack === 'string')
@@ -587,10 +606,10 @@ function deserializeError(source, generateCallback, getRemoteCallback) {
             if (typeof rawKey !== 'string')
                 continue;
             try {
-                error[rawKey] = deserialize0(rawValue, generateCallback, getRemoteCallback);
+                setOwnProperty(error, rawKey, deserialize0(rawValue, generateCallback, getRemoteCallback));
             }
-            catch {
-                // ignore non-writable property
+            catch (err) {
+                warn('deserializeError', 'failed to set error property', rawKey, err);
             }
         }
     }
@@ -607,7 +626,7 @@ function deserializeWrappedObject(entries, generateCallback, getRemoteCallback)
         const value = deserialize0(entry[1], generateCallback, getRemoteCallback);
         const key = resolveObjectKey(rawKey);
         if (key === undefined) {
-            console.warn('chrome-in-iframe: dropping wrapped-object entry with unresolvable key', rawKey);
+            warn('deserializeWrappedObject', 'dropping wrapped-object entry with unresolvable key', rawKey);
             continue;
         }
         Object.defineProperty(result, key, {
@@ -628,7 +647,8 @@ function resolveObjectKey(raw) {
             try {
                 return deserializeSymbol(tagged.v);
             }
-            catch {
+            catch (err) {
+                warn('resolveObjectKey', 'failed to deserialize symbol key', tagged.v, err);
                 return undefined;
             }
         }
@@ -673,7 +693,7 @@ function setOwnProperty(target, key, value) {
 
 function isListenerRegistrationPath(path) {
     const last = path[path.length - 1];
-    return last === 'addListener' || last === 'hasListener';
+    return last === 'addListener';
 }
 function isListenerRemovalPath(path) {
     const last = path[path.length - 1];
@@ -694,23 +714,6 @@ function readProperty(target, key) {
     return target[key];
 }
 
-const boundCache = new WeakMap();
-function bindMethod(fn, owner) {
-    if (owner === null || typeof owner !== 'object') {
-        return (...args) => Reflect.apply(fn, owner, args);
-    }
-    let perOwner = boundCache.get(fn);
-    if (!perOwner) {
-        perOwner = new WeakMap();
-        boundCache.set(fn, perOwner);
-    }
-    const cached = perOwner.get(owner);
-    if (cached)
-        return cached;
-    const bound = (...args) => Reflect.apply(fn, owner, args);
-    perOwner.set(owner, bound);
-    return bound;
-}
 function handleAccessPropertyRequest(data, ctx, meta) {
     const target = ctx.getDelegateTarget();
     const channel = ctx.getMessageChannel();
@@ -721,7 +724,7 @@ function handleAccessPropertyRequest(data, ctx, meta) {
         }, meta.senderInstanceId);
         return;
     }
-    if (!target) {
+    if (target === undefined || target === null) {
         channel.getSender().sendMessage('accessPropertyResponse', {
             id: data.id,
             error: { message: 'No delegate target is configured' },
@@ -731,18 +734,24 @@ function handleAccessPropertyRequest(data, ctx, meta) {
     try {
         let current = target;
         let owner = target;
-        for (const key of data.path) {
+        for (let i = 0; i < data.path.length; i++) {
+            const key = data.path[i];
             if (current === undefined || current === null) {
                 channel.getSender().sendMessage('accessPropertyResponse', {
                     id: data.id,
-                    data: serialize(current, ctx.registerFunction),
+                    error: {
+                        message: `Cannot read property '${String(key)}' of ${current === null ? 'null' : 'undefined'} (at '${data.path
+                            .slice(0, i)
+                            .map(String)
+                            .join('.')}')`,
+                    },
                 }, meta.senderInstanceId);
                 return;
             }
             owner = current;
             current = readProperty(current, key);
         }
-        const value = typeof current === 'function' ? bindMethod(current, owner) : current;
+        const value = typeof current === 'function' ? ctx.bindMethod(current, owner) : current;
         channel.getSender().sendMessage('accessPropertyResponse', {
             id: data.id,
             data: serialize(value, ctx.registerFunction, { persistent: isLikelyListenerPath(data.path) }),
@@ -761,17 +770,21 @@ function handleAccessPropertyResponse(data, ctx, meta) {
         return;
     if (data.error) {
         const err = new Error(data.error.message);
-        err.stack = data.error.stack;
+        if (data.error.stack)
+            err.stack = data.error.stack;
+        pending.onReject?.();
         pending.reject(err);
         return;
     }
     const scopedRemoteCallback = createScopedRemoteCallback$2(ctx, meta.senderInstanceId);
     try {
+        pending.onResolve?.();
         pending.resolve(deserialize(data.data, (id, args, options) => {
             return ctx.invokeFunctionById(id, args, options);
         }, scopedRemoteCallback));
     }
     catch (err) {
+        pending.onReject?.();
         pending.reject(err instanceof Error ? err : new Error(String(err)));
     }
 }
@@ -783,13 +796,20 @@ function handleInvokeRequest(data, ctx, meta) {
     const target = ctx.getDelegateTarget();
     const channel = ctx.getMessageChannel();
     const scopedRemoteCallback = createScopedRemoteCallback$1(ctx, meta.senderInstanceId);
-    if (!target) {
+    if (target === undefined || target === null) {
         channel.getSender().sendMessage('invokeResponse', {
             id: data.id,
             error: { message: 'No delegate target is configured' },
         }, meta.senderInstanceId);
         return;
     }
+    if (data.path.length === 0) {
+        channel.getSender().sendMessage('invokeResponse', {
+            id: data.id,
+            error: { message: 'Invocation path must not be empty' },
+        }, meta.senderInstanceId);
+        return;
+    }
     let current = target;
     for (let i = 0; i < data.path.length - 1; i++) {
         current = readProperty(current, data.path[i]);
@@ -797,7 +817,10 @@ function handleInvokeRequest(data, ctx, meta) {
             channel.getSender().sendMessage('invokeResponse', {
                 id: data.id,
                 error: {
-                    message: `Cannot read property '${String(data.path[i + 1])}' of ${String(data.path[i])}`,
+                    message: `Cannot read property '${String(data.path[i + 1])}' of ${current === null ? 'null' : 'undefined'} (at '${data.path
+                        .slice(0, i + 1)
+                        .map(String)
+                        .join('.')}')`,
                 },
             }, meta.senderInstanceId);
             return;
@@ -836,8 +859,8 @@ function handleInvokeRequest(data, ctx, meta) {
         }, meta.senderInstanceId);
         return;
     }
-    if (result instanceof Promise) {
-        result
+    if (isPromiseLike(result)) {
+        Promise.resolve(result)
             .then((value) => {
             sendInvokeSuccess(data.id, value, ctx, meta.senderInstanceId);
         })
@@ -847,10 +870,9 @@ function handleInvokeRequest(data, ctx, meta) {
                 error: serializeThrownError(err),
             }, meta.senderInstanceId);
         });
+        return;
     }
-    else {
-        sendInvokeSuccess(data.id, result, ctx, meta.senderInstanceId);
-    }
+    sendInvokeSuccess(data.id, result, ctx, meta.senderInstanceId);
 }
 function handleInvokeResponse(data, ctx, meta) {
     const pending = ctx.getAndRemovePendingPromise(data.id);
@@ -858,17 +880,21 @@ function handleInvokeResponse(data, ctx, meta) {
         return;
     if (data.error) {
         const err = new Error(data.error.message);
-        err.stack = data.error.stack;
+        if (data.error.stack)
+            err.stack = data.error.stack;
+        pending.onReject?.();
         pending.reject(err);
     }
     else {
         const scopedRemoteCallback = createScopedRemoteCallback$1(ctx, meta.senderInstanceId);
         try {
+            pending.onResolve?.();
             pending.resolve(deserialize(data.data, (id, args, options) => {
                 return ctx.invokeFunctionById(id, args, options);
             }, scopedRemoteCallback));
         }
         catch (err) {
+            pending.onReject?.();
             pending.reject(err instanceof Error ? err : new Error(String(err)));
         }
     }
@@ -898,7 +924,7 @@ function handleCallbackInvoke(data, ctx, meta) {
     const entry = persistentEntry ?? ctx.getFunctionCache().get(data.id);
     if (!entry) {
         const error = { message: `Callback '${data.id}' is not available or has expired` };
-        console.warn(`chrome-in-iframe: ${error.message}`);
+        warn('handleCallbackInvoke', error.message);
         channel.getSender().sendMessage('invokeFunctionByIdResponse', {
             id: data.callId,
             error,
@@ -918,8 +944,8 @@ function handleCallbackInvoke(data, ctx, meta) {
     }
     try {
         const result = Reflect.apply(entry.fn, entry.thisArg, deserializedArgs);
-        if (result instanceof Promise) {
-            result
+        if (isPromiseLike(result)) {
+            Promise.resolve(result)
                 .then((value) => {
                 sendCallbackSuccess(data.callId, value, ctx, meta.senderInstanceId);
             })
@@ -940,17 +966,21 @@ function handleCallbackInvokeResponse(data, ctx, meta) {
         return;
     if (data.error) {
         const err = new Error(data.error.message);
-        err.stack = data.error.stack;
+        if (data.error.stack)
+            err.stack = data.error.stack;
+        pending.onReject?.();
         pending.reject(err);
         return;
     }
     const scopedRemoteCallback = createScopedRemoteCallback(ctx, meta.senderInstanceId);
     try {
+        pending.onResolve?.();
         pending.resolve(deserialize(data.data, (id, args, options) => {
             return ctx.invokeFunctionById(id, args, options);
         }, scopedRemoteCallback));
     }
     catch (err) {
+        pending.onReject?.();
         pending.reject(err instanceof Error ? err : new Error(String(err)));
     }
 }
@@ -979,13 +1009,17 @@ function createScopedRemoteCallback(ctx, remoteInstanceId) {
     return (id, invoke, options) => ctx.getRemoteCallback(id, invoke, options, remoteInstanceId);
 }
 
-const MAX_RELEASE_BATCH = 10000;
-function handleReleaseCallbacks(data, ctx, _meta) {
-    if (data.ids.length > MAX_RELEASE_BATCH)
-        return;
-    for (const id of data.ids) {
-        ctx.getFunctionCache().delete(id);
-        ctx.getPersistentFunctionCache().delete(id);
+const MAX_RELEASE_IDS = 100000;
+function handleReleaseCallbacks(data, ctx, meta) {
+    const ids = data.ids;
+    const total = ids.length > MAX_RELEASE_IDS ? MAX_RELEASE_IDS : ids.length;
+    if (ids.length > MAX_RELEASE_IDS) {
+        warn('handleReleaseCallbacks', `releaseCallbacks payload exceeds cap (${ids.length} > ${MAX_RELEASE_IDS}); only the first ${MAX_RELEASE_IDS} ids will be released`);
+    }
+    const effectiveIds = total === ids.length ? ids : ids.slice(0, total);
+    ctx.releaseRemoteCallbacks(meta.senderInstanceId, effectiveIds);
+    for (let i = 0; i < total; i++) {
+        ctx.dropLocalCallback(ids[i]);
     }
 }
 function handleDestroyEndpoint(_data, ctx, meta) {
@@ -1009,24 +1043,60 @@ const DEFAULT_FUNCTION_CACHE_MAX = 100;
 const DEFAULT_FUNCTION_CACHE_TTL = 5 * 60 * 1000;
 const DEFAULT_REMOTE_CALLBACK_CACHE_MAX = 500;
 const DEFAULT_REMOTE_CALLBACK_CACHE_TTL = 5 * 60 * 1000;
+function resolveTimeout(raw) {
+    if (raw === undefined)
+        return DEFAULT_TIMEOUT;
+    if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0)
+        return DEFAULT_TIMEOUT;
+    return raw;
+}
 function createClientContext(getMessageChannel, instanceId, options = {}) {
     const remoteCacheMax = options.remoteCallbackCacheMax ?? DEFAULT_REMOTE_CALLBACK_CACHE_MAX;
     const remoteCacheTtl = options.remoteCallbackCacheTtl ?? DEFAULT_REMOTE_CALLBACK_CACHE_TTL;
+    const callTimeout = resolveTimeout(options.timeout);
     const pending = new Map();
     const functionIds = new Map();
+    const persistentFunctionCache = new Map();
+    const persistentRefcount = new Map();
     const functionCache = new LRUCache({
         max: options.functionCacheMax ?? DEFAULT_FUNCTION_CACHE_MAX,
         ttl: options.functionCacheTtl ?? DEFAULT_FUNCTION_CACHE_TTL,
-        dispose: (value, _key, reason) => {
+        dispose: (value, key, reason) => {
             if (reason === 'set' || reason === 'delete')
                 return;
-            functionIds.delete(value.fn);
+            if (persistentFunctionCache.has(key))
+                return;
+            removeFunctionIdMapping(value.fn, value.thisArg);
         },
     });
-    const persistentFunctionCache = new Map();
     const remoteCallbacksByOwner = new Map();
     const persistentRemoteCallbacksByOwner = new Map();
+    const boundMethodCache = new WeakMap();
     let destroyed = false;
+    const bindMethod = (fn, owner) => {
+        if (owner === null || typeof owner !== 'object') {
+            return (...args) => Reflect.apply(fn, owner, args);
+        }
+        let perOwner = boundMethodCache.get(fn);
+        if (!perOwner) {
+            perOwner = new WeakMap();
+            boundMethodCache.set(fn, perOwner);
+        }
+        const cached = perOwner.get(owner);
+        if (cached)
+            return cached;
+        const bound = (...args) => Reflect.apply(fn, owner, args);
+        perOwner.set(owner, bound);
+        return bound;
+    };
+    const removeFunctionIdMapping = (fn, thisArg) => {
+        const perOwner = functionIds.get(fn);
+        if (!perOwner)
+            return;
+        perOwner.delete(thisArg);
+        if (perOwner.size === 0)
+            functionIds.delete(fn);
+    };
     const getOrCreateRemoteLru = (remoteId) => {
         let lru = remoteCallbacksByOwner.get(remoteId);
         if (!lru) {
@@ -1044,21 +1114,51 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
         return map;
     };
     const registerFunction = (fn, thisArg, callbackOptions = {}) => {
-        let id = functionIds.get(fn);
+        let perOwner = functionIds.get(fn);
+        if (!perOwner) {
+            perOwner = new Map();
+            functionIds.set(fn, perOwner);
+        }
+        let id = perOwner.get(thisArg);
         if (!id) {
             id = createId('cb');
-            functionIds.set(fn, id);
+            perOwner.set(thisArg, id);
         }
         const entry = { fn, thisArg };
         if (callbackOptions.persistent) {
             persistentFunctionCache.set(id, entry);
             functionCache.delete(id);
+            persistentRefcount.set(id, (persistentRefcount.get(id) ?? 0) + 1);
         }
         else if (!persistentFunctionCache.has(id)) {
             functionCache.set(id, entry);
         }
         return id;
     };
+    const releasePersistentRegistrationById = (id) => {
+        if (!persistentRefcount.has(id))
+            return undefined;
+        const next = (persistentRefcount.get(id) ?? 0) - 1;
+        if (next > 0) {
+            persistentRefcount.set(id, next);
+            return undefined;
+        }
+        persistentRefcount.delete(id);
+        const entry = persistentFunctionCache.get(id);
+        persistentFunctionCache.delete(id);
+        functionCache.delete(id);
+        if (entry)
+            removeFunctionIdMapping(entry.fn, entry.thisArg);
+        return id;
+    };
+    const dropLocalCallback = (id) => {
+        const entry = persistentFunctionCache.get(id) ?? functionCache.get(id);
+        persistentRefcount.delete(id);
+        persistentFunctionCache.delete(id);
+        functionCache.delete(id);
+        if (entry)
+            removeFunctionIdMapping(entry.fn, entry.thisArg);
+    };
     const getRemoteCallback = (id, invoke, callbackOptions, remoteInstanceId) => {
         const opts = callbackOptions ?? {};
         const lru = remoteCallbacksByOwner.get(remoteInstanceId);
@@ -1085,10 +1185,19 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
         try {
             getMessageChannel().getSender().sendMessage('releaseCallbacks', { ids });
         }
-        catch {
-            // channel may not be available yet
+        catch (err) {
+            warn('notifyReleaseCallbacks', 'failed to release callbacks', err);
         }
     };
+    const rejectPending = (id, error) => {
+        const callbacks = pending.get(id);
+        if (!callbacks)
+            return;
+        clearTimeout(callbacks.timer);
+        pending.delete(id);
+        callbacks.onReject?.();
+        callbacks.reject(error);
+    };
     return {
         getDelegateTarget() {
             return options.delegateTarget;
@@ -1119,9 +1228,6 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
             }
             return callbacks;
         },
-        registerPendingPromise(id, callbacks) {
-            pending.set(id, callbacks);
-        },
         invoke(path, args) {
             return new Promise((resolve, reject) => {
                 if (destroyed) {
@@ -1129,35 +1235,63 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
                     return;
                 }
                 const id = createId('req');
-                const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+                const persistent = isListenerRegistrationPath(path);
+                const registeredIds = [];
+                const collectingRegister = (fn, thisArg, opts) => {
+                    const cbId = registerFunction(fn, thisArg, opts);
+                    registeredIds.push(cbId);
+                    return cbId;
+                };
+                const releaseRegisteredPersistents = () => {
+                    const released = [];
+                    for (const cbId of registeredIds) {
+                        const releasedId = releasePersistentRegistrationById(cbId);
+                        if (releasedId)
+                            released.push(releasedId);
+                    }
+                    return released;
+                };
                 const timer = setTimeout(() => {
+                    rejectPending(id, new Error(`Call timed out: ${String(path.join('.'))}`));
+                }, callTimeout);
+                try {
+                    const channel = getMessageChannel();
+                    const serializedArgs = args.map((arg) => serialize(arg, collectingRegister, { persistent }));
+                    pending.set(id, {
+                        resolve,
+                        reject,
+                        timer,
+                        onResolve: () => {
+                            if (isListenerRemovalPath(path)) {
+                                const released = releaseRegisteredPersistents();
+                                if (released.length > 0)
+                                    notifyReleaseCallbacks(released);
+                            }
+                        },
+                        onReject: () => {
+                            if (isListenerRegistrationPath(path)) {
+                                const released = releaseRegisteredPersistents();
+                                if (released.length > 0)
+                                    notifyReleaseCallbacks(released);
+                            }
+                        },
+                    });
+                    channel.getSender().sendMessage('invokeRequest', {
+                        id,
+                        path,
+                        args: serializedArgs,
+                    });
+                }
+                catch (err) {
+                    clearTimeout(timer);
                     pending.delete(id);
-                    reject(new Error(`Call timed out: ${String(path.join('.'))}`));
-                }, timeout);
-                pending.set(id, { resolve, reject, timer });
-                const channel = getMessageChannel();
-                const persistent = isListenerRegistrationPath(path);
-                const serializedArgs = args.map((arg) => serialize(arg, registerFunction, { persistent }));
-                if (isListenerRemovalPath(path)) {
-                    const releasedIds = [];
-                    for (const original of args) {
-                        if (typeof original !== 'function')
-                            continue;
-                        const fnId = functionIds.get(original);
-                        if (fnId) {
-                            releasedIds.push(fnId);
-                            functionCache.delete(fnId);
-                            persistentFunctionCache.delete(fnId);
-                            functionIds.delete(original);
-                        }
+                    if (isListenerRegistrationPath(path)) {
+                        const released = releaseRegisteredPersistents();
+                        if (released.length > 0)
+                            notifyReleaseCallbacks(released);
                     }
-                    notifyReleaseCallbacks(releasedIds);
+                    reject(err);
                 }
-                channel.getSender().sendMessage('invokeRequest', {
-                    id,
-                    path,
-                    args: serializedArgs,
-                });
             });
         },
         accessProperty(path) {
@@ -1167,16 +1301,21 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
                     return;
                 }
                 const id = createId('req');
-                const timeout = options.timeout ?? DEFAULT_TIMEOUT;
                 const timer = setTimeout(() => {
-                    pending.delete(id);
-                    reject(new Error(`Property access timed out: ${String(path.join('.'))}`));
-                }, timeout);
+                    rejectPending(id, new Error(`Property access timed out: ${String(path.join('.'))}`));
+                }, callTimeout);
                 pending.set(id, { resolve, reject, timer });
-                getMessageChannel().getSender().sendMessage('accessPropertyRequest', {
-                    id,
-                    path,
-                });
+                try {
+                    getMessageChannel().getSender().sendMessage('accessPropertyRequest', {
+                        id,
+                        path,
+                    });
+                }
+                catch (err) {
+                    clearTimeout(timer);
+                    pending.delete(id);
+                    reject(err);
+                }
             });
         },
         invokeFunctionById(callbackId, args, callbackOptions = {}) {
@@ -1186,35 +1325,77 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
                     return;
                 }
                 const callId = createId('cbcall');
-                const timeout = options.timeout ?? DEFAULT_TIMEOUT;
                 const timer = setTimeout(() => {
-                    pending.delete(callId);
-                    reject(new Error(`Callback call timed out: ${callbackId}`));
-                }, timeout);
+                    rejectPending(callId, new Error(`Callback call timed out: ${callbackId}`));
+                }, callTimeout);
                 pending.set(callId, { resolve, reject, timer });
-                getMessageChannel()
-                    .getSender()
-                    .sendMessage('invokeFunctionByIdRequest', {
-                    id: callbackId,
-                    callId,
-                    args: args.map((arg) => serialize(arg, registerFunction, callbackOptions)),
-                });
+                try {
+                    getMessageChannel()
+                        .getSender()
+                        .sendMessage('invokeFunctionByIdRequest', {
+                        id: callbackId,
+                        callId,
+                        args: args.map((arg) => serialize(arg, registerFunction, callbackOptions)),
+                    });
+                }
+                catch (err) {
+                    clearTimeout(timer);
+                    pending.delete(callId);
+                    reject(err);
+                }
             });
         },
         handleRemoteDestroy(remoteInstanceId) {
             remoteCallbacksByOwner.delete(remoteInstanceId);
             persistentRemoteCallbacksByOwner.delete(remoteInstanceId);
         },
+        releaseRemoteCallbacks(remoteInstanceId, ids) {
+            const lru = remoteCallbacksByOwner.get(remoteInstanceId);
+            const pmap = persistentRemoteCallbacksByOwner.get(remoteInstanceId);
+            if (!lru && !pmap)
+                return;
+            for (const id of ids) {
+                lru?.delete(id);
+                pmap?.delete(id);
+            }
+        },
+        dropLocalCallback(id) {
+            dropLocalCallback(id);
+        },
+        bindMethod(fn, owner) {
+            return bindMethod(fn, owner);
+        },
+        getRemoteCallbackCounts(remoteInstanceId) {
+            return {
+                lru: remoteCallbacksByOwner.get(remoteInstanceId)?.size ?? 0,
+                persistent: persistentRemoteCallbacksByOwner.get(remoteInstanceId)?.size ?? 0,
+            };
+        },
         destroy(notifyRemote = true) {
             if (destroyed)
                 return;
             destroyed = true;
             if (notifyRemote) {
+                const heldRemoteIds = [];
+                for (const lru of remoteCallbacksByOwner.values()) {
+                    for (const id of lru.keys())
+                        heldRemoteIds.push(id);
+                }
+                for (const map of persistentRemoteCallbacksByOwner.values()) {
+                    for (const id of map.keys())
+                        heldRemoteIds.push(id);
+                }
                 try {
-                    getMessageChannel().getSender().sendMessage('destroyEndpoint', { instanceId });
+                    const sender = getMessageChannel().getSender();
+                    if (heldRemoteIds.length > 0) {
+                        sender.sendMessage('releaseCallbacks', { ids: heldRemoteIds });
+                    }
+                    sender.sendMessage('destroyEndpoint', { instanceId });
                 }
-                catch {
-                    // channel may already be torn down
+                catch (err) {
+                    if (!isExpectedDestroyNotifyError(err)) {
+                        warn('destroy', 'failed to notify remote of destroy', err);
+                    }
                 }
             }
             for (const [id, callbacks] of pending) {
@@ -1224,6 +1405,7 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
             pending.clear();
             functionCache.clear();
             persistentFunctionCache.clear();
+            persistentRefcount.clear();
             functionIds.clear();
             remoteCallbacksByOwner.clear();
             persistentRemoteCallbacksByOwner.clear();
@@ -1233,6 +1415,9 @@ function createClientContext(getMessageChannel, instanceId, options = {}) {
 function createId(prefix) {
     return `${prefix}-${nanoid()}`;
 }
+function isExpectedDestroyNotifyError(err) {
+    return err instanceof Error && err.message.includes('contentWindow is not available');
+}
 
 const EMPTY_TARGET = () => undefined;
 const INTERCEPTED_STRING_PROPS = new Set([
@@ -1355,10 +1540,14 @@ function createEndpoint(options) {
     processorRegistry.register('releaseCallbacks', handleReleaseCallbacks);
     processorRegistry.register('destroyEndpoint', handleDestroyEndpoint);
     const proxy = createClientProxy((path, args) => context.invoke(path, args), (path) => context.accessProperty(path));
+    let destroyed = false;
     return {
         proxy,
         getContext: () => context,
         destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
             context.destroy(true);
             channel.destroy();
         },
@@ -1367,6 +1556,7 @@ function createEndpoint(options) {
 
 function setupInMainWindow(options) {
     const resolveTargetOrigin = createTargetOriginResolver(() => options.iframe, options.targetOrigin);
+    const allowedOrigin = createAllowedOrigin(options.allowedOrigin, resolveTargetOrigin);
     const poster = createWindowPoster({
         postMessage: (message) => {
             const contentWindow = options.iframe.contentWindow;
@@ -1376,7 +1566,7 @@ function setupInMainWindow(options) {
             contentWindow.postMessage(message, resolveTargetOrigin());
         },
         getExpectedSource: () => options.iframe.contentWindow,
-        allowedOrigin: options.allowedOrigin,
+        allowedOrigin,
     });
     const endpoint = createEndpoint({
         poster,
@@ -1399,12 +1589,13 @@ function setupInMainWindow(options) {
 }
 function setupInIframe(options = {}) {
     const resolveTargetOrigin = createParentTargetOriginResolver(options.targetOrigin);
+    const allowedOrigin = createAllowedOrigin(options.allowedOrigin, resolveTargetOrigin);
     const poster = createWindowPoster({
         postMessage: (message) => {
             window.parent.postMessage(message, resolveTargetOrigin());
         },
         getExpectedSource: () => window.parent,
-        allowedOrigin: options.allowedOrigin,
+        allowedOrigin,
     });
     const endpoint = createEndpoint({
         poster,
@@ -1439,11 +1630,23 @@ function connectChromeInIframe(options = {}) {
 }
 function createWindowPoster(options) {
     const listenerMap = new Map();
+    const getOrCreatePerName = (name) => {
+        let perName = listenerMap.get(name);
+        if (!perName) {
+            perName = new Map();
+            listenerMap.set(name, perName);
+        }
+        return perName;
+    };
     return {
         postMessage(message) {
             options.postMessage(message);
         },
         addEventListener(name, callback) {
+            const perName = getOrCreatePerName(name);
+            const existing = perName.get(callback);
+            if (existing)
+                window.removeEventListener(name, existing);
             const listener = (event) => {
                 const messageEvent = event;
                 if (messageEvent.source !== options.getExpectedSource())
@@ -1452,20 +1655,25 @@ function createWindowPoster(options) {
                     return;
                 callback(messageEvent);
             };
-            listenerMap.set(callback, listener);
+            perName.set(callback, listener);
             window.addEventListener(name, listener);
         },
         removeEventListener(name, callback) {
-            const listener = listenerMap.get(callback);
+            const perName = listenerMap.get(name);
+            if (!perName)
+                return;
+            const listener = perName.get(callback);
             if (!listener)
                 return;
             window.removeEventListener(name, listener);
-            listenerMap.delete(callback);
+            perName.delete(callback);
+            if (perName.size === 0)
+                listenerMap.delete(name);
         },
     };
 }
 function isAllowedOrigin(origin, allowedOrigin) {
-    if (!allowedOrigin)
+    if (allowedOrigin === undefined)
         return true;
     if (typeof allowedOrigin === 'function')
         return allowedOrigin(origin);
@@ -1473,6 +1681,14 @@ function isAllowedOrigin(origin, allowedOrigin) {
         return allowedOrigin.includes(origin);
     return allowedOrigin === origin;
 }
+function createAllowedOrigin(explicit, resolveTargetOrigin) {
+    if (explicit !== undefined)
+        return explicit;
+    return (origin) => {
+        const targetOrigin = resolveTargetOrigin();
+        return targetOrigin === '*' || targetOrigin === origin;
+    };
+}
 function getGlobalChrome() {
     const chromeApi = globalThis.chrome;
     if (!chromeApi) {
@@ -1502,13 +1718,11 @@ function deriveOriginFromIframe(iframe) {
                 return loc.origin;
         }
     }
-    catch {
-        // cross-origin contentWindow.location access throws — fall through
-    }
-    if (typeof console !== 'undefined') {
-        console.warn("chrome-in-iframe: unable to derive iframe origin automatically; falling back to '*'. " +
-            'Pass `targetOrigin` explicitly to lock the destination.');
+    catch (err) {
+        warn('deriveOriginFromIframe', 'unable to access cross-origin contentWindow.location', err);
     }
+    warn('deriveOriginFromIframe', "unable to derive iframe origin automatically; falling back to '*'. " +
+        'Pass `targetOrigin` explicitly to lock the destination.');
     return '*';
 }
 function deriveParentOrigin() {
@@ -1523,10 +1737,8 @@ function deriveParentOrigin() {
         if (first && first !== 'null')
             return first;
     }
-    if (typeof console !== 'undefined') {
-        console.warn("chrome-in-iframe: unable to derive parent origin automatically; falling back to '*'. " +
-            'Pass `targetOrigin` explicitly to lock the destination.');
-    }
+    warn('deriveParentOrigin', "unable to derive parent origin automatically; falling back to '*'. " +
+        'Pass `targetOrigin` explicitly to lock the destination.');
     return '*';
 }
 function parseOrigin(url) {
@@ -1537,10 +1749,11 @@ function parseOrigin(url) {
         if (parsed.origin && parsed.origin !== 'null')
             return parsed.origin;
     }
-    catch {
+    catch (err) {
+        warn('parseOrigin', 'failed to parse URL', url, err);
         return null;
     }
     return null;
 }
 
-export { connectChromeInIframe, exposeChromeInIframe, setupInIframe, setupInMainWindow };
+export { connectChromeInIframe, exposeChromeInIframe, setLogger, setupInIframe, setupInMainWindow };