jseption 0.0.3 → 0.0.5

package/dist/membrane.js

@@ -0,0 +1,576 @@
+/* The membrane: live host objects for the guest.
+ *
+ * `toGuest`/`expose` (src/embed.ts) copy plain data and wrap functions; a
+ * host class instance is refused. The membrane instead hands the guest a
+ * live view of a host object graph: every host object or function the guest
+ * reaches from a root crosses as a host `Proxy` whose handler lives here.
+ * Each trap forwards the operation to the host object and converts what
+ * comes back the same way, so nested objects, method results and
+ * constructed instances are proxied lazily.
+ *
+ * A membrane proxy is not a guest Proxy (src/builtins/proxy.ts): the guest
+ * Proxy calls guest handler code, while this handler is host code that must
+ * never return a host value. The proxy's target is a private dummy (an empty
+ * null-prototype object, or an empty function for callables) so the host
+ * Proxy invariants never force a host value out, and the proxy has no engine
+ * metadata, so the engine treats it as an ordinary object or host function
+ * (`Reflect.get`, `Reflect.apply`, ... on it run the traps).
+ *
+ * The sandbox rules (always on; a policy can only narrow them):
+ *  1. host intrinsics (Function and its async/generator variants, eval,
+ *     globalThis, Reflect, Proxy, Object, the Error constructors, the
+ *     intrinsic prototypes, the methods of Object, Reflect, Object.prototype
+ *     and Function.prototype) are never wrapped: they read as undefined, or
+ *     raise a guest TypeError where a value is required;
+ *  2. constructor, prototype, __proto__, caller, callee, arguments and the
+ *     legacy __define/lookup{G,S}etter__ read as undefined; the prototype of
+ *     a proxy is the guest Object.prototype (Function.prototype for
+ *     callables); writes are refused unless the policy is writable, and
+ *     setPrototypeOf / preventExtensions are always refused;
+ *  3. lookups stop at the host Object.prototype / Function.prototype and
+ *     continue on the guest's own, so call/apply/bind/toString/hasOwnProperty
+ *     are the guest intrinsics operating on the proxy, never host methods;
+ *  4. getters run on the host, their results are converted like any value;
+ *  5. only the well-known symbols iterator, asyncIterator, toStringTag and
+ *     toPrimitive (and hasInstance, answered by the membrane) are forwarded;
+ *     host symbols are neither listed nor returned;
+ *  6. `policy.allow(target, key)` filters every key-based operation.
+ *
+ * See docs/MEMBRANE.md. */
+import { JS_IsException, JS_GetException, JS_NewCFunction, JS_Call, JS_Throw, JS_NewArrayFrom, JS_NewErrorNative, JS_SetPropertyStr, JS_GetClassID, js_meta, } from "./quickjs.js";
+import { toGuest, drainJobs, guestErrorToHost, hostPromiseWith, guestPromiseToHostWith, fromGuestWith, FROM_GUEST_DEFAULT, } from "./embed.js";
+import { JS_NewDate } from "./builtins/date.js";
+/* ------------------------------------------------------------------ */
+/* host intrinsics, collected once at module load                       */
+const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+const GeneratorFunction = Object.getPrototypeOf(function* () { }).constructor;
+const AsyncGeneratorFunction = Object.getPrototypeOf(async function* () { }).constructor;
+/* never wrapped, never returned to the guest */
+const FORBIDDEN = new Set();
+/* the host prototype walk stops here and continues on the guest prototype */
+const WALK_STOP = new Set([Object.prototype, Function.prototype, globalThis]);
+function forbid(v) {
+    if ((typeof v === 'object' && v !== null) || typeof v === 'function')
+        FORBIDDEN.add(v);
+}
+/* the functions stored on an object (values and accessors) */
+function forbidMembers(o) {
+    for (const k of Reflect.ownKeys(o)) {
+        const d = Reflect.getOwnPropertyDescriptor(o, k);
+        if (!d)
+            continue;
+        if (typeof d.value === 'function')
+            forbid(d.value);
+        forbid(d.get);
+        forbid(d.set);
+    }
+}
+(function collectIntrinsics() {
+    const g = globalThis;
+    for (const v of [Function, AsyncFunction, GeneratorFunction, AsyncGeneratorFunction, eval, globalThis, Reflect, Proxy, Object])
+        forbid(v);
+    /* the host error constructors expose stack-trace hooks (captureStackTrace,
+       prepareStackTrace) that can hand out host frames */
+    for (const name of ['Error', 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError',
+        'AggregateError', 'SuppressedError'])
+        forbid(g[name]);
+    /* the prototype of every standard constructor */
+    const ctors = ['Object', 'Function', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt', 'Error', 'EvalError',
+        'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError', 'AggregateError', 'SuppressedError', 'Date',
+        'RegExp', 'Map', 'Set', 'WeakMap', 'WeakSet', 'WeakRef', 'FinalizationRegistry', 'Promise', 'ArrayBuffer',
+        'SharedArrayBuffer', 'DataView', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array',
+        'Int32Array', 'Uint32Array', 'Float16Array', 'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array',
+        'Iterator', 'AsyncIterator', 'DisposableStack', 'AsyncDisposableStack'];
+    for (const name of ctors) {
+        const c = g[name];
+        if (typeof c === 'function')
+            forbid(c.prototype);
+    }
+    const TypedArray = Object.getPrototypeOf(Int8Array);
+    forbid(TypedArray);
+    forbid(TypedArray.prototype);
+    for (const F of [AsyncFunction, GeneratorFunction, AsyncGeneratorFunction]) {
+        forbid(F.prototype); /* %AsyncFunction.prototype%, %GeneratorFunction.prototype%, ... */
+        forbid(F.prototype.prototype); /* %GeneratorPrototype%, %AsyncGeneratorPrototype% */
+    }
+    const arrayIter = Object.getPrototypeOf([][Symbol.iterator]());
+    forbid(arrayIter);
+    forbid(Object.getPrototypeOf(arrayIter)); /* %IteratorPrototype% */
+    forbid(Object.getPrototypeOf(Object.getPrototypeOf((async function* () { })()))); /* %AsyncGeneratorPrototype% */
+    forbid(Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf((async function* () { })())))); /* %AsyncIteratorPrototype% */
+    forbid(Object.getPrototypeOf(new Map().entries()));
+    forbid(Object.getPrototypeOf(new Set().values()));
+    forbid(Object.getPrototypeOf(''[Symbol.iterator]()));
+    forbid(Object.getPrototypeOf(/a/[Symbol.matchAll]('a')));
+    /* %ThrowTypeError% and the methods that reach code, prototypes or properties
+       of arbitrary objects */
+    forbid(Reflect.getOwnPropertyDescriptor(Function.prototype, 'caller')?.get);
+    for (const o of [Object, Reflect, Proxy, Object.prototype, Function.prototype])
+        forbidMembers(o);
+})();
+const BLOCKED_KEYS = new Set([
+    'constructor', 'prototype', '__proto__', 'caller', 'callee', 'arguments',
+    '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__',
+]);
+const WELL_KNOWN_SYMBOLS = new Set(Reflect.ownKeys(Symbol).map(k => Symbol[k])
+    .filter((v) => typeof v === 'symbol'));
+/* the well-known symbols forwarded as keys */
+const FORWARDED_SYMBOLS = new Set([Symbol.iterator, Symbol.asyncIterator, Symbol.toStringTag, Symbol.toPrimitive]);
+const ERROR_KINDS = [
+    [TypeError, 4 /* JSErrorEnum.TYPE_ERROR */], [RangeError, 1 /* JSErrorEnum.RANGE_ERROR */], [SyntaxError, 3 /* JSErrorEnum.SYNTAX_ERROR */],
+    [ReferenceError, 2 /* JSErrorEnum.REFERENCE_ERROR */], [URIError, 5 /* JSErrorEnum.URI_ERROR */], [EvalError, 0 /* JSErrorEnum.EVAL_ERROR */],
+];
+const STANDARD_ERROR_NAMES = new Set(['Error', 'TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'URIError', 'EvalError']);
+function isHostConstructor(f) {
+    try {
+        Reflect.construct(String, [], f);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isObjectLike(v) {
+    return (typeof v === 'object' && v !== null) || typeof v === 'function';
+}
+/* ------------------------------------------------------------------ */
+/* registries shared by every membrane                                  */
+/* membrane proxy -> the host object it stands for */
+const proxyHost = new WeakMap();
+/* host callable made for a guest function -> that guest function */
+const callableGuest = new WeakMap();
+/* host Error thrown to host code for a guest exception -> the guest exception */
+const thrownGuest = new WeakMap();
+/* one membrane per context and policy */
+const membranes = new WeakMap();
+/* membrane traps running now, per runtime. Compiled guest code pushes no interpreter frame, so
+   when it calls into host code through a proxy, `rt.current_stack_frame` is null although guest
+   code is on the stack; this count is what tells a guest callback the host calls back that it is
+   not the outermost call */
+const trapDepth = new WeakMap();
+function membraneFor(ctx, policy) {
+    let e = membranes.get(ctx);
+    if (!e) {
+        e = { byPolicy: new WeakMap() };
+        membranes.set(ctx, e);
+    }
+    if (policy === undefined)
+        return (e.plain ??= new Membrane(ctx, {}));
+    let m = e.byPolicy.get(policy);
+    if (!m) {
+        m = new Membrane(ctx, policy);
+        e.byPolicy.set(policy, m);
+    }
+    return m;
+}
+/* ------------------------------------------------------------------ */
+class Membrane {
+    ctx;
+    proxies = new WeakMap(); /* host object -> proxy */
+    callables = new WeakMap(); /* guest function -> host callable */
+    hasInstanceFns = new WeakMap();
+    guestSymbols = new WeakSet(); /* symbols the guest handed to the host */
+    writable;
+    allowFn;
+    constructor(ctx, policy) {
+        this.ctx = ctx;
+        this.writable = policy.writable === true;
+        this.allowFn = typeof policy.allow === 'function' ? policy.allow.bind(policy) : undefined;
+    }
+    /* ---------------- host -> guest ---------------- */
+    toGuest(v, seen) {
+        switch (typeof v) {
+            case 'undefined':
+            case 'boolean':
+            case 'number':
+            case 'string':
+            case 'bigint':
+                return v;
+            case 'symbol':
+                return this.symbolCrosses(v) ? v : undefined;
+        }
+        if (v === null)
+            return null;
+        const o = v;
+        if (FORBIDDEN.has(o))
+            return undefined;
+        const p = proxyHost.get(o);
+        if (p !== undefined)
+            return p.membrane.ctx === this.ctx ? o : this.toGuest(p.host, seen);
+        if (typeof o === 'function') {
+            const g = callableGuest.get(o);
+            if (g !== undefined)
+                return g;
+        }
+        if (this.isGuestOwned(o))
+            return o;
+        if (o instanceof Promise) {
+            return hostPromiseWith(this.ctx, o, r => this.toGuest(r), e => this.thrownToGuest(e));
+        }
+        if (Array.isArray(o)) {
+            /* arrays are snapshots: a fresh guest array whose elements are converted */
+            seen ??= new Map();
+            const cached = seen.get(o);
+            if (cached !== undefined)
+                return cached;
+            const arr = JS_NewArrayFrom(this.ctx, []);
+            seen.set(o, arr);
+            const len = o.length;
+            for (let i = 0; i < len; i++)
+                arr[i] = this.toGuest(o[i], seen);
+            return arr;
+        }
+        if (o instanceof Date)
+            return JS_NewDate(this.ctx, Date.prototype.getTime.call(o));
+        if (o instanceof Error)
+            return this.errorToGuest(o);
+        if (o instanceof RegExp || o instanceof ArrayBuffer || ArrayBuffer.isView(o))
+            return toGuest(this.ctx, o);
+        return this.wrap(o);
+    }
+    /* a well-known or registered symbol, or one the guest gave to the host */
+    symbolCrosses(s) {
+        return WELL_KNOWN_SYMBOLS.has(s) || Symbol.keyFor(s) !== undefined || this.guestSymbols.has(s);
+    }
+    /* an engine object, or an object whose prototype chain reaches this
+       context's guest Object.prototype / Function.prototype */
+    isGuestOwned(o) {
+        if (js_meta.has(o))
+            return true;
+        try {
+            return this.chainReachesGuest(o);
+        }
+        catch {
+            return false; /* a host proxy whose getPrototypeOf throws */
+        }
+    }
+    chainReachesGuest(o) {
+        const ctx = this.ctx;
+        const op = ctx.class_proto[1 /* JSClassID.OBJECT */], fp = ctx.function_proto;
+        let p = Reflect.getPrototypeOf(o);
+        for (let i = 0; i < 64 && p !== null; i++) {
+            if (p === op || p === fp)
+                return true;
+            if (WALK_STOP.has(p) || FORBIDDEN.has(p) || proxyHost.has(p))
+                return false;
+            p = Reflect.getPrototypeOf(p);
+        }
+        return false;
+    }
+    errorToGuest(e) {
+        let kind = 8 /* JSErrorEnum.PLAIN_ERROR */;
+        for (const [C, k] of ERROR_KINDS)
+            if (e instanceof C) {
+                kind = k;
+                break;
+            }
+        let message = '', name;
+        try {
+            const m = e.message;
+            message = typeof m === 'string' ? m : '';
+            name = e.name;
+        }
+        catch { /* hostile getter */ }
+        const g = JS_NewErrorNative(this.ctx, kind, message);
+        if (kind === 8 /* JSErrorEnum.PLAIN_ERROR */ && typeof name === 'string' && !STANDARD_ERROR_NAMES.has(name)) {
+            Reflect.defineProperty(g, 'name', { value: name, writable: true, enumerable: false, configurable: true });
+        }
+        return g;
+    }
+    /* convert anything the host threw into a value to throw in the guest; the
+       host exception object itself never crosses */
+    thrownToGuest(e) {
+        if (isObjectLike(e)) {
+            const g = thrownGuest.get(e);
+            if (g !== undefined)
+                return g; /* a guest exception that passed through host code */
+            if (proxyHost.has(e) || this.isGuestOwned(e))
+                return e; /* thrown by guest code */
+            if (e instanceof Error)
+                return this.errorToGuest(e);
+            let message = 'host exception';
+            try {
+                const m = e.message;
+                if (typeof m === 'string')
+                    message = m;
+            }
+            catch { /* hostile getter */ }
+            return JS_NewErrorNative(this.ctx, 8 /* JSErrorEnum.PLAIN_ERROR */, message);
+        }
+        if (typeof e === 'symbol')
+            return this.symbolCrosses(e) ? e : undefined;
+        return e;
+    }
+    guestTypeError(message) {
+        return JS_NewErrorNative(this.ctx, 4 /* JSErrorEnum.TYPE_ERROR */, message);
+    }
+    /* the proxy for a host object (one per host object) */
+    wrap(host) {
+        const cached = this.proxies.get(host);
+        if (cached !== undefined)
+            return cached;
+        let target;
+        const callable = typeof host === 'function';
+        if (callable) {
+            /* constructible or not like the host function; no own properties, so
+               no target invariant constrains the traps */
+            const f = isHostConstructor(host) ? Function.prototype.bind.call(function () { }, null) : () => { };
+            Reflect.deleteProperty(f, 'name');
+            Reflect.deleteProperty(f, 'length');
+            Reflect.setPrototypeOf(f, null);
+            target = f;
+        }
+        else {
+            target = Object.create(null);
+        }
+        const proxy = new Proxy(target, this.handler(host, callable));
+        this.proxies.set(host, proxy);
+        proxyHost.set(proxy, { host, membrane: this });
+        return proxy;
+    }
+    keyAllowed(host, key) {
+        if (typeof key === 'symbol') {
+            if (WELL_KNOWN_SYMBOLS.has(key) && !FORWARDED_SYMBOLS.has(key))
+                return false;
+        }
+        else if (BLOCKED_KEYS.has(key)) {
+            return false;
+        }
+        return this.allowFn === undefined || this.allowFn(host, key) === true;
+    }
+    /* listed by ownKeys: host symbols other than the forwarded well-known ones stay hidden */
+    keyListed(host, key) {
+        if (typeof key === 'symbol' && !FORWARDED_SYMBOLS.has(key) && !this.guestSymbols.has(key))
+            return false;
+        return this.keyAllowed(host, key);
+    }
+    /* walk the host prototype chain up to (not including) the host
+       Object.prototype / Function.prototype */
+    lookup(host, key) {
+        let o = host;
+        for (let depth = 0; o !== null && depth < 10000; depth++) {
+            if (WALK_STOP.has(o))
+                return undefined;
+            const d = Reflect.getOwnPropertyDescriptor(o, key);
+            if (d !== undefined)
+                return d;
+            o = Reflect.getPrototypeOf(o);
+        }
+        return undefined;
+    }
+    hostOf(v, fallback) {
+        return isObjectLike(v) ? proxyHost.get(v)?.host ?? fallback : fallback;
+    }
+    hasInstance(host) {
+        let f = this.hasInstanceFns.get(host);
+        if (f === undefined) {
+            f = JS_NewCFunction(this.ctx, (ctx, _this, argv) => {
+                const v = argv[0];
+                const h = isObjectLike(v) ? proxyHost.get(v)?.host : undefined;
+                if (h === undefined)
+                    return false;
+                try {
+                    return h instanceof host;
+                }
+                catch (e) {
+                    return JS_Throw(ctx, this.thrownToGuest(e));
+                }
+            }, '[Symbol.hasInstance]', 1);
+            this.hasInstanceFns.set(host, f);
+        }
+        return f;
+    }
+    handler(host, callable) {
+        const m = this;
+        const ctx = this.ctx;
+        const guestProto = () => (callable ? ctx.function_proto : ctx.class_proto[1 /* JSClassID.OBJECT */]);
+        /* every trap converts what the host throws, and counts as guest code on the stack while it
+           runs host code */
+        const rt = ctx.rt;
+        const guard = (fn) => (...args) => {
+            trapDepth.set(rt, (trapDepth.get(rt) ?? 0) + 1);
+            try {
+                return fn(...args);
+            }
+            catch (e) {
+                throw m.thrownToGuest(e);
+            }
+            finally {
+                trapDepth.set(rt, trapDepth.get(rt) - 1);
+            }
+        };
+        const refuse = (what, key) => {
+            const k = key === undefined ? '' : ` '${typeof key === 'symbol' ? key.description ?? 'symbol' : key}'`;
+            throw m.guestTypeError(`cannot ${what}${k}: host object is read-only`);
+        };
+        const proxyOf = () => m.proxies.get(host);
+        return {
+            get: guard((_t, key, receiver) => {
+                if (callable && key === Symbol.hasInstance)
+                    return m.hasInstance(host);
+                if (!m.keyAllowed(host, key))
+                    return undefined;
+                const d = m.lookup(host, key);
+                if (d === undefined)
+                    return Reflect.get(guestProto(), key, receiver);
+                if ('value' in d)
+                    return m.toGuest(d.value);
+                if (d.get === undefined)
+                    return undefined;
+                return m.toGuest(Reflect.apply(d.get, m.hostOf(receiver, host), []));
+            }),
+            has: guard((_t, key) => {
+                if (callable && key === Symbol.hasInstance)
+                    return true;
+                if (!m.keyAllowed(host, key))
+                    return false;
+                if (m.lookup(host, key) !== undefined)
+                    return true;
+                return Reflect.has(guestProto(), key);
+            }),
+            ownKeys: guard((_t) => Reflect.ownKeys(host).filter(k => m.keyListed(host, k))),
+            getOwnPropertyDescriptor: guard((_t, key) => {
+                if (!m.keyAllowed(host, key))
+                    return undefined;
+                const d = Reflect.getOwnPropertyDescriptor(host, key);
+                if (d === undefined)
+                    return undefined;
+                if ('value' in d) {
+                    return { value: m.toGuest(d.value), writable: m.writable && d.writable === true, enumerable: d.enumerable === true, configurable: true };
+                }
+                return {
+                    get: d.get === undefined ? undefined : m.toGuest(d.get),
+                    set: d.set === undefined || !m.writable ? undefined : m.toGuest(d.set),
+                    enumerable: d.enumerable === true, configurable: true,
+                };
+            }),
+            set: guard((_t, key, value, receiver) => {
+                if (receiver !== proxyOf() && !(isObjectLike(receiver) && proxyHost.has(receiver))) {
+                    /* a guest object inheriting from the proxy: the property lands on it */
+                    return Reflect.defineProperty(receiver, key, { value, writable: true, enumerable: true, configurable: true });
+                }
+                if (!m.writable || !m.keyAllowed(host, key))
+                    refuse('assign to property', key);
+                return Reflect.set(host, key, m.fromGuest(value), m.hostOf(receiver, host));
+            }),
+            defineProperty: guard((_t, key, desc) => {
+                if (!m.writable || !m.keyAllowed(host, key))
+                    refuse('define property', key);
+                if (desc.configurable === false)
+                    throw m.guestTypeError('cannot define a non-configurable property on a host object');
+                const hd = {};
+                if ('value' in desc)
+                    hd.value = m.fromGuest(desc.value);
+                if ('get' in desc)
+                    hd.get = m.fromGuest(desc.get);
+                if ('set' in desc)
+                    hd.set = m.fromGuest(desc.set);
+                if ('writable' in desc)
+                    hd.writable = desc.writable;
+                if ('enumerable' in desc)
+                    hd.enumerable = desc.enumerable;
+                hd.configurable = true;
+                return Reflect.defineProperty(host, key, hd);
+            }),
+            deleteProperty: guard((_t, key) => {
+                if (!m.writable || !m.keyAllowed(host, key))
+                    refuse('delete property', key);
+                return Reflect.deleteProperty(host, key);
+            }),
+            getPrototypeOf: () => guestProto(),
+            setPrototypeOf: () => false,
+            isExtensible: () => true,
+            preventExtensions: () => false,
+            apply: guard((_t, thisArg, args) => {
+                const hostThis = thisArg === ctx.global_obj ? undefined : m.fromGuest(thisArg);
+                const hostArgs = args.map(a => m.fromGuest(a));
+                return m.toGuest(Reflect.apply(host, hostThis, hostArgs));
+            }),
+            construct: guard((_t, args, newTarget) => {
+                if (newTarget !== proxyOf())
+                    throw m.guestTypeError('host constructors cannot be subclassed from the guest');
+                const r = m.toGuest(Reflect.construct(host, args.map(a => m.fromGuest(a))));
+                if (!isObjectLike(r))
+                    throw m.guestTypeError('host constructor returned a value that cannot cross the membrane');
+                return r;
+            }),
+        };
+    }
+    /* ---------------- guest -> host ---------------- */
+    fromGuest(v) {
+        return fromGuestWith(this.ctx, v, x => this.fromGuestHook(x));
+    }
+    fromGuestHook(v) {
+        if (typeof v === 'symbol') {
+            if (!WELL_KNOWN_SYMBOLS.has(v) && Symbol.keyFor(v) === undefined)
+                this.guestSymbols.add(v);
+            return v;
+        }
+        if (!isObjectLike(v))
+            return FROM_GUEST_DEFAULT;
+        const p = proxyHost.get(v);
+        if (p !== undefined)
+            return p.host;
+        if (typeof v === 'function')
+            return this.callable(v);
+        if (JS_GetClassID(v) === 45 /* JSClassID.PROMISE */) {
+            return guestPromiseToHostWith(this.ctx, v, x => this.fromGuest(x), e => (JS_GetClassID(e) === 3 /* JSClassID.ERROR */ ? guestErrorToHost(this.ctx, e) : this.fromGuest(e)));
+        }
+        return FROM_GUEST_DEFAULT;
+    }
+    /* a host function that runs the guest function (one per guest function) */
+    callable(fn) {
+        const cached = this.callables.get(fn);
+        if (cached !== undefined)
+            return cached;
+        const m = this;
+        const ctx = this.ctx;
+        const c = {
+            guestCallback(...args) {
+                /* outermost: no guest code below this call, neither an interpreter frame nor a membrane
+                   trap (the way compiled guest code reaches host code) */
+                const outermost = ctx.rt.current_stack_frame === null && (trapDepth.get(ctx.rt) ?? 0) === 0;
+                try {
+                    const r = JS_Call(ctx, fn, m.toGuest(this), args.map(a => m.toGuest(a)));
+                    if (JS_IsException(r)) {
+                        const exc = JS_GetException(ctx);
+                        const he = guestErrorToHost(ctx, exc);
+                        thrownGuest.set(he, exc);
+                        throw he;
+                    }
+                    return m.fromGuest(r);
+                }
+                finally {
+                    /* called from host code outside any guest call (an event, a timer, a
+                       promise reaction): run the guest jobs the callback queued */
+                    if (outermost)
+                        drainJobs(ctx);
+                }
+            },
+        }.guestCallback;
+        this.callables.set(fn, c);
+        callableGuest.set(c, fn);
+        return c;
+    }
+}
+/* ------------------------------------------------------------------ */
+/* public API                                                           */
+/** the guest view of a host value: primitives as is, host objects and
+ *  functions as live membrane proxies (see docs/MEMBRANE.md) */
+export function toGuestLive(ctx, value, policy) {
+    if (FORBIDDEN.has(value))
+        throw new TypeError('toGuestLive: refusing to hand a host intrinsic to the guest');
+    return membraneFor(ctx, policy).toGuest(value);
+}
+/** define the global `name` in the guest as a live view of `root` */
+export function exposeLive(ctx, name, root, policy) {
+    const g = toGuestLive(ctx, root, policy);
+    if (JS_SetPropertyStr(ctx, ctx.global_obj, name, g) < 0) {
+        throw guestErrorToHost(ctx, JS_GetException(ctx));
+    }
+}
+/** true if `value` is a membrane proxy */
+export function isLiveProxy(value) {
+    return isObjectLike(value) && proxyHost.has(value);
+}
+//# sourceMappingURL=membrane.js.map