@n8n/expression-runtime 0.28.1 → 0.29.1

package/dist/cjs/bridge/quickjs-bridge.js

@@ -0,0 +1,1243 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJsBridge = void 0;
+const promises_1 = require("node:fs/promises");
+const path = __importStar(require("node:path"));
+const types_1 = require("../types");
+const bridge_messages_1 = require("./bridge-messages");
+let _quickjs = null;
+async function getQuickJSModule() {
+    if (!_quickjs) {
+        _quickjs = await import('quickjs-emscripten');
+    }
+    return _quickjs;
+}
+const BUNDLE_RELATIVE_PATH = path.join('dist', 'bundle', 'runtime.iife.js');
+// Captured at module load so values rendered into generated code stay stable
+// even if the global is later replaced.
+const safeStringify = JSON.stringify;
+// ============================================================================
+// Sentinel helpers
+//
+// QuickJS's vm.dump() loses Date / NaN / Map / Set / Error type identity
+// (Date → ISO string, NaN → null, Map/Set/Error → empty plain object). Inside
+// the QuickJS context we wrap those values as sentinel objects
+// ({ __isDate: true, __isoString: ... } etc.) before they cross the boundary,
+// then unwrap them on the host side. The isolated-vm bridge does NOT need this
+// — structured clone preserves type identity natively.
+// ============================================================================
+function isDateSentinel(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__isDate === true &&
+        typeof value.__isoString === 'string');
+}
+function isNaNSentinel(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__isNaN === true);
+}
+function isErrorValueSentinel(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__isErrorValue === true);
+}
+function isMapSentinel(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__isMap === true);
+}
+function isSetSentinel(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__isSet === true);
+}
+function isErrorSentinel(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__isError === true);
+}
+function isEscapedObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__isEscaped === true);
+}
+/**
+ * Recursively reconstruct Date objects, NaN values, Map, and Set from
+ * sentinels produced by the QuickJS-side __prepareForTransfer wrapper.
+ */
+function unwrapSentinels(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value !== 'object')
+        return value;
+    // Escaped user objects: keys collided with the sentinel markers, so the
+    // guest wrapped them (see injectTransferWrapper). Unwrap the values but
+    // treat the object itself as plain data.
+    if (isEscapedObject(value)) {
+        const inner = value.__value;
+        const result = {};
+        for (const key of Object.keys(inner)) {
+            result[key] = unwrapSentinels(inner[key]);
+        }
+        return result;
+    }
+    if (isDateSentinel(value))
+        return new Date(value.__isoString);
+    if (isNaNSentinel(value))
+        return NaN;
+    if (isErrorValueSentinel(value)) {
+        const ErrorCtor = {
+            TypeError,
+            SyntaxError,
+            EvalError,
+            RangeError,
+            ReferenceError,
+            URIError,
+        }[value.__name] ?? Error;
+        const err = new ErrorCtor(value.__message);
+        if (value.__extra) {
+            for (const [k, v] of Object.entries(value.__extra)) {
+                err[k] = unwrapSentinels(v);
+            }
+        }
+        return err;
+    }
+    if (isMapSentinel(value)) {
+        return new Map(value.__entries.map(([k, v]) => [unwrapSentinels(k), unwrapSentinels(v)]));
+    }
+    if (isSetSentinel(value)) {
+        return new Set(value.__values.map(unwrapSentinels));
+    }
+    if (Array.isArray(value))
+        return value.map(unwrapSentinels);
+    // Pass error sentinels through untouched — execute() detects them after
+    // unwrapping and reconstructs the Error on the host.
+    if (isErrorSentinel(value))
+        return value;
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = unwrapSentinels(value[key]);
+    }
+    return result;
+}
+/** Keys the transfer encoding reserves — keep in sync with the guest-side wrappers in injectTransferWrapper(). */
+const TRANSFER_MARKER_KEYS = new Set([
+    '__isDate',
+    '__isNaN',
+    '__isErrorValue',
+    '__isMap',
+    '__isSet',
+    '__isEscaped',
+]);
+/**
+ * Recursively wrap host values that JSON.stringify would flatten (Date, NaN,
+ * Map, Set) into the same sentinel format the guest transfer wrapper uses,
+ * escaping user objects whose keys collide with the markers. The guest
+ * rebuilds real instances via __unwrapFromHost (see injectTransferWrapper),
+ * so host-callback results match what isolated-vm's structured clone delivers.
+ */
+function wrapSpecialValuesForGuest(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (value instanceof Date) {
+        // Invalid Dates have no ISO string; '' rebuilds an Invalid Date in the guest.
+        return { __isDate: true, __isoString: isNaN(value.getTime()) ? '' : value.toISOString() };
+    }
+    if (typeof value === 'number' && Number.isNaN(value))
+        return { __isNaN: true };
+    if (typeof value !== 'object')
+        return value;
+    if (value instanceof Map) {
+        return {
+            __isMap: true,
+            __entries: [...value.entries()].map(([k, v]) => [
+                wrapSpecialValuesForGuest(k),
+                wrapSpecialValuesForGuest(v),
+            ]),
+        };
+    }
+    if (value instanceof Set) {
+        return { __isSet: true, __values: [...value.values()].map(wrapSpecialValuesForGuest) };
+    }
+    if (Array.isArray(value))
+        return value.map(wrapSpecialValuesForGuest);
+    // Error sentinels are already in transfer shape — leave them intact.
+    if (isErrorSentinel(value))
+        return value;
+    const record = value;
+    const result = {};
+    let collides = false;
+    for (const key of Object.keys(record)) {
+        if (TRANSFER_MARKER_KEYS.has(key))
+            collides = true;
+        result[key] = wrapSpecialValuesForGuest(record[key]);
+    }
+    return collides ? { __isEscaped: true, __value: result } : result;
+}
+/**
+ * Serialize an error into a transferable metadata object.
+ *
+ * Host-side callbacks (getValueAtPath, etc.) catch errors and return this
+ * sentinel instead of letting the error cross the boundary (which strips
+ * custom class identity and properties). The in-context proxy detects
+ * __isError and throws the sentinel; the host reconstructs a real Error
+ * after it round-trips back (see execute() / reconstructError).
+ */
+function serializeError(err) {
+    if (err instanceof Error) {
+        const extra = Object.fromEntries(Object.entries(err).filter(([key]) => key !== 'name' && key !== 'message' && key !== 'stack'));
+        return {
+            __isError: true,
+            name: err.name,
+            message: err.message,
+            stack: err.stack,
+            extra,
+        };
+    }
+    return { __isError: true, name: 'Error', message: String(err), extra: {} };
+}
+/**
+ * Read the runtime IIFE bundle by walking up from `__dirname` until
+ * `dist/bundle/runtime.iife.js` is found. Walking up (rather than a fixed
+ * relative path) works from either compiled output dir — `dist/cjs/bridge/`
+ * and `dist/esm/bridge/` sit at different depths from the bundle.
+ */
+async function readRuntimeBundle() {
+    let dir = __dirname;
+    while (dir !== path.dirname(dir)) {
+        try {
+            return await (0, promises_1.readFile)(path.join(dir, BUNDLE_RELATIVE_PATH), 'utf-8');
+        }
+        catch { }
+        dir = path.dirname(dir);
+    }
+    throw new Error(`Could not find runtime bundle (${BUNDLE_RELATIVE_PATH}) in any parent of ${__dirname}`);
+}
+/**
+ * Convert a host JavaScript value to a JSON string suitable for round-tripping
+ * into QuickJS via evalCode. Handles undefined (not valid JSON) by returning
+ * the string "undefined".
+ *
+ * Only objects/arrays reach this — primitives (including top-level NaN via
+ * newNumber) and Date are handled directly by the caller. Everything else
+ * (lazy-proxy metadata, Intl outputs, typed-RPC results, error-sentinel
+ * extras) is sentinel-wrapped first so nested Date/NaN/Map/Set survive the
+ * JSON round-trip and rebuild in the guest via __unwrapFromHost — matching
+ * what isolated-vm's structured clone delivers.
+ */
+function hostValueToJson(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    try {
+        return safeStringify(wrapSpecialValuesForGuest(value));
+    }
+    catch {
+        return 'undefined';
+    }
+}
+/**
+ * Navigate data object by path and return metadata or primitive value.
+ * Mirrors the IsolatedVmBridge getValueAtPath callback so QuickJS
+ * matches isolated-vm semantics, including special-cased $/$item navigation.
+ */
+function getValueAtPath(data, pathArr) {
+    let value = data;
+    let startIndex = 0;
+    const itemFn = data.$item;
+    if (pathArr.length >= 2 && pathArr[0] === '$item' && typeof itemFn === 'function') {
+        const itemIndex = parseInt(pathArr[1], 10);
+        if (!isNaN(itemIndex)) {
+            value = itemFn(itemIndex);
+            startIndex = 2;
+        }
+    }
+    else {
+        const dollarFn = data.$;
+        if (pathArr.length >= 2 && pathArr[0] === '$' && typeof dollarFn === 'function') {
+            value = dollarFn(pathArr[1]);
+            startIndex = 2;
+        }
+    }
+    for (let i = startIndex; i < pathArr.length; i++) {
+        value = value?.[pathArr[i]];
+        if (value === undefined || value === null) {
+            return value;
+        }
+    }
+    // Functions must never cross the boundary — resolve them as undefined,
+    // matching IsolatedVmBridge (invariant: __tests__/host-fn-shadowing.test.ts).
+    if (typeof value === 'function') {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return {
+            __isArray: true,
+            __length: value.length,
+            __data: null,
+        };
+    }
+    // Dates have no enumerable own keys; pass through instead of
+    // marshaling as an empty object.
+    if (value instanceof Date) {
+        return value;
+    }
+    if (value !== null && typeof value === 'object') {
+        return {
+            __isObject: true,
+            __keys: Object.keys(value),
+        };
+    }
+    return value;
+}
+function getArrayElement(data, pathArr, index) {
+    let arr = data;
+    let startIndex = 0;
+    const itemFn = data.$item;
+    if (pathArr.length >= 2 && pathArr[0] === '$item' && typeof itemFn === 'function') {
+        const itemIndex = parseInt(pathArr[1], 10);
+        if (!isNaN(itemIndex)) {
+            arr = itemFn(itemIndex);
+            startIndex = 2;
+        }
+    }
+    else {
+        const dollarFn = data.$;
+        if (pathArr.length >= 2 && pathArr[0] === '$' && typeof dollarFn === 'function') {
+            arr = dollarFn(pathArr[1]);
+            startIndex = 2;
+        }
+    }
+    for (let i = startIndex; i < pathArr.length; i++) {
+        arr = arr?.[pathArr[i]];
+        if (arr === undefined || arr === null) {
+            return undefined;
+        }
+    }
+    if (!Array.isArray(arr)) {
+        return undefined;
+    }
+    // Reject non-integer / negative indices so a crafted "index" can't read off
+    // the prototype chain. Mirrors IsolatedVmBridge.getArrayElement.
+    if (!Number.isInteger(index) || index < 0) {
+        return undefined;
+    }
+    const element = arr[index];
+    // Functions must never cross the boundary — resolve as undefined, matching
+    // getValueAtPath and IsolatedVmBridge (invariant: host-fn-shadowing.test.ts).
+    if (typeof element === 'function') {
+        return undefined;
+    }
+    // Dates have no enumerable own keys; pass through instead of
+    // marshaling as an empty object.
+    if (element instanceof Date) {
+        return element;
+    }
+    if (element !== null && typeof element === 'object') {
+        if (Array.isArray(element)) {
+            return {
+                __isArray: true,
+                __length: element.length,
+                __data: null,
+            };
+        }
+        return {
+            __isObject: true,
+            __keys: Object.keys(element),
+        };
+    }
+    return element;
+}
+/**
+ * Host-side dispatcher for the typed-RPC `callHost` channel.
+ *
+ * Mirrors IsolatedVmBridge's dispatcher — see isolated-vm-bridge.ts for the
+ * per-message rationale. The two copies are kept in sync at compile time:
+ * the `never` check in the default case fails to compile when a new schema
+ * lands in bridge-messages.ts without a matching case here.
+ */
+function dispatchHostCall(rawMsg, data) {
+    const msg = bridge_messages_1.bridgeMessageSchema.parse(rawMsg);
+    switch (msg.type) {
+        case 'getNodeFirst':
+            return data.$?.(msg.nodeName)?.first?.(msg.branchIndex, msg.runIndex);
+        case 'getNodeLast':
+            return data.$?.(msg.nodeName)?.last?.(msg.branchIndex, msg.runIndex);
+        case 'getNodeAll':
+            return data.$?.(msg.nodeName)?.all?.(msg.branchIndex, msg.runIndex);
+        case 'getInputFirst':
+            return data.$input?.first?.();
+        case 'getInputLast':
+            return data.$input?.last?.();
+        case 'getInputAll':
+            return data.$input?.all?.();
+        case 'getItems':
+            return data.$items?.(msg.nodeName, msg.outputIndex, msg.runIndex);
+        case 'fromAi':
+            return data.$fromAI?.(msg.name, msg.description, msg.valueType, msg.defaultValue);
+        case 'getNodePairedItem':
+            return data.$?.(msg.nodeName)?.pairedItem?.(msg.itemIndex);
+        case 'getNodeItemMatching':
+            return data.$?.(msg.nodeName)?.itemMatching?.(msg.itemIndex);
+        case 'getNodeItem':
+            // `.item` is a host getter — accessing it invokes the resolver.
+            return data.$?.(msg.nodeName)?.item;
+        case 'evaluateExpression':
+            return data.$evaluateExpression?.(msg.expression, msg.itemIndex);
+        case 'getPairedItem':
+            return data.$getPairedItem?.(msg.destinationNodeName, msg.incomingSourceData, msg.initialPairedItem);
+        default: {
+            // Unreachable at runtime — zod rejects unknown `type` values before
+            // the switch. The `never` assignment is the compile-time guard.
+            const exhaustive = msg;
+            void exhaustive;
+            throw new Error('Unhandled bridge message');
+        }
+    }
+}
+/**
+ * QuickJsBridge - Runtime bridge using quickjs-emscripten for expression evaluation.
+ *
+ * Mirrors the IsolatedVmBridge contract:
+ * - Memory limit enforcement
+ * - No access to Node.js APIs
+ * - Timeout enforcement via interrupt handler
+ * - Complete isolation from host process
+ *
+ * Callbacks are scoped per execute() call (see createCallbackHandles), so
+ * concurrent / nested evaluations see fresh data. The runtime treats bridge
+ * callbacks as plain functions, so `buildContext(callbacks, timezone)` gets
+ * the host callback functions directly.
+ */
+class QuickJsBridge {
+    runtime;
+    vm;
+    initialized = false;
+    disposed = false;
+    config;
+    logger;
+    // Long-lived host-callback handles (Intl polyfills) — disposed on dispose()
+    intlHandles = [];
+    // Wall-clock deadlines of the execute() calls currently in flight, outer to
+    // inner. execute() can re-enter (e.g. $evaluateExpression), and the runtime
+    // has a single interrupt handler; the handler interrupts once the earliest
+    // deadline passes, so a nested call cannot extend the outer call's budget.
+    deadlines = [];
+    constructor(config = {}) {
+        this.config = {
+            ...types_1.DEFAULT_BRIDGE_CONFIG,
+            ...config,
+        };
+        this.logger = this.config.logger;
+    }
+    async initialize() {
+        // Disposal is terminal (matches IsolatedVmBridge, whose isolate cannot be revived).
+        if (this.disposed)
+            throw new Error('Bridge has been disposed and cannot be reinitialized.');
+        if (this.initialized)
+            return;
+        const { getQuickJS } = await getQuickJSModule();
+        const QuickJS = await getQuickJS();
+        // Create runtime with memory limit (MB → bytes)
+        this.runtime = QuickJS.newRuntime();
+        this.runtime.setMemoryLimit(this.config.memoryLimit * 1024 * 1024);
+        this.vm = this.runtime.newContext();
+        // Install the interrupt handler once. It reads the live deadline stack, so
+        // nested execute() calls share one budget: the earliest deadline wins.
+        // Math.min() of an empty stack is Infinity, so an idle runtime never fires.
+        this.runtime.setInterruptHandler(() => Date.now() > Math.min(...this.deadlines));
+        // Set up 'global' / 'globalThis' self-reference
+        const globalHandle = this.vm.global;
+        this.vm.setProp(globalHandle, 'global', globalHandle);
+        this.vm.setProp(globalHandle, 'globalThis', globalHandle);
+        // Inject Intl polyfill — QuickJS doesn't include Intl, but Luxon needs it
+        this.injectIntlPolyfill();
+        // Load runtime bundle (DateTime, extend, SafeObject, proxy system, buildContext)
+        await this.loadRuntimeBundle();
+        // Wrap __prepareForTransfer to mark Date/NaN/Map/Set/Error so they survive vm.dump()
+        this.injectTransferWrapper();
+        // Inject E() error handler matching IsolatedVmBridge's E() semantics
+        this.injectErrorHandler();
+        this.verifyProxySystem();
+        this.initialized = true;
+        this.logger.info('[QuickJsBridge] Initialized successfully');
+    }
+    /**
+     * Load the runtime IIFE bundle and verify required globals are present.
+     */
+    async loadRuntimeBundle() {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        const runtimeBundle = await readRuntimeBundle();
+        const result = this.vm.evalCode(runtimeBundle);
+        if (result.error) {
+            const errorStr = this.vm.dump(result.error);
+            result.error.dispose();
+            throw new Error(`Failed to load runtime bundle: ${String(errorStr)}`);
+        }
+        result.value.dispose();
+        this.logger.info('[QuickJsBridge] Runtime bundle loaded');
+        this.evalCodeOrThrow('typeof DateTime !== "undefined"', 'DateTime verification');
+        this.evalCodeOrThrow('typeof extend !== "undefined"', 'extend verification');
+        this.logger.info('[QuickJsBridge] Vendor libraries verified successfully');
+    }
+    /**
+     * Inject a polyfill for the Intl API.
+     *
+     * QuickJS doesn't include Intl, but Luxon (bundled in the runtime) uses
+     * Intl.DateTimeFormat, Intl.NumberFormat, Intl.RelativeTimeFormat, and
+     * Intl.ListFormat extensively. Rather than shimming all of this in pure JS,
+     * we register host callback functions that delegate to Node.js's real Intl
+     * implementation, then build lightweight JS wrapper classes that call them.
+     */
+    injectIntlPolyfill() {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        const vm = this.vm;
+        const dtfFn = vm.newFunction('__intl_dtf', (...handles) => {
+            const args = handles.map((h) => vm.dump(h));
+            const op = args[0];
+            const locales = args[1];
+            const options = args[2];
+            try {
+                if (op === 'resolvedOptions') {
+                    const fmt = new Intl.DateTimeFormat(locales, options);
+                    return this.hostValueToQuickJSHandle(fmt.resolvedOptions());
+                }
+                if (op === 'format') {
+                    const fmt = new Intl.DateTimeFormat(locales, options);
+                    const ts = args[3];
+                    const date = ts !== undefined ? new Date(ts) : new Date();
+                    return this.hostValueToQuickJSHandle(fmt.format(date));
+                }
+                if (op === 'formatToParts') {
+                    const fmt = new Intl.DateTimeFormat(locales, options);
+                    const ts = args[3];
+                    const date = ts !== undefined ? new Date(ts) : new Date();
+                    return this.hostValueToQuickJSHandle(fmt.formatToParts(date));
+                }
+                if (op === 'supportedLocalesOf') {
+                    return this.hostValueToQuickJSHandle(Intl.DateTimeFormat.supportedLocalesOf(locales ?? []));
+                }
+            }
+            catch (err) {
+                return this.hostValueToQuickJSHandle({
+                    __intlError: true,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return vm.undefined;
+        });
+        vm.setProp(vm.global, '__intl_dtf', dtfFn);
+        this.intlHandles.push(dtfFn);
+        const nfFn = vm.newFunction('__intl_nf', (...handles) => {
+            const args = handles.map((h) => vm.dump(h));
+            const op = args[0];
+            const locales = args[1];
+            const options = args[2];
+            try {
+                if (op === 'resolvedOptions') {
+                    const fmt = new Intl.NumberFormat(locales, options);
+                    return this.hostValueToQuickJSHandle(fmt.resolvedOptions());
+                }
+                if (op === 'format') {
+                    const fmt = new Intl.NumberFormat(locales, options);
+                    const num = args[3];
+                    return this.hostValueToQuickJSHandle(fmt.format(num));
+                }
+                if (op === 'formatToParts') {
+                    const fmt = new Intl.NumberFormat(locales, options);
+                    const num = args[3];
+                    return this.hostValueToQuickJSHandle(fmt.formatToParts(num));
+                }
+            }
+            catch (err) {
+                return this.hostValueToQuickJSHandle({
+                    __intlError: true,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return vm.undefined;
+        });
+        vm.setProp(vm.global, '__intl_nf', nfFn);
+        this.intlHandles.push(nfFn);
+        const rtfFn = vm.newFunction('__intl_rtf', (...handles) => {
+            const args = handles.map((h) => vm.dump(h));
+            const op = args[0];
+            const locales = args[1];
+            const options = args[2];
+            try {
+                if (op === 'resolvedOptions') {
+                    const fmt = new Intl.RelativeTimeFormat(locales, options);
+                    return this.hostValueToQuickJSHandle(fmt.resolvedOptions());
+                }
+                if (op === 'format') {
+                    const fmt = new Intl.RelativeTimeFormat(locales, options);
+                    const value = args[3];
+                    const unit = args[4];
+                    return this.hostValueToQuickJSHandle(fmt.format(value, unit));
+                }
+                if (op === 'formatToParts') {
+                    const fmt = new Intl.RelativeTimeFormat(locales, options);
+                    const value = args[3];
+                    const unit = args[4];
+                    return this.hostValueToQuickJSHandle(fmt.formatToParts(value, unit));
+                }
+            }
+            catch (err) {
+                return this.hostValueToQuickJSHandle({
+                    __intlError: true,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return vm.undefined;
+        });
+        vm.setProp(vm.global, '__intl_rtf', rtfFn);
+        this.intlHandles.push(rtfFn);
+        const lfFn = vm.newFunction('__intl_lf', (...handles) => {
+            const args = handles.map((h) => vm.dump(h));
+            const op = args[0];
+            const locales = args[1];
+            const options = args[2];
+            try {
+                if (op === 'format') {
+                    const fmt = new Intl.ListFormat(locales, options);
+                    const list = args[3];
+                    return this.hostValueToQuickJSHandle(fmt.format(list));
+                }
+                if (op === 'formatToParts') {
+                    const fmt = new Intl.ListFormat(locales, options);
+                    const list = args[3];
+                    return this.hostValueToQuickJSHandle(fmt.formatToParts(list));
+                }
+                if (op === 'resolvedOptions') {
+                    const fmt = new Intl.ListFormat(locales, options);
+                    return this.hostValueToQuickJSHandle(fmt.resolvedOptions());
+                }
+            }
+            catch (err) {
+                return this.hostValueToQuickJSHandle({
+                    __intlError: true,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return vm.undefined;
+        });
+        vm.setProp(vm.global, '__intl_lf', lfFn);
+        this.intlHandles.push(lfFn);
+        const shimCode = `
+(function() {
+	function checkError(result) {
+		if (result && typeof result === 'object' && result.__intlError) {
+			throw new Error(result.message);
+		}
+		return result;
+	}
+
+	function DateTimeFormat(locales, options) {
+		this._locales = locales;
+		this._options = options || {};
+	}
+	DateTimeFormat.prototype.resolvedOptions = function() {
+		return checkError(__intl_dtf('resolvedOptions', this._locales, this._options));
+	};
+	DateTimeFormat.prototype.format = function(date) {
+		var ts = date instanceof Date ? date.getTime() : (typeof date === 'number' ? date : Date.now());
+		return checkError(__intl_dtf('format', this._locales, this._options, ts));
+	};
+	DateTimeFormat.prototype.formatToParts = function(date) {
+		var ts = date instanceof Date ? date.getTime() : (typeof date === 'number' ? date : Date.now());
+		return checkError(__intl_dtf('formatToParts', this._locales, this._options, ts));
+	};
+	DateTimeFormat.supportedLocalesOf = function(locales) {
+		return checkError(__intl_dtf('supportedLocalesOf', locales));
+	};
+
+	function NumberFormat(locales, options) {
+		this._locales = locales;
+		this._options = options || {};
+	}
+	NumberFormat.prototype.resolvedOptions = function() {
+		return checkError(__intl_nf('resolvedOptions', this._locales, this._options));
+	};
+	NumberFormat.prototype.format = function(num) {
+		return checkError(__intl_nf('format', this._locales, this._options, num));
+	};
+	NumberFormat.prototype.formatToParts = function(num) {
+		return checkError(__intl_nf('formatToParts', this._locales, this._options, num));
+	};
+
+	function RelativeTimeFormat(locales, options) {
+		this._locales = locales;
+		this._options = options || {};
+	}
+	RelativeTimeFormat.prototype.resolvedOptions = function() {
+		return checkError(__intl_rtf('resolvedOptions', this._locales, this._options));
+	};
+	RelativeTimeFormat.prototype.format = function(value, unit) {
+		return checkError(__intl_rtf('format', this._locales, this._options, value, unit));
+	};
+	RelativeTimeFormat.prototype.formatToParts = function(value, unit) {
+		return checkError(__intl_rtf('formatToParts', this._locales, this._options, value, unit));
+	};
+
+	function ListFormat(locales, options) {
+		this._locales = locales;
+		this._options = options || {};
+	}
+	ListFormat.prototype.format = function(list) {
+		return checkError(__intl_lf('format', this._locales, this._options, list));
+	};
+	ListFormat.prototype.formatToParts = function(list) {
+		return checkError(__intl_lf('formatToParts', this._locales, this._options, list));
+	};
+	ListFormat.prototype.resolvedOptions = function() {
+		return checkError(__intl_lf('resolvedOptions', this._locales, this._options));
+	};
+
+	globalThis.Intl = {
+		DateTimeFormat: DateTimeFormat,
+		NumberFormat: NumberFormat,
+		RelativeTimeFormat: RelativeTimeFormat,
+		ListFormat: ListFormat,
+		Locale: function Locale(tag) { this.baseName = tag; this.language = tag.split('-')[0]; }
+	};
+
+	// QuickJS's built-in toLocale* methods are locale-unaware (no ECMA-402) and
+	// ignore locales/options. Route them through the polyfill so they format on
+	// the host, like the spec routes them through NumberFormat/DateTimeFormat.
+	Number.prototype.toLocaleString = function(locales, options) {
+		return new NumberFormat(locales, options).format(Number(this));
+	};
+
+	function hasAny(options, keys) {
+		if (!options) return false;
+		for (var i = 0; i < keys.length; i++) {
+			if (options[keys[i]] !== undefined) return true;
+		}
+		return false;
+	}
+	var DATE_COMPONENTS = ['weekday', 'year', 'month', 'day'];
+	var TIME_COMPONENTS = ['dayPeriod', 'hour', 'minute', 'second', 'fractionalSecondDigits'];
+	// ToDateTimeOptions (ECMA-402 sec. 12): reject the style option the method
+	// doesn't cover (as V8 does), and when options carry none of the method's
+	// required components (and no dateStyle/timeStyle), fill in the method's
+	// numeric defaults so e.g. toLocaleTimeString() shows a time.
+	function toDateTimeOptions(options, requiredKeys, addDate, addTime, rejectedStyle) {
+		if (rejectedStyle && options && options[rejectedStyle] !== undefined) {
+			throw new TypeError('Invalid option : ' + rejectedStyle);
+		}
+		var merged = {};
+		for (var k in options || {}) merged[k] = options[k];
+		if (merged.dateStyle !== undefined || merged.timeStyle !== undefined) return merged;
+		if (hasAny(options, requiredKeys)) return merged;
+		if (addDate) { merged.year = 'numeric'; merged.month = 'numeric'; merged.day = 'numeric'; }
+		if (addTime) { merged.hour = 'numeric'; merged.minute = 'numeric'; merged.second = 'numeric'; }
+		return merged;
+	}
+	var ANY_COMPONENTS = DATE_COMPONENTS.concat(TIME_COMPONENTS);
+	Date.prototype.toLocaleString = function(locales, options) {
+		return new DateTimeFormat(locales, toDateTimeOptions(options, ANY_COMPONENTS, true, true)).format(this);
+	};
+	Date.prototype.toLocaleDateString = function(locales, options) {
+		return new DateTimeFormat(locales, toDateTimeOptions(options, DATE_COMPONENTS, true, false, 'timeStyle')).format(this);
+	};
+	Date.prototype.toLocaleTimeString = function(locales, options) {
+		return new DateTimeFormat(locales, toDateTimeOptions(options, TIME_COMPONENTS, false, true, 'dateStyle')).format(this);
+	};
+})();
+`;
+        const result = this.vm.evalCode(shimCode);
+        if (result.error) {
+            const errStr = this.vm.dump(result.error);
+            result.error.dispose();
+            throw new Error(`Failed to inject Intl polyfill: ${typeof errStr === 'object' ? JSON.stringify(errStr) : String(errStr)}`);
+        }
+        result.value.dispose();
+        this.logger.debug('[QuickJsBridge] Intl polyfill injected');
+    }
+    /**
+     * Wrap __prepareForTransfer so values that don't survive vm.dump()
+     * (Date, NaN, Map, Set, Error) are converted to sentinel objects.
+     * The host post-processes vm.dump() output to reconstruct real instances
+     * via unwrapSentinels(). Also injects __unwrapFromHost, the guest-side
+     * reverse: it rebuilds instances from the sentinels the host's
+     * wrapSpecialValuesForGuest() emits for callback results.
+     */
+    injectTransferWrapper() {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        const wrapperCode = `
+(function() {
+	var original = __prepareForTransfer;
+	globalThis.__prepareForTransfer = function(value) {
+		var prepared = original(value);
+		return wrapSpecialValues(prepared);
+	};
+	function wrapSpecialValues(v) {
+		if (v === null || v === undefined) return v;
+		// Functions and Promises must not leave the sandbox as results.
+		// isolated-vm's structured clone rejects them; match its error.
+		if (typeof v === 'function') {
+			throw new TypeError(String(v) + ' could not be cloned');
+		}
+		if (v instanceof Date) {
+			// Invalid Dates have no ISO string; '' rebuilds an Invalid Date on the host.
+			return { __isDate: true, __isoString: isNaN(v.getTime()) ? '' : v.toISOString() };
+		}
+		if (typeof v === 'number' && isNaN(v)) {
+			return { __isNaN: true };
+		}
+		if (typeof v !== 'object') return v;
+		if (v instanceof Promise) {
+			throw new TypeError('#<Promise> could not be cloned');
+		}
+		if (v instanceof Error) {
+			var errExtra = {};
+			var errKeys = Object.keys(v);
+			for (var ei = 0; ei < errKeys.length; ei++) {
+				if (errKeys[ei] !== 'name' && errKeys[ei] !== 'message' && errKeys[ei] !== 'stack') {
+					errExtra[errKeys[ei]] = wrapSpecialValues(v[errKeys[ei]]);
+				}
+			}
+			return { __isErrorValue: true, __name: v.name || 'Error', __message: v.message || '', __extra: errExtra };
+		}
+		if (v instanceof Map) {
+			var entries = [];
+			v.forEach(function(val, key) {
+				entries.push([wrapSpecialValues(key), wrapSpecialValues(val)]);
+			});
+			return { __isMap: true, __entries: entries };
+		}
+		if (v instanceof Set) {
+			var values = [];
+			v.forEach(function(val) {
+				values.push(wrapSpecialValues(val));
+			});
+			return { __isSet: true, __values: values };
+		}
+		if (Array.isArray(v)) return v.map(wrapSpecialValues);
+		// Error sentinels are already in transfer shape — leave them intact.
+		if (v.__isError) return v;
+		var result = {};
+		var keys = Object.keys(v);
+		var collides = false;
+		for (var i = 0; i < keys.length; i++) {
+			var key = keys[i];
+			if (
+				key === '__isDate' || key === '__isNaN' || key === '__isErrorValue' ||
+				key === '__isMap' || key === '__isSet' || key === '__isEscaped'
+			) {
+				collides = true;
+			}
+			result[key] = wrapSpecialValues(v[key]);
+		}
+		// User objects whose keys collide with transfer markers are escaped so
+		// the host returns them as plain data (as isolated-vm does) instead of
+		// misreading them as sentinels.
+		return collides ? { __isEscaped: true, __value: result } : result;
+	}
+
+	// Reverse direction: rebuild real instances from the sentinels the host's
+	// wrapSpecialValuesForGuest() produces for callback results.
+	globalThis.__unwrapFromHost = function unwrapFromHost(v) {
+		if (v === null || typeof v !== 'object') return v;
+		// Error sentinels stay as-is — the in-context proxy detects and throws them.
+		if (v.__isError === true) return v;
+		if (v.__isDate === true) return new Date(v.__isoString);
+		if (v.__isNaN === true) return NaN;
+		if (v.__isMap === true) {
+			var m = new Map();
+			for (var i = 0; i < v.__entries.length; i++) {
+				m.set(unwrapFromHost(v.__entries[i][0]), unwrapFromHost(v.__entries[i][1]));
+			}
+			return m;
+		}
+		if (v.__isSet === true) {
+			var s = new Set();
+			for (var j = 0; j < v.__values.length; j++) s.add(unwrapFromHost(v.__values[j]));
+			return s;
+		}
+		if (v.__isEscaped === true) {
+			var inner = v.__value;
+			var out = {};
+			var ekeys = Object.keys(inner);
+			for (var e = 0; e < ekeys.length; e++) out[ekeys[e]] = unwrapFromHost(inner[ekeys[e]]);
+			return out;
+		}
+		if (Array.isArray(v)) return v.map(unwrapFromHost);
+		var result = {};
+		var keys = Object.keys(v);
+		for (var n = 0; n < keys.length; n++) result[keys[n]] = unwrapFromHost(v[keys[n]]);
+		return result;
+	};
+})();
+`;
+        const result = this.vm.evalCode(wrapperCode);
+        if (result.error) {
+            const errStr = this.vm.dump(result.error);
+            result.error.dispose();
+            throw new Error(`Failed to inject transfer wrapper: ${typeof errStr === 'object' ? JSON.stringify(errStr) : String(errStr)}`);
+        }
+        result.value.dispose();
+        this.logger.debug('[QuickJsBridge] Transfer wrapper injected');
+    }
+    /**
+     * Inject the E() error handler matching IsolatedVmBridge semantics:
+     * - Re-throw ExpressionError / ExpressionExtensionError
+     * - Swallow everything else (TypeErrors, generic Errors, etc.)
+     *
+     * Errors from host callbacks arrive as sentinel objects (not class
+     * instances), so we match by `name` instead of instanceof.
+     */
+    injectErrorHandler() {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        const result = this.vm.evalCode(`
+			if (typeof E === 'undefined') {
+				globalThis.E = function(error, _context) {
+					var name = error && error.name;
+					if (name === 'ExpressionError' || name === 'ExpressionExtensionError') {
+						throw error;
+					}
+					return undefined;
+				};
+			}
+		`);
+        if (result.error) {
+            const errorStr = this.vm.dump(result.error);
+            result.error.dispose();
+            throw new Error(`Failed to inject error handler: ${String(errorStr)}`);
+        }
+        result.value.dispose();
+        this.logger.debug('[QuickJsBridge] Error handler injected');
+    }
+    verifyProxySystem() {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        const checks = [
+            ['createDeepLazyProxy', 'typeof createDeepLazyProxy !== "undefined"'],
+            ['buildContext', 'typeof buildContext !== "undefined"'],
+            ['SafeObject', 'typeof SafeObject !== "undefined"'],
+            ['SafeError', 'typeof SafeError !== "undefined"'],
+        ];
+        for (const [name, code] of checks) {
+            const result = this.vm.evalCode(code);
+            if (result.error) {
+                result.error.dispose();
+                throw new Error(`Proxy system verification failed: ${name} check errored`);
+            }
+            const val = this.vm.dump(result.value);
+            result.value.dispose();
+            if (val !== true) {
+                throw new Error(`Proxy system verification failed: ${name} not available`);
+            }
+        }
+        this.logger.debug('[QuickJsBridge] Proxy system verified');
+    }
+    /**
+     * Create per-execute callback function handles, closure-scoped to `data`.
+     *
+     * The handles are passed as arguments into the per-call wrapper function
+     * (see execute()) instead of being set as VM globals: `execute()` can
+     * re-enter synchronously (e.g. `$evaluateExpression`), and globals would
+     * let the nested call's callbacks clobber the in-flight outer call's data
+     * bindings. This mirrors IsolatedVmBridge's closure-scoped `$0`/`$1`/`$2`
+     * evalClosureSync references.
+     *
+     * Callers must dispose the returned handles when the call completes.
+     */
+    createCallbackHandles(data) {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        const vm = this.vm;
+        const getValueFn = vm.newFunction('__getValueAtPathImpl', (pathHandle) => {
+            const pathArr = vm.dump(pathHandle);
+            try {
+                const result = getValueAtPath(data, pathArr);
+                return this.hostValueToQuickJSHandle(result);
+            }
+            catch (err) {
+                return this.hostValueToQuickJSHandle(serializeError(err));
+            }
+        });
+        const getArrayFn = vm.newFunction('__getArrayElementImpl', (pathHandle, indexHandle) => {
+            const pathArr = vm.dump(pathHandle);
+            const index = vm.dump(indexHandle);
+            try {
+                const result = getArrayElement(data, pathArr, index);
+                return this.hostValueToQuickJSHandle(result);
+            }
+            catch (err) {
+                return this.hostValueToQuickJSHandle(serializeError(err));
+            }
+        });
+        const callHostFn = vm.newFunction('__callHostImpl', (msgHandle) => {
+            const rawMsg = vm.dump(msgHandle);
+            try {
+                const result = dispatchHostCall(rawMsg, data);
+                return this.hostValueToQuickJSHandle(result);
+            }
+            catch (err) {
+                return this.hostValueToQuickJSHandle(serializeError(err));
+            }
+        });
+        return [getValueFn, getArrayFn, callHostFn];
+    }
+    /**
+     * Convert a host JavaScript value to a QuickJS handle.
+     *
+     * For primitives, uses the dedicated vm.newXxx() methods.
+     * For complex objects (arrays, objects), uses JSON round-trip via evalCode.
+     */
+    hostValueToQuickJSHandle(value) {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        if (value === undefined)
+            return this.vm.undefined;
+        if (value === null)
+            return this.vm.null;
+        if (typeof value === 'number') {
+            return this.vm.newNumber(value);
+        }
+        if (typeof value === 'string')
+            return this.vm.newString(value);
+        if (typeof value === 'boolean') {
+            return value ? this.vm.true : this.vm.false;
+        }
+        // Construct a real Date inside the context — JSON round-tripping would
+        // collapse it to an ISO string (via Date.prototype.toJSON).
+        if (value instanceof Date) {
+            const dateResult = this.vm.evalCode(`(new Date(${value.getTime()}))`);
+            if (dateResult.error) {
+                dateResult.error.dispose();
+                return this.vm.undefined;
+            }
+            return dateResult.value;
+        }
+        const json = hostValueToJson(value);
+        if (json === 'undefined')
+            return this.vm.undefined;
+        const result = this.vm.evalCode(`__unwrapFromHost(${json})`);
+        if (result.error) {
+            result.error.dispose();
+            return this.vm.undefined;
+        }
+        return result.value;
+    }
+    /**
+     * Execute JavaScript code in the QuickJS context.
+     *
+     * Mirrors IsolatedVmBridge.execute():
+     * 1. Create per-call host callbacks scoped to `data` (createCallbackHandles)
+     * 2. Build a fresh evaluation context via buildContext(callbacks, timezone)
+     * 3. Run wrapped code with `this` set to the context
+     * 4. Reconstruct error sentinels into real Errors
+     */
+    execute(code, data, options) {
+        if (!this.initialized || !this.vm || !this.runtime) {
+            throw new Error('Bridge not initialized. Call initialize() first.');
+        }
+        // A nested call runs on what is left of the configured timeout, so the
+        // chain shares one budget (mirrors IsolatedVmBridge). A configured
+        // timeout of 0 means "no limit", so there is nothing to share.
+        const elapsedMs = options?.elapsedMs ?? 0;
+        const nested = elapsedMs > 0 && this.config.timeout > 0;
+        let timeout = this.config.timeout;
+        if (nested) {
+            timeout = Math.trunc(this.config.timeout - elapsedMs);
+            if (timeout <= 0)
+                throw this.timeoutError(true);
+        }
+        const callbackHandles = this.createCallbackHandles(data);
+        let wrapperFn;
+        // Push this call's deadline; the interrupt handler (set in initialize)
+        // interrupts on the earliest in-flight deadline. Popped in finally so a
+        // nested call can't leave the outer budget extended.
+        this.deadlines.push(Date.now() + timeout);
+        try {
+            const timezone = options?.timezone ? safeStringify(options.timezone) : 'undefined';
+            // The callback impls arrive as function arguments (scoped to this call),
+            // never as globals — see createCallbackHandles(). The runtime calls them
+            // as plain functions; the isolated-vm bridge wires ivm.Callback there,
+            // while QuickJS host functions are already plain functions in the context.
+            const wrappedCode = `
+(function(__getValueAtPathImpl, __getArrayElementImpl, __callHostImpl) {
+  var __ctx = buildContext({
+    getValueAtPath: __getValueAtPathImpl,
+    getArrayElement: __getArrayElementImpl,
+    callHost: __callHostImpl,
+  }, ${timezone});
+  try {
+    var __result = (function() {
+      ${code}
+    }).call(__ctx);
+    return __prepareForTransfer(__result);
+  } catch(e) {
+    if (e && e.__isError) return e;
+    if (e == null) return { __isError: true, name: "Error", message: String(e), stack: "", extra: {} };
+    var extra = {};
+    for (var k in e) {
+      if (Object.prototype.hasOwnProperty.call(e, k) && k !== "name" && k !== "message" && k !== "stack") extra[k] = e[k];
+    }
+    return {
+      __isError: true,
+      name: e.name || "Error",
+      message: e.message || "",
+      stack: e.stack || "",
+      extra: extra
+    };
+  }
+})`;
+            const wrapperResult = this.vm.evalCode(wrappedCode);
+            if (wrapperResult.error) {
+                const errDump = this.vm.dump(wrapperResult.error);
+                wrapperResult.error.dispose();
+                throw new Error(`Expression compilation failed: ${String(errDump)}`);
+            }
+            wrapperFn = wrapperResult.value;
+            const execResult = this.vm.callFunction(wrapperFn, this.vm.undefined, ...callbackHandles);
+            if (execResult.error) {
+                const errDump = this.vm.dump(execResult.error);
+                execResult.error.dispose();
+                // buildContext throws on invalid timezone — propagate the original message
+                const errStr = String(typeof errDump === 'object' && errDump !== null
+                    ? (errDump.message ?? errDump)
+                    : errDump);
+                if (errStr.includes('interrupted')) {
+                    throw this.timeoutError(nested);
+                }
+                if (typeof errDump === 'object' &&
+                    errDump !== null &&
+                    typeof errDump.message === 'string') {
+                    throw new Error(errDump.message);
+                }
+                throw new Error(`Expression evaluation failed: ${errStr}`);
+            }
+            const rawResult = this.vm.dump(execResult.value);
+            execResult.value.dispose();
+            const result = unwrapSentinels(rawResult);
+            if (isErrorSentinel(result)) {
+                throw this.reconstructError(result);
+            }
+            this.logger.debug('[QuickJsBridge] Expression executed successfully');
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (error.name === 'ExpressionError' || error.name === 'ExpressionExtensionError')) {
+                throw error;
+            }
+            if (error instanceof types_1.TimeoutError || error instanceof types_1.MemoryLimitError) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('interrupted')) {
+                throw this.timeoutError(nested);
+            }
+            if (errorMessage.includes('out of memory') || errorMessage.includes('memory')) {
+                throw new types_1.MemoryLimitError(`Expression exceeded memory limit of ${this.config.memoryLimit}MB`, {});
+            }
+            throw new Error(`Expression evaluation failed: ${errorMessage}`);
+        }
+        finally {
+            this.deadlines.pop();
+            wrapperFn?.dispose();
+            for (const handle of callbackHandles) {
+                handle.dispose();
+            }
+        }
+    }
+    /**
+     * Always names the configured limit, never the reduced budget a nested call
+     * ran on — reporting "timed out after 137ms" would misstate the limit.
+     */
+    timeoutError(nested) {
+        return new types_1.TimeoutError(nested
+            ? `Nested expressions timed out after sharing the ${this.config.timeout}ms limit`
+            : `Expression timed out after ${this.config.timeout}ms`, {});
+    }
+    reconstructError(data) {
+        const error = new Error(data.message);
+        error.name = data.name || 'Error';
+        if (data.stack) {
+            error.stack = data.stack;
+        }
+        if (data.extra) {
+            Object.assign(error, data.extra);
+        }
+        return error;
+    }
+    evalCodeOrThrow(code, label) {
+        if (!this.vm)
+            throw new Error('Context not initialized');
+        const result = this.vm.evalCode(code);
+        if (result.error) {
+            const errStr = this.vm.dump(result.error);
+            result.error.dispose();
+            throw new Error(`${label} failed: ${String(errStr)}`);
+        }
+        const value = this.vm.dump(result.value);
+        result.value.dispose();
+        return value;
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        for (const handle of this.intlHandles) {
+            handle.dispose();
+        }
+        this.intlHandles = [];
+        if (this.vm) {
+            this.vm.dispose();
+            this.vm = undefined;
+        }
+        if (this.runtime) {
+            this.runtime.dispose();
+            this.runtime = undefined;
+        }
+        this.disposed = true;
+        this.initialized = false;
+        this.logger.info('[QuickJsBridge] Disposed');
+    }
+    isDisposed() {
+        return this.disposed;
+    }
+}
+exports.QuickJsBridge = QuickJsBridge;
+//# sourceMappingURL=quickjs-bridge.js.map