chrome-in-iframe 1.0.1 → 2.0.1

package/dist/index.js

@@ -1,5 +1,21 @@
-import { LRUCache } from 'lru-cache';
 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,
@@ -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) => {
@@ -82,10 +100,17 @@ function deserializeSymbol$1(value) {
     throw new TypeError('Cannot deserialize symbol path key');
 }
 
-function createMessageSender(poster, key) {
+function createMessageSender(poster, key, instanceId) {
     return {
-        sendMessage(type, data) {
-            const body = { type, key, data: serializeMessageData(type, data) };
+        sendMessage(type, data, targetInstanceId) {
+            const body = {
+                type,
+                key,
+                data: serializeMessageData(type, data),
+                senderInstanceId: instanceId,
+            };
+            if (targetInstanceId)
+                body.targetInstanceId = targetInstanceId;
             poster.postMessage(JSON.stringify(body));
         },
     };
@@ -108,25 +133,40 @@ function serializeMessageData(type, data) {
     return data;
 }
 
-function createMessageChannel(poster, key, context, processorRegistry) {
-    const sender = createMessageSender(poster, key);
+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;
+        if (body.senderInstanceId === instanceId)
+            return;
+        if (body.targetInstanceId !== undefined && body.targetInstanceId !== instanceId)
+            return;
         const handler = processorRegistry.get(body.type);
         if (!handler)
             return;
+        if (!isValidMessagePayload(body))
+            return;
+        const meta = { senderInstanceId: body.senderInstanceId };
         try {
-            handler(deserializeMessageData(body), context);
+            handler(deserializeMessageData(body), context, meta);
         }
         catch (err) {
             sendProcessorError(body, sender, err);
@@ -137,27 +177,25 @@ function createMessageChannel(poster, key, context, processorRegistry) {
         getSender() {
             return sender;
         },
-        getContext() {
-            return context;
-        },
-        getPoster() {
-            return poster;
-        },
-        getKey() {
-            return key;
-        },
         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' || 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);
@@ -171,6 +209,10 @@ function isMessageBody(value) {
             return isCallbackRequest(value.data);
         case 'invokeFunctionByIdResponse':
             return isResponse(value.data);
+        case 'releaseCallbacks':
+            return isReleaseCallbacks(value.data);
+        case 'destroyEndpoint':
+            return isDestroyEndpoint(value.data);
         default:
             return false;
     }
@@ -182,7 +224,7 @@ function isAccessPropertyRequest(value) {
     return isRecord(value) && isMessageId(value.id) && isSerializedPath(value.path);
 }
 function isCallbackRequest(value) {
-    return isRecord(value) && typeof value.id === 'string' && isMessageId(value.callId) && Array.isArray(value.args);
+    return isRecord(value) && isMessageId(value.id) && isMessageId(value.callId) && Array.isArray(value.args);
 }
 function isResponse(value) {
     return (isRecord(value) &&
@@ -190,6 +232,12 @@ function isResponse(value) {
         (!('error' in value) || isSerializedError(value.error)) &&
         ('data' in value || 'error' in value));
 }
+function isReleaseCallbacks(value) {
+    return isRecord(value) && Array.isArray(value.ids) && value.ids.every((id) => typeof id === 'string');
+}
+function isDestroyEndpoint(value) {
+    return isRecord(value) && typeof value.instanceId === 'string';
+}
 function isSerializedError(value) {
     return (isRecord(value) && typeof value.message === 'string' && (!('stack' in value) || typeof value.stack === 'string'));
 }
@@ -222,7 +270,7 @@ function sendProcessorError(body, sender, err) {
         sender.sendMessage('invokeResponse', {
             id: data.id,
             error: serializeThrownError(err),
-        });
+        }, body.senderInstanceId);
         return;
     }
     if (body.type === 'accessPropertyRequest') {
@@ -230,113 +278,161 @@ function sendProcessorError(body, sender, err) {
         sender.sendMessage('accessPropertyResponse', {
             id: data.id,
             error: serializeThrownError(err),
-        });
+        }, body.senderInstanceId);
         return;
     }
     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,
-        });
+        }, body.senderInstanceId);
     }
 }
 
-function deserialize(arg, generateCallback, getRemoteCallback, options = {}) {
-    return deserialize0(arg, generateCallback, getRemoteCallback, options);
+const TYPE_KEY = '$cii$';
+function serialize(arg, registerFunction, options = {}) {
+    return serialize0(arg, undefined, registerFunction, options, new WeakSet());
 }
-function deserialize0(arg, generateCallback, getRemoteCallback, options = {}) {
-    if (typeof arg === 'string') {
-        return deserializePrimitive(arg, generateCallback, getRemoteCallback, options);
+function serialize0(arg, owner, registerFunction, options, seen) {
+    if (arg === undefined)
+        return { [TYPE_KEY]: 'undef' };
+    if (arg === null)
+        return null;
+    const typeOf = typeof arg;
+    if (typeOf === 'string')
+        return arg;
+    if (typeOf === 'boolean')
+        return arg;
+    if (typeOf === 'number')
+        return serializeNumber(arg);
+    if (typeOf === 'bigint')
+        return { [TYPE_KEY]: 'big', v: arg.toString() };
+    if (typeOf === 'function') {
+        const id = registerFunction(arg, owner, options);
+        return options.persistent ? { [TYPE_KEY]: 'fn', id, persistent: true } : { [TYPE_KEY]: 'fn', id };
     }
-    if (typeof arg === 'object' && arg !== null) {
-        if (Array.isArray(arg)) {
-            return arg.map((item) => deserialize0(item, generateCallback, getRemoteCallback, options));
-        }
-        const source = arg;
-        const result = {};
-        for (const key of Object.keys(arg)) {
-            setOwnProperty$1(result, key, deserialize0(source[key], generateCallback, getRemoteCallback, options));
+    if (typeOf === 'symbol')
+        return { [TYPE_KEY]: 'sym', v: serializeSymbol(arg) };
+    if (typeOf === 'object') {
+        if (seen.has(arg)) {
+            throw new TypeError('Cannot serialize circular structure');
         }
-        return result;
-    }
-    return arg;
-}
-function deserializePrimitive(value, generateCallback, getRemoteCallback, options = {}) {
-    const undefinedPrefix = '$undefined$';
-    const nullPrefix = '$null$';
-    const errorPrefix = '$error$';
-    const functionPrefix = '$function$';
-    if (value === undefinedPrefix)
-        return undefined;
-    if (value === nullPrefix)
-        return null;
-    if (value.startsWith(errorPrefix)) {
-        let serialized;
+        seen.add(arg);
         try {
-            serialized = JSON.parse(value.slice(errorPrefix.length));
-        }
-        catch {
-            return new Error('Unable to deserialize remote error');
-        }
-        const error = new Error(serialized.message);
-        error.stack = serialized.stack;
-        return error;
-    }
-    if (value.startsWith(functionPrefix)) {
-        const { id, options: functionOptions } = parseSerializedFunction(value.slice(functionPrefix.length), options);
-        const invoke = (args) => {
-            if (functionOptions.persistent) {
-                return generateCallback(id, args, functionOptions);
+            if (arg instanceof Error)
+                return serializeError(arg, owner, registerFunction, options, seen);
+            if (arg instanceof Date)
+                return { [TYPE_KEY]: 'date', v: arg.getTime() };
+            if (arg instanceof RegExp)
+                return { [TYPE_KEY]: 're', source: arg.source, flags: arg.flags };
+            if (arg instanceof Map) {
+                const entries = [];
+                for (const [k, v] of arg.entries()) {
+                    entries.push([
+                        serialize0(k, arg, registerFunction, options, seen),
+                        serialize0(v, arg, registerFunction, options, seen),
+                    ]);
+                }
+                return { [TYPE_KEY]: 'map', entries };
             }
-            else {
-                return generateCallback(id, args);
+            if (arg instanceof Set) {
+                const values = [];
+                for (const v of arg.values()) {
+                    values.push(serialize0(v, arg, registerFunction, options, seen));
+                }
+                return { [TYPE_KEY]: 'set', values };
             }
-        };
-        return getRemoteCallback
-            ? getRemoteCallback(id, invoke, functionOptions)
-            : (...args) => invoke(args);
-    }
-    const match = value.match(/^\$(\w+)\$(.*)$/s);
-    if (match) {
-        const [, type, raw] = match;
-        switch (type) {
-            case 'number':
-                return Number(raw);
-            case 'string':
-                return raw;
-            case 'boolean':
-                return raw === 'true';
-            case 'bigint':
-                return BigInt(raw);
-            case 'symbol':
-                return deserializeSymbol(raw);
+            if (Array.isArray(arg)) {
+                return arg.map((item) => serialize0(item, arg, registerFunction, options, seen));
+            }
+            return serializePlainObject(arg, registerFunction, options, seen);
+        }
+        finally {
+            seen.delete(arg);
         }
     }
-    return value;
+    return null;
 }
-function parseSerializedFunction(value, options) {
-    const persistentPrefix = 'persistent:';
-    if (value.startsWith(persistentPrefix)) {
-        return {
-            id: value.slice(persistentPrefix.length),
-            options: { ...options, persistent: true },
-        };
+function serializeError(err, owner, registerFunction, options, seen) {
+    const result = { [TYPE_KEY]: 'err', message: err.message };
+    if (err.name && err.name !== 'Error')
+        result.name = err.name;
+    if (err.stack !== undefined)
+        result.stack = err.stack;
+    const cause = err.cause;
+    if (cause !== undefined) {
+        result.cause = serialize0(cause, owner, registerFunction, options, seen);
     }
-    return { id: value, options };
+    const RESERVED_ERROR_KEYS = new Set(['message', 'name', 'stack', 'cause']);
+    const extras = [];
+    for (const k of Reflect.ownKeys(err)) {
+        if (typeof k === 'symbol')
+            continue;
+        if (RESERVED_ERROR_KEYS.has(k))
+            continue;
+        const value = err[k];
+        extras.push([k, serialize0(value, owner, registerFunction, options, seen)]);
+    }
+    if (extras.length > 0)
+        result.extras = extras;
+    return result;
 }
-function deserializeSymbol(value) {
-    if (value.startsWith('global:')) {
-        return Symbol.for(value.slice('global:'.length));
+function serializePlainObject(source, registerFunction, options, seen) {
+    const record = source;
+    const ownKeys = Reflect.ownKeys(source).filter((k) => isEnumerable(source, k));
+    const symbolKeys = [];
+    const stringKeys = [];
+    for (const k of ownKeys) {
+        if (typeof k === 'symbol') {
+            if (isSerializableSymbol(k))
+                symbolKeys.push(k);
+        }
+        else {
+            stringKeys.push(k);
+        }
     }
-    if (value.startsWith('wellKnown:')) {
-        const symbol = getWellKnownSymbol(value.slice('wellKnown:'.length));
-        if (symbol)
-            return symbol;
+    const hasReservedKey = Object.prototype.hasOwnProperty.call(record, TYPE_KEY);
+    if (symbolKeys.length > 0 || hasReservedKey) {
+        const entries = [];
+        for (const k of stringKeys) {
+            entries.push([k, serialize0(record[k], source, registerFunction, options, seen)]);
+        }
+        for (const k of symbolKeys) {
+            entries.push([
+                { [TYPE_KEY]: 'sym', v: serializeSymbol(k) },
+                serialize0(record[k], source, registerFunction, options, seen),
+            ]);
+        }
+        return { [TYPE_KEY]: 'obj', entries };
     }
-    throw new TypeError('Cannot deserialize symbol');
+    const result = {};
+    for (const k of stringKeys) {
+        setOwnProperty$1(result, k, serialize0(record[k], source, registerFunction, options, seen));
+    }
+    return result;
+}
+function isSerializableSymbol(value) {
+    if (Symbol.keyFor(value) !== undefined)
+        return true;
+    return getWellKnownSymbolName(value) !== undefined;
+}
+function isEnumerable(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    return descriptor ? descriptor.enumerable === true : false;
+}
+function serializeNumber(value) {
+    if (Number.isNaN(value))
+        return { [TYPE_KEY]: 'num', v: 'NaN' };
+    if (value === Infinity)
+        return { [TYPE_KEY]: 'num', v: 'Infinity' };
+    if (value === -Infinity)
+        return { [TYPE_KEY]: 'num', v: '-Infinity' };
+    if (Object.is(value, -0))
+        return { [TYPE_KEY]: 'num', v: '-0' };
+    return value;
 }
 function setOwnProperty$1(target, key, value) {
     Object.defineProperty(target, key, {
@@ -346,58 +442,245 @@ function setOwnProperty$1(target, key, value) {
         writable: true,
     });
 }
-
-function isListenerRegistrationPath(path) {
-    const last = path[path.length - 1];
-    return last === 'addListener' || last === 'removeListener' || last === 'hasListener';
-}
-function isLikelyListenerPath(path, value) {
-    if (typeof value === 'function')
-        return true;
-    const last = path[path.length - 1];
-    return typeof last === 'string' && /^on[A-Z]/.test(last);
+function serializeSymbol(value) {
+    const globalKey = Symbol.keyFor(value);
+    if (globalKey)
+        return `global:${globalKey}`;
+    const wellKnownName = getWellKnownSymbolName(value);
+    if (wellKnownName)
+        return `wellKnown:${wellKnownName}`;
+    throw new TypeError('Cannot serialize non-global symbol');
 }
 
-function serialize(arg, registerFunction, options = {}) {
-    return serialize0(arg, registerFunction, options, new WeakSet());
+const ERROR_CONSTRUCTORS = {
+    Error,
+    TypeError: TypeError,
+    RangeError: RangeError,
+    SyntaxError: SyntaxError,
+    ReferenceError: ReferenceError,
+    URIError: URIError,
+    EvalError: EvalError,
+};
+function deserialize(arg, generateCallback, getRemoteCallback) {
+    return deserialize0(arg, generateCallback, getRemoteCallback);
 }
-function serialize0(arg, registerFunction, options, seen) {
-    if (arg === undefined) {
-        return '$undefined$';
-    }
+function deserialize0(arg, generateCallback, getRemoteCallback) {
     if (arg === null)
-        return '$null$';
-    if (typeof arg === 'object') {
-        if (seen.has(arg)) {
-            throw new TypeError('Cannot serialize circular structure');
+        return null;
+    if (typeof arg !== 'object')
+        return arg;
+    if (Array.isArray(arg)) {
+        return arg.map((item) => deserialize0(item, generateCallback, getRemoteCallback));
+    }
+    const source = arg;
+    const tag = source[TYPE_KEY];
+    if (typeof tag === 'string') {
+        return deserializeTagged(tag, source, generateCallback, getRemoteCallback);
+    }
+    const result = {};
+    for (const key of Object.keys(source)) {
+        setOwnProperty(result, key, deserialize0(source[key], generateCallback, getRemoteCallback));
+    }
+    return result;
+}
+function deserializeTagged(tag, source, generateCallback, getRemoteCallback) {
+    switch (tag) {
+        case 'undef':
+            return undefined;
+        case 'big':
+            return deserializeBigInt(source.v);
+        case 'sym':
+            return deserializeSymbol(expectString(source.v, 'symbol'));
+        case 'num':
+            return deserializeNumber(expectString(source.v, 'number'));
+        case 'err':
+            return deserializeError(source, generateCallback, getRemoteCallback);
+        case 'date':
+            return deserializeDate(source.v);
+        case 're':
+            return deserializeRegExp(source.source, source.flags);
+        case 'map':
+            return deserializeMap(source.entries, generateCallback, getRemoteCallback);
+        case 'set':
+            return deserializeSet(source.values, generateCallback, getRemoteCallback);
+        case 'fn':
+            return deserializeFunction(source, generateCallback, getRemoteCallback);
+        case 'obj':
+            return deserializeWrappedObject(source.entries, generateCallback, getRemoteCallback);
+        default: {
+            const result = {};
+            for (const key of Object.keys(source)) {
+                setOwnProperty(result, key, deserialize0(source[key], generateCallback, getRemoteCallback));
+            }
+            return result;
         }
-        seen.add(arg);
+    }
+}
+function deserializeBigInt(raw) {
+    if (typeof raw !== 'string')
+        throw new TypeError('Invalid bigint payload');
+    try {
+        return BigInt(raw);
+    }
+    catch {
+        throw new TypeError(`Invalid bigint payload: ${raw}`);
+    }
+}
+function deserializeDate(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        throw new TypeError('Invalid date payload');
+    }
+    return new Date(raw);
+}
+function deserializeRegExp(rawSource, rawFlags) {
+    if (typeof rawSource !== 'string')
+        throw new TypeError('Invalid regexp source');
+    if (typeof rawFlags !== 'string')
+        throw new TypeError('Invalid regexp flags');
+    try {
+        return new RegExp(rawSource, rawFlags);
+    }
+    catch (err) {
+        throw new TypeError(`Invalid regexp payload: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function deserializeMap(entries, generateCallback, getRemoteCallback) {
+    const result = new Map();
+    if (!Array.isArray(entries))
+        return result;
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length !== 2)
+            continue;
+        const k = deserialize0(entry[0], generateCallback, getRemoteCallback);
+        const v = deserialize0(entry[1], generateCallback, getRemoteCallback);
+        result.set(k, v);
+    }
+    return result;
+}
+function deserializeSet(values, generateCallback, getRemoteCallback) {
+    const result = new Set();
+    if (!Array.isArray(values))
+        return result;
+    for (const v of values) {
+        result.add(deserialize0(v, generateCallback, getRemoteCallback));
+    }
+    return result;
+}
+function deserializeFunction(source, generateCallback, getRemoteCallback) {
+    const id = source.id;
+    if (typeof id !== 'string' || id.length === 0) {
+        throw new TypeError('Invalid function payload');
+    }
+    const persistent = source.persistent === true;
+    const fnOptions = { persistent };
+    const invoke = (args) => {
+        if (persistent)
+            return generateCallback(id, args, fnOptions);
+        return generateCallback(id, args);
+    };
+    return getRemoteCallback ? getRemoteCallback(id, invoke, fnOptions) : (...args) => invoke(args);
+}
+function deserializeError(source, generateCallback, getRemoteCallback) {
+    const message = typeof source.message === 'string' ? source.message : '';
+    const name = typeof source.name === 'string' ? source.name : 'Error';
+    const Ctor = ERROR_CONSTRUCTORS[name] ?? Error;
+    const error = new Ctor(message);
+    if (name && name !== Ctor.name) {
         try {
-            if (arg instanceof Error) {
-                return '$error$' + JSON.stringify({ message: arg.message, stack: arg.stack });
-            }
-            if (Array.isArray(arg)) {
-                return arg.map((item) => serialize0(item, registerFunction, options, seen));
+            error.name = name;
+        }
+        catch (err) {
+            warn('deserializeError', 'failed to set error.name', name, err);
+        }
+    }
+    if (typeof source.stack === 'string')
+        error.stack = source.stack;
+    if (source.cause !== undefined) {
+        error.cause = deserialize0(source.cause, generateCallback, getRemoteCallback);
+    }
+    if (Array.isArray(source.extras)) {
+        for (const entry of source.extras) {
+            if (!Array.isArray(entry) || entry.length !== 2)
+                continue;
+            const [rawKey, rawValue] = entry;
+            if (typeof rawKey !== 'string')
+                continue;
+            try {
+                setOwnProperty(error, rawKey, deserialize0(rawValue, generateCallback, getRemoteCallback));
             }
-            const result = {};
-            const source = arg;
-            for (const key of Object.keys(arg)) {
-                setOwnProperty(result, key, serialize0(source[key], registerFunction, options, seen));
+            catch (err) {
+                warn('deserializeError', 'failed to set error property', rawKey, err);
             }
-            return result;
         }
-        finally {
-            seen.delete(arg);
+    }
+    return error;
+}
+function deserializeWrappedObject(entries, generateCallback, getRemoteCallback) {
+    const result = {};
+    if (!Array.isArray(entries))
+        return result;
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length !== 2)
+            continue;
+        const rawKey = entry[0];
+        const value = deserialize0(entry[1], generateCallback, getRemoteCallback);
+        const key = resolveObjectKey(rawKey);
+        if (key === undefined) {
+            warn('deserializeWrappedObject', 'dropping wrapped-object entry with unresolvable key', rawKey);
+            continue;
         }
+        Object.defineProperty(result, key, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
     }
-    if (typeof arg === 'function') {
-        const id = registerFunction(arg, options);
-        return '$function$' + (options.persistent ? `persistent:${id}` : id);
+    return result;
+}
+function resolveObjectKey(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (raw !== null && typeof raw === 'object') {
+        const tagged = raw;
+        if (tagged[TYPE_KEY] === 'sym' && typeof tagged.v === 'string') {
+            try {
+                return deserializeSymbol(tagged.v);
+            }
+            catch (err) {
+                warn('resolveObjectKey', 'failed to deserialize symbol key', tagged.v, err);
+                return undefined;
+            }
+        }
+    }
+    return undefined;
+}
+function expectString(raw, label) {
+    if (typeof raw !== 'string')
+        throw new TypeError(`Invalid ${label} payload`);
+    return raw;
+}
+function deserializeNumber(raw) {
+    if (raw === 'NaN')
+        return NaN;
+    if (raw === 'Infinity')
+        return Infinity;
+    if (raw === '-Infinity')
+        return -Infinity;
+    if (raw === '-0')
+        return -0;
+    return Number(raw);
+}
+function deserializeSymbol(value) {
+    if (value.startsWith('global:')) {
+        return Symbol.for(value.slice('global:'.length));
     }
-    if (typeof arg === 'symbol') {
-        return '$symbol$' + serializeSymbol(arg);
+    if (value.startsWith('wellKnown:')) {
+        const symbol = getWellKnownSymbol(value.slice('wellKnown:'.length));
+        if (symbol)
+            return symbol;
     }
-    return `$${typeof arg}$${arg}`;
+    throw new TypeError('Cannot deserialize symbol');
 }
 function setOwnProperty(target, key, value) {
     Object.defineProperty(target, key, {
@@ -407,14 +690,18 @@ function setOwnProperty(target, key, value) {
         writable: true,
     });
 }
-function serializeSymbol(value) {
-    const globalKey = Symbol.keyFor(value);
-    if (globalKey)
-        return `global:${globalKey}`;
-    const wellKnownName = getWellKnownSymbolName(value);
-    if (wellKnownName)
-        return `wellKnown:${wellKnownName}`;
-    throw new TypeError('Cannot serialize non-global symbol');
+
+function isListenerRegistrationPath(path) {
+    const last = path[path.length - 1];
+    return last === 'addListener';
+}
+function isListenerRemovalPath(path) {
+    const last = path[path.length - 1];
+    return last === 'removeListener';
+}
+function isLikelyListenerPath(path) {
+    const last = path[path.length - 1];
+    return typeof last === 'string' && /^on[A-Z]/.test(last);
 }
 
 const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
@@ -427,70 +714,100 @@ function readProperty(target, key) {
     return target[key];
 }
 
-function handleAccessPropertyRequest(data, ctx) {
+function handleAccessPropertyRequest(data, ctx, meta) {
     const target = ctx.getDelegateTarget();
     const channel = ctx.getMessageChannel();
     if (data.path.length === 0) {
         channel.getSender().sendMessage('accessPropertyResponse', {
             id: data.id,
             error: { message: 'Property path must not be empty' },
-        });
+        }, meta.senderInstanceId);
         return;
     }
-    if (!target) {
+    if (target === undefined || target === null) {
         channel.getSender().sendMessage('accessPropertyResponse', {
             id: data.id,
             error: { message: 'No delegate target is configured' },
-        });
+        }, meta.senderInstanceId);
         return;
     }
     try {
         let current = target;
-        for (const key of data.path) {
+        let owner = target;
+        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' ? ctx.bindMethod(current, owner) : current;
         channel.getSender().sendMessage('accessPropertyResponse', {
             id: data.id,
-            data: serialize(current, ctx.registerFunction, { persistent: isLikelyListenerPath(data.path, current) }),
-        });
+            data: serialize(value, ctx.registerFunction, { persistent: isLikelyListenerPath(data.path) }),
+        }, meta.senderInstanceId);
     }
     catch (err) {
         channel.getSender().sendMessage('accessPropertyResponse', {
             id: data.id,
             error: serializeThrownError(err),
-        });
+        }, meta.senderInstanceId);
     }
 }
-function handleAccessPropertyResponse(data, ctx) {
+function handleAccessPropertyResponse(data, ctx, meta) {
     const pending = ctx.getAndRemovePendingPromise(data.id);
     if (!pending)
         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;
     }
-    pending.resolve(deserialize(data.data, (id, args, options) => {
-        return ctx.invokeFunctionById(id, args, options);
-    }, ctx.getRemoteCallback));
+    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)));
+    }
+}
+function createScopedRemoteCallback$2(ctx, remoteInstanceId) {
+    return (id, invoke, options) => ctx.getRemoteCallback(id, invoke, options, remoteInstanceId);
 }
 
-function handleInvokeRequest(data, ctx) {
+function handleInvokeRequest(data, ctx, meta) {
     const target = ctx.getDelegateTarget();
     const channel = ctx.getMessageChannel();
-    if (!target) {
+    const scopedRemoteCallback = createScopedRemoteCallback$1(ctx, meta.senderInstanceId);
+    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;
@@ -500,9 +817,12 @@ function handleInvokeRequest(data, ctx) {
             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;
         }
     }
@@ -512,12 +832,22 @@ function handleInvokeRequest(data, ctx) {
         channel.getSender().sendMessage('invokeResponse', {
             id: data.id,
             error: { message: `'${String(lastKey)}' is not a function` },
-        });
+        }, meta.senderInstanceId);
+        return;
+    }
+    let deserializedArgs;
+    try {
+        deserializedArgs = data.args.map((arg) => deserialize(arg, (id, args, options) => {
+            return ctx.invokeFunctionById(id, args, options);
+        }, scopedRemoteCallback));
+    }
+    catch (err) {
+        channel.getSender().sendMessage('invokeResponse', {
+            id: data.id,
+            error: serializeThrownError(err),
+        }, meta.senderInstanceId);
         return;
     }
-    const deserializedArgs = data.args.map((arg) => deserialize(arg, (id, args, options) => {
-        return ctx.invokeFunctionById(id, args, options);
-    }, ctx.getRemoteCallback, { persistent: isListenerRegistrationPath(data.path) }));
     let result;
     try {
         result = Reflect.apply(fn, current, deserializedArgs);
@@ -526,124 +856,174 @@ function handleInvokeRequest(data, ctx) {
         channel.getSender().sendMessage('invokeResponse', {
             id: data.id,
             error: serializeThrownError(err),
-        });
+        }, meta.senderInstanceId);
         return;
     }
-    if (result instanceof Promise) {
-        result
+    if (isPromiseLike(result)) {
+        Promise.resolve(result)
             .then((value) => {
-            sendInvokeSuccess(data.id, value, ctx);
+            sendInvokeSuccess(data.id, value, ctx, meta.senderInstanceId);
         })
             .catch((err) => {
             channel.getSender().sendMessage('invokeResponse', {
                 id: data.id,
                 error: serializeThrownError(err),
-            });
+            }, meta.senderInstanceId);
         });
+        return;
     }
-    else {
-        sendInvokeSuccess(data.id, result, ctx);
-    }
+    sendInvokeSuccess(data.id, result, ctx, meta.senderInstanceId);
 }
-function handleInvokeResponse(data, ctx) {
+function handleInvokeResponse(data, ctx, meta) {
     const pending = ctx.getAndRemovePendingPromise(data.id);
     if (!pending)
         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 {
-        pending.resolve(deserialize(data.data, (id, args, options) => {
-            return ctx.invokeFunctionById(id, args, options);
-        }, ctx.getRemoteCallback));
+        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)));
+        }
     }
 }
-function sendInvokeSuccess(id, value, ctx) {
+function sendInvokeSuccess(id, value, ctx, targetInstanceId) {
     const channel = ctx.getMessageChannel();
     try {
         channel.getSender().sendMessage('invokeResponse', {
             id,
             data: serialize(value, ctx.registerFunction),
-        });
+        }, targetInstanceId);
     }
     catch (err) {
         channel.getSender().sendMessage('invokeResponse', {
             id,
             error: serializeThrownError(err),
-        });
+        }, targetInstanceId);
     }
 }
+function createScopedRemoteCallback$1(ctx, remoteInstanceId) {
+    return (id, invoke, options) => ctx.getRemoteCallback(id, invoke, options, remoteInstanceId);
+}
 
-function handleCallbackInvoke(data, ctx) {
+function handleCallbackInvoke(data, ctx, meta) {
     const channel = ctx.getMessageChannel();
-    const isPersistentFunction = ctx.getPersistentFunctionCache().has(data.id);
-    const fn = ctx.getPersistentFunctionCache().get(data.id) ?? ctx.getFunctionCache().get(data.id);
-    if (!fn) {
+    const persistentEntry = ctx.getPersistentFunctionCache().get(data.id);
+    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,
-        });
+        }, meta.senderInstanceId);
         return;
     }
-    const deserializedArgs = data.args.map((arg) => deserialize(arg, (id, args, options) => {
-        return ctx.invokeFunctionById(id, args, options);
-    }, ctx.getRemoteCallback, { persistent: isPersistentFunction }));
+    const scopedRemoteCallback = createScopedRemoteCallback(ctx, meta.senderInstanceId);
+    let deserializedArgs;
     try {
-        const result = fn(...deserializedArgs);
-        if (result instanceof Promise) {
-            result
+        deserializedArgs = data.args.map((arg) => deserialize(arg, (id, args, options) => {
+            return ctx.invokeFunctionById(id, args, options);
+        }, scopedRemoteCallback));
+    }
+    catch (err) {
+        sendCallbackError(data.callId, err, ctx, meta.senderInstanceId);
+        return;
+    }
+    try {
+        const result = Reflect.apply(entry.fn, entry.thisArg, deserializedArgs);
+        if (isPromiseLike(result)) {
+            Promise.resolve(result)
                 .then((value) => {
-                sendCallbackSuccess(data.callId, value, ctx);
+                sendCallbackSuccess(data.callId, value, ctx, meta.senderInstanceId);
             })
                 .catch((err) => {
-                sendCallbackError(data.callId, err, ctx);
+                sendCallbackError(data.callId, err, ctx, meta.senderInstanceId);
             });
             return;
         }
-        sendCallbackSuccess(data.callId, result, ctx);
+        sendCallbackSuccess(data.callId, result, ctx, meta.senderInstanceId);
     }
     catch (err) {
-        sendCallbackError(data.callId, err, ctx);
+        sendCallbackError(data.callId, err, ctx, meta.senderInstanceId);
     }
 }
-function handleCallbackInvokeResponse(data, ctx) {
+function handleCallbackInvokeResponse(data, ctx, meta) {
     const pending = ctx.getAndRemovePendingPromise(data.id);
     if (!pending)
         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;
     }
-    pending.resolve(deserialize(data.data, (id, args, options) => {
-        return ctx.invokeFunctionById(id, args, options);
-    }, ctx.getRemoteCallback));
+    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)));
+    }
 }
-function sendCallbackSuccess(id, value, ctx) {
+function sendCallbackSuccess(id, value, ctx, targetInstanceId) {
     const channel = ctx.getMessageChannel();
     try {
         channel.getSender().sendMessage('invokeFunctionByIdResponse', {
             id,
             data: serialize(value, ctx.registerFunction),
-        });
+        }, targetInstanceId);
     }
     catch (err) {
-        sendCallbackError(id, err, ctx);
+        sendCallbackError(id, err, ctx, targetInstanceId);
     }
 }
-function sendCallbackError(id, err, ctx) {
+function sendCallbackError(id, err, ctx, targetInstanceId) {
     ctx
         .getMessageChannel()
         .getSender()
         .sendMessage('invokeFunctionByIdResponse', {
         id,
         error: serializeThrownError(err),
-    });
+    }, targetInstanceId);
+}
+function createScopedRemoteCallback(ctx, remoteInstanceId) {
+    return (id, invoke, options) => ctx.getRemoteCallback(id, invoke, options, remoteInstanceId);
+}
+
+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) {
+    ctx.handleRemoteDestroy(meta.senderInstanceId);
 }
 
 function createProcessorRegistry() {
@@ -659,56 +1039,165 @@ function createProcessorRegistry() {
 }
 
 const DEFAULT_TIMEOUT = 30000;
-const FUNCTION_CACHE_MAX = 100;
-const FUNCTION_CACHE_TTL = 5 * 60 * 1000;
-const REMOTE_CALLBACK_CACHE_MAX = 500;
-const REMOTE_CALLBACK_CACHE_TTL = 5 * 60 * 1000;
-function createClientContext(getMessageChannel, options = {}) {
+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 functionCache = new LRUCache({
-        max: FUNCTION_CACHE_MAX,
-        ttl: FUNCTION_CACHE_TTL,
-    });
+    const functionIds = new Map();
     const persistentFunctionCache = new Map();
-    const functionIds = new WeakMap();
-    const remoteCallbacks = new LRUCache({
-        max: REMOTE_CALLBACK_CACHE_MAX,
-        ttl: REMOTE_CALLBACK_CACHE_TTL,
+    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) => {
+            if (reason === 'set' || reason === 'delete')
+                return;
+            if (persistentFunctionCache.has(key))
+                return;
+            removeFunctionIdMapping(value.fn, value.thisArg);
+        },
     });
-    const persistentRemoteCallbacks = new Map();
+    const remoteCallbacksByOwner = new Map();
+    const persistentRemoteCallbacksByOwner = new Map();
+    const boundMethodCache = new WeakMap();
     let destroyed = false;
-    const registerFunction = (fn, callbackOptions = {}) => {
-        let id = functionIds.get(fn);
+    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) {
+            lru = new LRUCache({ max: remoteCacheMax, ttl: remoteCacheTtl });
+            remoteCallbacksByOwner.set(remoteId, lru);
+        }
+        return lru;
+    };
+    const getOrCreatePersistentRemoteMap = (remoteId) => {
+        let map = persistentRemoteCallbacksByOwner.get(remoteId);
+        if (!map) {
+            map = new Map();
+            persistentRemoteCallbacksByOwner.set(remoteId, map);
+        }
+        return map;
+    };
+    const registerFunction = (fn, thisArg, callbackOptions = {}) => {
+        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, fn);
+            persistentFunctionCache.set(id, entry);
             functionCache.delete(id);
+            persistentRefcount.set(id, (persistentRefcount.get(id) ?? 0) + 1);
         }
         else if (!persistentFunctionCache.has(id)) {
-            functionCache.set(id, fn);
+            functionCache.set(id, entry);
         }
         return id;
     };
-    const getRemoteCallback = (id, invoke, callbackOptions = {}) => {
-        let callback = persistentRemoteCallbacks.get(id) ?? remoteCallbacks.get(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);
+        const pmap = persistentRemoteCallbacksByOwner.get(remoteInstanceId);
+        let callback = pmap?.get(id) ?? lru?.get(id);
         if (!callback) {
             callback = (...args) => invoke(args);
-            if (callbackOptions.persistent) {
-                persistentRemoteCallbacks.set(id, callback);
+            if (opts.persistent) {
+                getOrCreatePersistentRemoteMap(remoteInstanceId).set(id, callback);
             }
             else {
-                remoteCallbacks.set(id, callback);
+                getOrCreateRemoteLru(remoteInstanceId).set(id, callback);
             }
         }
-        else if (callbackOptions.persistent) {
-            remoteCallbacks.delete(id);
-            persistentRemoteCallbacks.set(id, callback);
+        else if (opts.persistent && !pmap?.has(id)) {
+            lru?.delete(id);
+            getOrCreatePersistentRemoteMap(remoteInstanceId).set(id, callback);
         }
         return callback;
     };
+    const notifyReleaseCallbacks = (ids) => {
+        if (ids.length === 0)
+            return;
+        try {
+            getMessageChannel().getSender().sendMessage('releaseCallbacks', { ids });
+        }
+        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;
@@ -716,17 +1205,20 @@ function createClientContext(getMessageChannel, options = {}) {
         getMessageChannel() {
             return getMessageChannel();
         },
+        getInstanceId() {
+            return instanceId;
+        },
         getFunctionCache() {
             return functionCache;
         },
         getPersistentFunctionCache() {
             return persistentFunctionCache;
         },
-        registerFunction(fn, callbackOptions) {
-            return registerFunction(fn, callbackOptions);
+        registerFunction(fn, thisArg, callbackOptions) {
+            return registerFunction(fn, thisArg, callbackOptions);
         },
-        getRemoteCallback(id, invoke, callbackOptions) {
-            return getRemoteCallback(id, invoke, callbackOptions);
+        getRemoteCallback(id, invoke, callbackOptions, remoteInstanceId) {
+            return getRemoteCallback(id, invoke, callbackOptions, remoteInstanceId);
         },
         getAndRemovePendingPromise(id) {
             const callbacks = pending.get(id);
@@ -736,9 +1228,6 @@ function createClientContext(getMessageChannel, options = {}) {
             }
             return callbacks;
         },
-        registerPendingPromise(id, callbacks) {
-            pending.set(id, callbacks);
-        },
         invoke(path, args) {
             return new Promise((resolve, reject) => {
                 if (destroyed) {
@@ -746,20 +1235,63 @@ function createClientContext(getMessageChannel, 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 }));
-                channel.getSender().sendMessage('invokeRequest', {
-                    id,
-                    path,
-                    args: serializedArgs,
-                });
+                    if (isListenerRegistrationPath(path)) {
+                        const released = releaseRegisteredPersistents();
+                        if (released.length > 0)
+                            notifyReleaseCallbacks(released);
+                    }
+                    reject(err);
+                }
             });
         },
         accessProperty(path) {
@@ -769,16 +1301,21 @@ function createClientContext(getMessageChannel, 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 = {}) {
@@ -788,25 +1325,79 @@ function createClientContext(getMessageChannel, 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);
+                }
             });
         },
-        destroy() {
+        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 {
+                    const sender = getMessageChannel().getSender();
+                    if (heldRemoteIds.length > 0) {
+                        sender.sendMessage('releaseCallbacks', { ids: heldRemoteIds });
+                    }
+                    sender.sendMessage('destroyEndpoint', { instanceId });
+                }
+                catch (err) {
+                    if (!isExpectedDestroyNotifyError(err)) {
+                        warn('destroy', 'failed to notify remote of destroy', err);
+                    }
+                }
+            }
             for (const [id, callbacks] of pending) {
                 clearTimeout(callbacks.timer);
                 callbacks.reject(new Error(`Channel has been destroyed before call ${id} completed`));
@@ -814,15 +1405,57 @@ function createClientContext(getMessageChannel, options = {}) {
             pending.clear();
             functionCache.clear();
             persistentFunctionCache.clear();
-            remoteCallbacks.clear();
-            persistentRemoteCallbacks.clear();
+            persistentRefcount.clear();
+            functionIds.clear();
+            remoteCallbacksByOwner.clear();
+            persistentRemoteCallbacksByOwner.clear();
         },
     };
 }
 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([
+    'then',
+    'catch',
+    'finally',
+    'toJSON',
+    'toString',
+    'valueOf',
+    'nodeType',
+    'tagName',
+    'asymmetricMatch',
+    '$$typeof',
+    '@@__IMMUTABLE_ITERABLE__@@',
+    '@@__IMMUTABLE_RECORD__@@',
+    'length',
+    'name',
+    'prototype',
+    'arguments',
+    'caller',
+    'bind',
+    'call',
+    'apply',
+]);
+const INTERCEPTED_NONE_SYMBOLS = new Set([
+    Symbol.toStringTag,
+    Symbol.iterator,
+    Symbol.asyncIterator,
+    Symbol.isConcatSpreadable,
+]);
+const PROXY_DESCRIPTION = '[chrome-in-iframe proxy]';
+function toPrimitiveDescriptor() {
+    return (hint) => {
+        if (hint === 'number')
+            return NaN;
+        return PROXY_DESCRIPTION;
+    };
+}
 function resolvePath(node) {
     const path = [];
     let current = node;
@@ -834,11 +1467,14 @@ function resolvePath(node) {
 }
 function createClientProxy(invoke, accessProperty) {
     const normalizePropertyPath = (basePath, parts) => {
+        if (parts.length === 1 && typeof parts[0] === 'string') {
+            return [...basePath, ...parts[0].split('.').filter(Boolean)];
+        }
         const extraPath = parts.flatMap((part) => {
             if (Array.isArray(part))
                 return part.filter(isPathKey);
             if (typeof part === 'string')
-                return part.split('.').filter(Boolean);
+                return [part];
             if (typeof part === 'symbol')
                 return [part];
             return [];
@@ -848,19 +1484,27 @@ function createClientProxy(invoke, accessProperty) {
     function createHandler(node) {
         return {
             get(_target, prop) {
-                if (prop === 'then')
+                if (typeof prop === 'string') {
+                    if (INTERCEPTED_STRING_PROPS.has(prop))
+                        return undefined;
+                    if (prop === '$get') {
+                        return (...parts) => {
+                            if (!accessProperty) {
+                                return Promise.reject(new Error('Property access is not configured'));
+                            }
+                            const basePath = node ? resolvePath(node) : [];
+                            return accessProperty(normalizePropertyPath(basePath, parts));
+                        };
+                    }
+                }
+                else if (prop === Symbol.toPrimitive) {
+                    return toPrimitiveDescriptor();
+                }
+                else if (INTERCEPTED_NONE_SYMBOLS.has(prop)) {
                     return undefined;
-                if (prop === '$get') {
-                    return (...parts) => {
-                        if (!accessProperty) {
-                            return Promise.reject(new Error('Property access is not configured'));
-                        }
-                        const basePath = node ? resolvePath(node) : [];
-                        return accessProperty(normalizePropertyPath(basePath, parts));
-                    };
                 }
                 const childNode = node ? { parent: node, key: prop } : { key: prop };
-                return new Proxy(() => { }, createHandler(childNode));
+                return new Proxy(EMPTY_TARGET, createHandler(childNode));
             },
             apply(_target, _thisArg, argArray) {
                 const path = node ? resolvePath(node) : [];
@@ -868,7 +1512,7 @@ function createClientProxy(invoke, accessProperty) {
             },
         };
     }
-    return new Proxy(() => { }, createHandler());
+    return new Proxy(EMPTY_TARGET, createHandler());
 }
 function isPathKey(value) {
     return typeof value === 'string' || typeof value === 'symbol';
@@ -883,8 +1527,9 @@ function createEndpoint(options) {
         }
         return channelRef.current;
     };
-    const context = createClientContext(getChannel, options.contextOptions);
-    const channel = createMessageChannel(options.poster, options.key ?? 'default', context, processorRegistry);
+    const instanceId = `ep-${nanoid()}`;
+    const context = createClientContext(getChannel, instanceId, options.contextOptions);
+    const channel = createMessageChannel(options.poster, options.key ?? 'default', instanceId, context, processorRegistry);
     channelRef.current = channel;
     processorRegistry.register('invokeRequest', handleInvokeRequest);
     processorRegistry.register('invokeResponse', handleInvokeResponse);
@@ -892,27 +1537,36 @@ function createEndpoint(options) {
     processorRegistry.register('accessPropertyResponse', handleAccessPropertyResponse);
     processorRegistry.register('invokeFunctionByIdRequest', handleCallbackInvoke);
     processorRegistry.register('invokeFunctionByIdResponse', handleCallbackInvokeResponse);
+    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();
-            context.destroy();
         },
     };
 }
 
 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;
             if (!contentWindow) {
                 throw new Error('chrome-in-iframe: iframe contentWindow is not available');
             }
-            contentWindow.postMessage(message, options.targetOrigin ?? '*');
+            contentWindow.postMessage(message, resolveTargetOrigin());
         },
         getExpectedSource: () => options.iframe.contentWindow,
-        allowedOrigin: options.allowedOrigin,
+        allowedOrigin,
     });
     const endpoint = createEndpoint({
         poster,
@@ -920,6 +1574,10 @@ function setupInMainWindow(options) {
         contextOptions: {
             delegateTarget: options.delegateTarget,
             timeout: options.timeout,
+            functionCacheMax: options.functionCacheMax,
+            functionCacheTtl: options.functionCacheTtl,
+            remoteCallbackCacheMax: options.remoteCallbackCacheMax,
+            remoteCallbackCacheTtl: options.remoteCallbackCacheTtl,
         },
     });
     const proxy = endpoint.proxy;
@@ -930,18 +1588,24 @@ 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, options.targetOrigin ?? '*');
+            window.parent.postMessage(message, resolveTargetOrigin());
         },
         getExpectedSource: () => window.parent,
-        allowedOrigin: options.allowedOrigin,
+        allowedOrigin,
     });
     const endpoint = createEndpoint({
         poster,
         key: options.key,
         contextOptions: {
             timeout: options.timeout,
+            functionCacheMax: options.functionCacheMax,
+            functionCacheTtl: options.functionCacheTtl,
+            remoteCallbackCacheMax: options.remoteCallbackCacheMax,
+            remoteCallbackCacheTtl: options.remoteCallbackCacheTtl,
         },
     });
     const proxy = endpoint.proxy;
@@ -966,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())
@@ -979,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);
@@ -1000,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) {
@@ -1007,5 +1696,64 @@ function getGlobalChrome() {
     }
     return chromeApi;
 }
+function createTargetOriginResolver(getIframe, explicit) {
+    if (explicit)
+        return () => explicit;
+    return () => deriveOriginFromIframe(getIframe());
+}
+function createParentTargetOriginResolver(explicit) {
+    if (explicit)
+        return () => explicit;
+    return () => deriveParentOrigin();
+}
+function deriveOriginFromIframe(iframe) {
+    const src = iframe.src || iframe.getAttribute('src') || '';
+    const origin = parseOrigin(src);
+    if (origin)
+        return origin;
+    try {
+        if (iframe.contentWindow && iframe.contentWindow.location) {
+            const loc = iframe.contentWindow.location;
+            if (loc.origin && loc.origin !== 'null')
+                return loc.origin;
+        }
+    }
+    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() {
+    if (typeof document !== 'undefined') {
+        const referrer = document.referrer;
+        const origin = parseOrigin(referrer);
+        if (origin)
+            return origin;
+    }
+    if (typeof location !== 'undefined' && location.ancestorOrigins && location.ancestorOrigins.length > 0) {
+        const first = location.ancestorOrigins[0];
+        if (first && first !== 'null')
+            return first;
+    }
+    warn('deriveParentOrigin', "unable to derive parent origin automatically; falling back to '*'. " +
+        'Pass `targetOrigin` explicitly to lock the destination.');
+    return '*';
+}
+function parseOrigin(url) {
+    if (!url)
+        return null;
+    try {
+        const parsed = new URL(url, typeof location !== 'undefined' ? location.href : 'http://localhost');
+        if (parsed.origin && parsed.origin !== 'null')
+            return parsed.origin;
+    }
+    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 };