chrome-in-iframe 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { LRUCache } from 'lru-cache';
 import { nanoid } from 'nanoid';
+import { LRUCache } from 'lru-cache';
 
 const WELL_KNOWN_SYMBOLS = {
     asyncIterator: Symbol.asyncIterator,
@@ -82,10 +82,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,8 +115,8 @@ 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 listener = (event) => {
         let body;
         try {
@@ -122,11 +129,16 @@ function createMessageChannel(poster, key, context, processorRegistry) {
             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;
+        const meta = { senderInstanceId: body.senderInstanceId };
         try {
-            handler(deserializeMessageData(body), context);
+            handler(deserializeMessageData(body), context, meta);
         }
         catch (err) {
             sendProcessorError(body, sender, err);
@@ -146,6 +158,9 @@ function createMessageChannel(poster, key, context, processorRegistry) {
         getKey() {
             return key;
         },
+        getInstanceId() {
+            return instanceId;
+        },
         destroy() {
             poster.removeEventListener('message', listener);
         },
@@ -158,6 +173,10 @@ function isMessageBody(value) {
         return false;
     if (typeof value.key !== 'string')
         return false;
+    if (typeof value.senderInstanceId !== 'string')
+        return false;
+    if ('targetInstanceId' in value && typeof value.targetInstanceId !== 'string' && value.targetInstanceId !== undefined)
+        return false;
     switch (value.type) {
         case 'invokeRequest':
             return isInvokeRequest(value.data);
@@ -171,6 +190,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 +205,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 +213,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 +251,7 @@ function sendProcessorError(body, sender, err) {
         sender.sendMessage('invokeResponse', {
             id: data.id,
             error: serializeThrownError(err),
-        });
+        }, body.senderInstanceId);
         return;
     }
     if (body.type === 'accessPropertyRequest') {
@@ -230,7 +259,7 @@ function sendProcessorError(body, sender, err) {
         sender.sendMessage('accessPropertyResponse', {
             id: data.id,
             error: serializeThrownError(err),
-        });
+        }, body.senderInstanceId);
         return;
     }
     if (body.type === 'invokeFunctionByIdRequest') {
@@ -240,103 +269,151 @@ function sendProcessorError(body, sender, err) {
         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);
+    }
+    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)]);
     }
-    return { id: value, options };
+    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 +423,244 @@ 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 {
+            // ignore non-writable name
+        }
+    }
+    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 {
+                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 {
+                // ignore non-writable property
             }
-            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) {
+            console.warn('chrome-in-iframe: dropping wrapped-object entry with unresolvable key', rawKey);
+            continue;
+        }
+        Object.defineProperty(result, key, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    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 {
+                return undefined;
+            }
         }
     }
-    if (typeof arg === 'function') {
-        const id = registerFunction(arg, options);
-        return '$function$' + (options.persistent ? `persistent:${id}` : id);
+    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 +670,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' || last === 'hasListener';
+}
+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,48 +694,68 @@ function readProperty(target, key) {
     return target[key];
 }
 
-function handleAccessPropertyRequest(data, ctx) {
+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();
     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) {
         channel.getSender().sendMessage('accessPropertyResponse', {
             id: data.id,
             error: { message: 'No delegate target is configured' },
-        });
+        }, meta.senderInstanceId);
         return;
     }
     try {
         let current = target;
+        let owner = target;
         for (const key of data.path) {
             if (current === undefined || current === null) {
                 channel.getSender().sendMessage('accessPropertyResponse', {
                     id: data.id,
                     data: serialize(current, ctx.registerFunction),
-                });
+                }, meta.senderInstanceId);
                 return;
             }
+            owner = current;
             current = readProperty(current, key);
         }
+        const value = typeof current === 'function' ? 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;
@@ -478,19 +765,29 @@ function handleAccessPropertyResponse(data, ctx) {
         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.resolve(deserialize(data.data, (id, args, options) => {
+            return ctx.invokeFunctionById(id, args, options);
+        }, scopedRemoteCallback));
+    }
+    catch (err) {
+        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();
+    const scopedRemoteCallback = createScopedRemoteCallback$1(ctx, meta.senderInstanceId);
     if (!target) {
         channel.getSender().sendMessage('invokeResponse', {
             id: data.id,
             error: { message: 'No delegate target is configured' },
-        });
+        }, meta.senderInstanceId);
         return;
     }
     let current = target;
@@ -502,7 +799,7 @@ function handleInvokeRequest(data, ctx) {
                 error: {
                     message: `Cannot read property '${String(data.path[i + 1])}' of ${String(data.path[i])}`,
                 },
-            });
+            }, meta.senderInstanceId);
             return;
         }
     }
@@ -512,12 +809,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,26 +833,26 @@ function handleInvokeRequest(data, ctx) {
         channel.getSender().sendMessage('invokeResponse', {
             id: data.id,
             error: serializeThrownError(err),
-        });
+        }, meta.senderInstanceId);
         return;
     }
     if (result instanceof Promise) {
         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);
         });
     }
     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;
@@ -555,62 +862,79 @@ function handleInvokeResponse(data, ctx) {
         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.resolve(deserialize(data.data, (id, args, options) => {
+                return ctx.invokeFunctionById(id, args, options);
+            }, scopedRemoteCallback));
+        }
+        catch (err) {
+            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}`);
         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);
+        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 (result instanceof Promise) {
             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;
@@ -620,30 +944,52 @@ function handleCallbackInvokeResponse(data, ctx) {
         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.resolve(deserialize(data.data, (id, args, options) => {
+            return ctx.invokeFunctionById(id, args, options);
+        }, scopedRemoteCallback));
+    }
+    catch (err) {
+        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_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);
+    }
+}
+function handleDestroyEndpoint(_data, ctx, meta) {
+    ctx.handleRemoteDestroy(meta.senderInstanceId);
 }
 
 function createProcessorRegistry() {
@@ -659,56 +1005,90 @@ 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 createClientContext(getMessageChannel, instanceId, options = {}) {
+    const remoteCacheMax = options.remoteCallbackCacheMax ?? DEFAULT_REMOTE_CALLBACK_CACHE_MAX;
+    const remoteCacheTtl = options.remoteCallbackCacheTtl ?? DEFAULT_REMOTE_CALLBACK_CACHE_TTL;
     const pending = new Map();
+    const functionIds = new Map();
     const functionCache = new LRUCache({
-        max: FUNCTION_CACHE_MAX,
-        ttl: FUNCTION_CACHE_TTL,
+        max: options.functionCacheMax ?? DEFAULT_FUNCTION_CACHE_MAX,
+        ttl: options.functionCacheTtl ?? DEFAULT_FUNCTION_CACHE_TTL,
+        dispose: (value, _key, reason) => {
+            if (reason === 'set' || reason === 'delete')
+                return;
+            functionIds.delete(value.fn);
+        },
     });
     const persistentFunctionCache = new Map();
-    const functionIds = new WeakMap();
-    const remoteCallbacks = new LRUCache({
-        max: REMOTE_CALLBACK_CACHE_MAX,
-        ttl: REMOTE_CALLBACK_CACHE_TTL,
-    });
-    const persistentRemoteCallbacks = new Map();
+    const remoteCallbacksByOwner = new Map();
+    const persistentRemoteCallbacksByOwner = new Map();
     let destroyed = false;
-    const registerFunction = (fn, callbackOptions = {}) => {
+    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 id = functionIds.get(fn);
         if (!id) {
             id = createId('cb');
             functionIds.set(fn, id);
         }
+        const entry = { fn, thisArg };
         if (callbackOptions.persistent) {
-            persistentFunctionCache.set(id, fn);
+            persistentFunctionCache.set(id, entry);
             functionCache.delete(id);
         }
         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 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 {
+            // channel may not be available yet
+        }
+    };
     return {
         getDelegateTarget() {
             return options.delegateTarget;
@@ -716,17 +1096,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);
@@ -755,6 +1138,21 @@ function createClientContext(getMessageChannel, options = {}) {
                 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);
+                        }
+                    }
+                    notifyReleaseCallbacks(releasedIds);
+                }
                 channel.getSender().sendMessage('invokeRequest', {
                     id,
                     path,
@@ -803,10 +1201,22 @@ function createClientContext(getMessageChannel, options = {}) {
                 });
             });
         },
-        destroy() {
+        handleRemoteDestroy(remoteInstanceId) {
+            remoteCallbacksByOwner.delete(remoteInstanceId);
+            persistentRemoteCallbacksByOwner.delete(remoteInstanceId);
+        },
+        destroy(notifyRemote = true) {
             if (destroyed)
                 return;
             destroyed = true;
+            if (notifyRemote) {
+                try {
+                    getMessageChannel().getSender().sendMessage('destroyEndpoint', { instanceId });
+                }
+                catch {
+                    // channel may already be torn down
+                }
+            }
             for (const [id, callbacks] of pending) {
                 clearTimeout(callbacks.timer);
                 callbacks.reject(new Error(`Channel has been destroyed before call ${id} completed`));
@@ -814,8 +1224,9 @@ function createClientContext(getMessageChannel, options = {}) {
             pending.clear();
             functionCache.clear();
             persistentFunctionCache.clear();
-            remoteCallbacks.clear();
-            persistentRemoteCallbacks.clear();
+            functionIds.clear();
+            remoteCallbacksByOwner.clear();
+            persistentRemoteCallbacksByOwner.clear();
         },
     };
 }
@@ -823,6 +1234,43 @@ function createId(prefix) {
     return `${prefix}-${nanoid()}`;
 }
 
+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 +1282,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 +1299,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 +1327,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 +1342,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,24 +1352,28 @@ 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));
     return {
         proxy,
+        getContext: () => context,
         destroy() {
+            context.destroy(true);
             channel.destroy();
-            context.destroy();
         },
     };
 }
 
 function setupInMainWindow(options) {
+    const resolveTargetOrigin = createTargetOriginResolver(() => options.iframe, options.targetOrigin);
     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,
@@ -920,6 +1384,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,9 +1398,10 @@ function setupInMainWindow(options) {
     };
 }
 function setupInIframe(options = {}) {
+    const resolveTargetOrigin = createParentTargetOriginResolver(options.targetOrigin);
     const poster = createWindowPoster({
         postMessage: (message) => {
-            window.parent.postMessage(message, options.targetOrigin ?? '*');
+            window.parent.postMessage(message, resolveTargetOrigin());
         },
         getExpectedSource: () => window.parent,
         allowedOrigin: options.allowedOrigin,
@@ -942,6 +1411,10 @@ function setupInIframe(options = {}) {
         key: options.key,
         contextOptions: {
             timeout: options.timeout,
+            functionCacheMax: options.functionCacheMax,
+            functionCacheTtl: options.functionCacheTtl,
+            remoteCallbackCacheMax: options.remoteCallbackCacheMax,
+            remoteCallbackCacheTtl: options.remoteCallbackCacheTtl,
         },
     });
     const proxy = endpoint.proxy;
@@ -1007,5 +1480,67 @@ 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 {
+        // 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.');
+    }
+    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;
+    }
+    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.');
+    }
+    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 {
+        return null;
+    }
+    return null;
+}
 
 export { connectChromeInIframe, exposeChromeInIframe, setupInIframe, setupInMainWindow };