@n8n/expression-runtime 0.29.1 → 0.31.0

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

@@ -1,8 +1,19 @@
-import { readFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { DEFAULT_BRIDGE_CONFIG, TimeoutError, MemoryLimitError } from '../types';
-import { bridgeMessageSchema } from './bridge-messages';
+import { isLuxonSentinel, rebuildLuxonValue } from '../runtime/luxon-transfer';
+import { isEscapedTransferValue, isOpaqueTransferValue, TRANSFER_ESCAPED_KEY, TRANSFER_OPAQUE_KEY, TRANSFER_TYPE_KEY, } from '../runtime/transfer';
+import { LruCache } from '../evaluator/lru-cache';
+import { dispatchHostCall, getArrayElement, getValueAtPath, isErrorSentinel, reconstructError, serializeError, } from './host-functions';
 let _quickjs = null;
+/**
+ * The instantiated WASM module, cached after the first async initialize().
+ * Creating runtimes/contexts from it is synchronous, so once it is cached
+ * (pool warmup does this) initializeSync() can build a bridge on demand.
+ */
+let _quickjsWasm = null;
+/** Runtime bundle source, read once per process by loadRuntimeBundle(). */
+let _runtimeBundle = null;
 async function getQuickJSModule() {
     if (!_quickjs) {
         _quickjs = await import('quickjs-emscripten');
@@ -49,21 +60,43 @@ function isSetSentinel(value) {
         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);
 }
+/**
+ * Give back the payload of an escape wrapper.
+ *
+ * A walked payload only had its own keys collide, so the walk goes on and
+ * rebuilds the markers deeper in it. An opaque payload is a value the guest
+ * could not walk, so `opaque` keeps every marker in it as data.
+ */
+function unescapeTransferValue(value) {
+    const inner = value.__value;
+    const opaque = isOpaqueTransferValue(value);
+    if (typeof inner !== 'object' || inner === null)
+        return inner;
+    if (isEscapedObject(inner))
+        return unwrapSentinels(inner, opaque);
+    if (Array.isArray(inner))
+        return inner.map((entry) => unwrapSentinels(entry, opaque));
+    const unescaped = {};
+    for (const [key, entry] of Object.entries(inner)) {
+        unescaped[key] = unwrapSentinels(entry, opaque);
+    }
+    return unescaped;
+}
 /**
  * Recursively reconstruct Date objects, NaN values, Map, and Set from
  * sentinels produced by the QuickJS-side __prepareForTransfer wrapper.
+ *
+ * With `markersAsData` set, a transfer marker is left as the plain object it
+ * is, for the contents of a payload the guest marked opaque. The guest escapes
+ * most such objects itself, but one that also carries `__isError` leaves the
+ * guest walk before the escape, so the host must not read it as a marker.
  */
-function unwrapSentinels(value) {
+function unwrapSentinels(value, markersAsData = false) {
     if (value === null || value === undefined)
         return value;
     if (typeof value !== 'object')
@@ -75,10 +108,16 @@ function unwrapSentinels(value) {
         const inner = value.__value;
         const result = {};
         for (const key of Object.keys(inner)) {
-            result[key] = unwrapSentinels(inner[key]);
+            result[key] = unwrapSentinels(inner[key], markersAsData);
         }
         return result;
     }
+    if (!markersAsData) {
+        if (isLuxonSentinel(value))
+            return rebuildLuxonValue(value);
+        if (isEscapedTransferValue(value))
+            return unescapeTransferValue(value);
+    }
     if (isDateSentinel(value))
         return new Date(value.__isoString);
     if (isNaNSentinel(value))
@@ -95,26 +134,29 @@ function unwrapSentinels(value) {
         const err = new ErrorCtor(value.__message);
         if (value.__extra) {
             for (const [k, v] of Object.entries(value.__extra)) {
-                err[k] = unwrapSentinels(v);
+                err[k] = unwrapSentinels(v, markersAsData);
             }
         }
         return err;
     }
     if (isMapSentinel(value)) {
-        return new Map(value.__entries.map(([k, v]) => [unwrapSentinels(k), unwrapSentinels(v)]));
+        return new Map(value.__entries.map(([k, v]) => [
+            unwrapSentinels(k, markersAsData),
+            unwrapSentinels(v, markersAsData),
+        ]));
     }
     if (isSetSentinel(value)) {
-        return new Set(value.__values.map(unwrapSentinels));
+        return new Set(value.__values.map((entry) => unwrapSentinels(entry, markersAsData)));
     }
     if (Array.isArray(value))
-        return value.map(unwrapSentinels);
+        return value.map((entry) => unwrapSentinels(entry, markersAsData));
     // 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]);
+        result[key] = unwrapSentinels(value[key], markersAsData);
     }
     return result;
 }
@@ -173,38 +215,21 @@ function wrapSpecialValuesForGuest(value) {
     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() {
+function loadRuntimeBundle() {
+    if (_runtimeBundle !== null)
+        return _runtimeBundle;
     let dir = __dirname;
     while (dir !== path.dirname(dir)) {
         try {
-            return await readFile(path.join(dir, BUNDLE_RELATIVE_PATH), 'utf-8');
+            _runtimeBundle = readFileSync(path.join(dir, BUNDLE_RELATIVE_PATH), 'utf-8');
+            return _runtimeBundle;
         }
         catch { }
         dir = path.dirname(dir);
@@ -212,6 +237,7 @@ async function readRuntimeBundle() {
     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".
@@ -235,165 +261,100 @@ function hostValueToJson(value) {
         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;
+/** Formatter args arrive as dumped guest values; DateTimeFormat dates travel as timestamps. */
+function toDateArg(ts) {
+    return typeof ts === 'number' ? new Date(ts) : new Date();
 }
 /**
- * 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.
+ * Snapshot the properties Luxon and user code read from Intl.Locale into a
+ * plain object the guest copies onto its wrapper instance. weekInfo moved
+ * from a getter to getWeekInfo() across V8 versions — read both shapes.
  */
-function dispatchHostCall(rawMsg, data) {
-    const msg = 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');
-        }
-    }
+function dumpLocale(loc) {
+    const withWeekInfo = loc;
+    return {
+        tag: loc.toString(),
+        baseName: loc.baseName,
+        language: loc.language,
+        script: loc.script,
+        region: loc.region,
+        calendar: loc.calendar,
+        caseFirst: loc.caseFirst,
+        collation: loc.collation,
+        hourCycle: loc.hourCycle,
+        numberingSystem: loc.numberingSystem,
+        numeric: loc.numeric,
+        weekInfo: withWeekInfo.getWeekInfo?.() ?? withWeekInfo.weekInfo,
+    };
 }
+const INTL_DISPATCH = {
+    DateTimeFormat: {
+        create: (locales, options) => new Intl.DateTimeFormat(locales, options),
+        supportedLocalesOf: (locales) => Intl.DateTimeFormat.supportedLocalesOf(locales ?? []),
+        ops: {
+            format: (fmt, args) => fmt.format(toDateArg(args[0])),
+            formatToParts: (fmt, args) => fmt.formatToParts(toDateArg(args[0])),
+            resolvedOptions: (fmt) => fmt.resolvedOptions(),
+        },
+    },
+    NumberFormat: {
+        create: (locales, options) => new Intl.NumberFormat(locales, options),
+        supportedLocalesOf: (locales) => Intl.NumberFormat.supportedLocalesOf(locales ?? []),
+        ops: {
+            format: (fmt, args) => fmt.format(args[0]),
+            formatToParts: (fmt, args) => fmt.formatToParts(args[0]),
+            resolvedOptions: (fmt) => fmt.resolvedOptions(),
+        },
+    },
+    RelativeTimeFormat: {
+        create: (locales, options) => new Intl.RelativeTimeFormat(locales, options),
+        supportedLocalesOf: (locales) => Intl.RelativeTimeFormat.supportedLocalesOf(locales ?? []),
+        ops: {
+            format: (fmt, args) => fmt.format(args[0], args[1]),
+            formatToParts: (fmt, args) => fmt.formatToParts(args[0], args[1]),
+            resolvedOptions: (fmt) => fmt.resolvedOptions(),
+        },
+    },
+    ListFormat: {
+        create: (locales, options) => new Intl.ListFormat(locales, options),
+        supportedLocalesOf: (locales) => Intl.ListFormat.supportedLocalesOf(locales ?? []),
+        ops: {
+            format: (fmt, args) => fmt.format(args[0]),
+            formatToParts: (fmt, args) => fmt.formatToParts(args[0]),
+            resolvedOptions: (fmt) => fmt.resolvedOptions(),
+        },
+    },
+    Collator: {
+        create: (locales, options) => new Intl.Collator(locales, options),
+        supportedLocalesOf: (locales) => Intl.Collator.supportedLocalesOf(locales ?? []),
+        ops: {
+            compare: (col, args) => col.compare(args[0], args[1]),
+            resolvedOptions: (col) => col.resolvedOptions(),
+        },
+    },
+    PluralRules: {
+        create: (locales, options) => new Intl.PluralRules(locales, options),
+        supportedLocalesOf: (locales) => Intl.PluralRules.supportedLocalesOf(locales ?? []),
+        ops: {
+            select: (pr, args) => pr.select(args[0]),
+            resolvedOptions: (pr) => pr.resolvedOptions(),
+        },
+    },
+    DisplayNames: {
+        create: (locales, options) => new Intl.DisplayNames(locales, options),
+        supportedLocalesOf: (locales) => Intl.DisplayNames.supportedLocalesOf(locales ?? []),
+        ops: {
+            of: (dn, args) => dn.of(args[0]),
+            resolvedOptions: (dn) => dn.resolvedOptions(),
+        },
+    },
+    Locale: {
+        create: (locales, options) => new Intl.Locale(locales, options),
+        ops: {
+            dump: (loc) => dumpLocale(loc),
+        },
+    },
+};
 /**
  * QuickJsBridge - Runtime bridge using quickjs-emscripten for expression evaluation.
  *
@@ -417,6 +378,11 @@ export class QuickJsBridge {
     logger;
     // Long-lived host-callback handles (Intl polyfills) — disposed on dispose()
     intlHandles = [];
+    // Memoized host Intl formatters keyed by ctor + locales + options.
+    // Construction dominates per-call cost (~39µs for a DateTimeFormat vs ~1µs
+    // for format on an existing one). Capped because locales/options are
+    // user-influenced — unbounded, this would be a memory leak by user input.
+    intlFormatterCache = new LruCache(200);
     // 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
@@ -437,6 +403,31 @@ export class QuickJsBridge {
             return;
         const { getQuickJS } = await getQuickJSModule();
         const QuickJS = await getQuickJS();
+        _quickjsWasm = QuickJS;
+        this.setupContext(QuickJS, loadRuntimeBundle());
+    }
+    /**
+     * Synchronous variant of initialize(), for on-demand creation inside the
+     * synchronous evaluate() path (lazy acquisition with an exhausted pool).
+     * Requires the WASM module to have been instantiated by an earlier async
+     * initialize() in this process — pool warmup provides that.
+     */
+    initializeSync() {
+        if (this.disposed)
+            throw new Error('Bridge has been disposed and cannot be reinitialized.');
+        if (this.initialized)
+            return;
+        // Both caches are populated by the same async initialize() (pool
+        // warmup), so the sync path never touches the filesystem or the
+        // event loop beyond the context setup itself.
+        if (_quickjsWasm === null || _runtimeBundle === null) {
+            throw new Error('QuickJS WASM module and runtime bundle are not loaded yet: an async initialize() ' +
+                'must run once (pool warmup) before bridges can be created synchronously');
+        }
+        this.setupContext(_quickjsWasm, _runtimeBundle);
+    }
+    /** Everything after module/bundle acquisition is synchronous and shared. */
+    setupContext(QuickJS, runtimeBundle) {
         // Create runtime with memory limit (MB → bytes)
         this.runtime = QuickJS.newRuntime();
         this.runtime.setMemoryLimit(this.config.memoryLimit * 1024 * 1024);
@@ -452,7 +443,7 @@ export class QuickJsBridge {
         // 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();
+        this.loadRuntimeBundle(runtimeBundle);
         // 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
@@ -464,10 +455,9 @@ export class QuickJsBridge {
     /**
      * Load the runtime IIFE bundle and verify required globals are present.
      */
-    async loadRuntimeBundle() {
+    loadRuntimeBundle(runtimeBundle) {
         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);
@@ -483,105 +473,20 @@ export class QuickJsBridge {
     /**
      * 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.
+     * QuickJS doesn't include Intl, but Luxon (bundled in the runtime) and user
+     * expressions use it extensively. Rather than shimming ECMA-402 in pure JS,
+     * we register a single `__intl` host callback that dispatches to Node.js's
+     * real Intl implementation (see INTL_DISPATCH), then build lightweight JS
+     * wrapper classes that call it.
      */
     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 intlFn = vm.newFunction('__intl', (...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));
-                }
+                return this.hostValueToQuickJSHandle(this.dispatchIntl(args[0], args[1], args[2], args[3], args.slice(4)));
             }
             catch (err) {
                 return this.hostValueToQuickJSHandle({
@@ -589,41 +494,9 @@ export class QuickJsBridge {
                     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);
+        vm.setProp(vm.global, '__intl', intlFn);
+        this.intlHandles.push(intlFn);
         const shimCode = `
 (function() {
 	function checkError(result) {
@@ -633,73 +506,107 @@ export class QuickJsBridge {
 		return result;
 	}
 
-	function DateTimeFormat(locales, options) {
-		this._locales = locales;
-		this._options = options || {};
+	// Shallow-copy locales/options at construction — V8 snapshots them when a
+	// formatter is created, so mutating them afterwards must not change output.
+	// The stable snapshot also keys the host-side formatter memo.
+	function snapshotOptions(options) {
+		if (options === null || options === undefined) return undefined;
+		var copy = {};
+		for (var k in options) copy[k] = options[k];
+		return copy;
+	}
+	function snapshotLocales(locales) {
+		return Array.isArray(locales) ? locales.slice() : locales;
 	}
-	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 || {};
+	function callIntl(inst, ctorName, op, args, transform) {
+		var callArgs = [ctorName, op, inst._locales, inst._options];
+		var i = 0;
+		if (transform) {
+			callArgs.push(transform(args[0]));
+			i = 1;
+		}
+		for (; i < args.length; i++) callArgs.push(args[i]);
+		return checkError(__intl.apply(null, callArgs));
 	}
-	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 || {};
+	// Build a wrapper class that delegates each op to the host dispatcher.
+	// \`ops\` maps op name → optional first-arg transform. \`boundOp\` is also
+	// installed as an instance function: V8 models format/compare as
+	// bound-function getters, so e.g. dates.map(dtf.format) must work unbound.
+	function makeWrapper(ctorName, ops, boundOp) {
+		function Wrapper(locales, options) {
+			this._locales = snapshotLocales(locales);
+			this._options = snapshotOptions(options);
+			if (boundOp) {
+				var self = this;
+				this[boundOp] = function () {
+					return callIntl(self, ctorName, boundOp, arguments, ops[boundOp]);
+				};
+			}
+		}
+		var opNames = Object.keys(ops);
+		for (var i = 0; i < opNames.length; i++) {
+			(function (op) {
+				Wrapper.prototype[op] = function () {
+					return callIntl(this, ctorName, op, arguments, ops[op]);
+				};
+			})(opNames[i]);
+		}
+		Wrapper.supportedLocalesOf = function (locales) {
+			return checkError(__intl(ctorName, 'supportedLocalesOf', locales));
+		};
+		return Wrapper;
 	}
-	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 || {};
+	// DateTimeFormat dates travel as timestamps — guest Dates don't survive vm.dump().
+	function toTs(date) {
+		return date instanceof Date ? date.getTime() : (typeof date === 'number' ? date : Date.now());
 	}
-	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));
-	};
+
+	var DateTimeFormat = makeWrapper('DateTimeFormat', { format: toTs, formatToParts: toTs, resolvedOptions: null }, 'format');
+	var NumberFormat = makeWrapper('NumberFormat', { format: null, formatToParts: null, resolvedOptions: null }, 'format');
+	var RelativeTimeFormat = makeWrapper('RelativeTimeFormat', { format: null, formatToParts: null, resolvedOptions: null }, null);
+	var ListFormat = makeWrapper('ListFormat', { format: null, formatToParts: null, resolvedOptions: null }, null);
+	var Collator = makeWrapper('Collator', { compare: null, resolvedOptions: null }, 'compare');
+	var PluralRules = makeWrapper('PluralRules', { select: null, resolvedOptions: null }, null);
+	var DisplayNames = makeWrapper('DisplayNames', { of: null, resolvedOptions: null }, null);
+
+	// Host-backed Intl.Locale: the host dumps the locale's properties once at
+	// construction. Luxon feature-detects week support via ('weekInfo' in
+	// Intl.Locale.prototype || 'getWeekInfo' in Intl.Locale.prototype) and
+	// prefers getWeekInfo() — expose both, like current V8.
+	function Locale(tag, options) {
+		var dumped = checkError(__intl('Locale', 'dump', tag, snapshotOptions(options)));
+		var keys = Object.keys(dumped);
+		for (var i = 0; i < keys.length; i++) {
+			var k = keys[i];
+			if (k === 'weekInfo') this._weekInfo = dumped[k];
+			else if (k === 'tag') this._tag = dumped[k];
+			else this[k] = dumped[k];
+		}
+	}
+	Object.defineProperty(Locale.prototype, 'weekInfo', {
+		get: function () { return this._weekInfo; },
+	});
+	Locale.prototype.getWeekInfo = function () { return this._weekInfo; };
+	Locale.prototype.toString = function () { return this._tag; };
 
 	globalThis.Intl = {
 		DateTimeFormat: DateTimeFormat,
 		NumberFormat: NumberFormat,
 		RelativeTimeFormat: RelativeTimeFormat,
 		ListFormat: ListFormat,
-		Locale: function Locale(tag) { this.baseName = tag; this.language = tag.split('-')[0]; }
+		Collator: Collator,
+		PluralRules: PluralRules,
+		DisplayNames: DisplayNames,
+		Locale: Locale,
+		getCanonicalLocales: function (locales) {
+			return checkError(__intl('Intl', 'getCanonicalLocales', locales));
+		},
+		supportedValuesOf: function (key) {
+			return checkError(__intl('Intl', 'supportedValuesOf', undefined, undefined, key));
+		},
 	};
 
 	// QuickJS's built-in toLocale* methods are locale-unaware (no ECMA-402) and
@@ -755,6 +662,43 @@ export class QuickJsBridge {
         result.value.dispose();
         this.logger.debug('[QuickJsBridge] Intl polyfill injected');
     }
+    /**
+     * Host side of the guest's `__intl(ctorName, op, locales, options, ...args)`
+     * callback. Resolves the constructor and op against INTL_DISPATCH (rejecting
+     * anything not in the table) and memoizes constructed formatters.
+     */
+    dispatchIntl(ctorName, op, locales, options, args) {
+        // Pure static Intl functions — no constructed instance involved.
+        if (ctorName === 'Intl') {
+            if (op === 'getCanonicalLocales')
+                return Intl.getCanonicalLocales(locales);
+            if (op === 'supportedValuesOf') {
+                return Intl.supportedValuesOf(args[0]);
+            }
+            throw new TypeError(`Unsupported Intl operation: ${op}`);
+        }
+        const entry = INTL_DISPATCH[ctorName];
+        if (!entry)
+            throw new TypeError(`Unsupported Intl constructor: ${ctorName}`);
+        if (op === 'supportedLocalesOf') {
+            if (!entry.supportedLocalesOf) {
+                throw new TypeError(`Intl.${ctorName} has no supportedLocalesOf`);
+            }
+            return entry.supportedLocalesOf(locales);
+        }
+        const opFn = entry.ops[op];
+        if (!opFn)
+            throw new TypeError(`Unsupported Intl.${ctorName} operation: ${op}`);
+        // Guest wrappers snapshot options at construction, so the JSON key is
+        // stable across calls on the same wrapper instance.
+        const key = `${ctorName}${JSON.stringify(locales) ?? ''}${JSON.stringify(options) ?? ''}`;
+        let instance = this.intlFormatterCache.get(key);
+        if (instance === undefined) {
+            instance = entry.create(locales, options);
+            this.intlFormatterCache.set(key, instance);
+        }
+        return opFn(instance, args);
+    }
     /**
      * Wrap __prepareForTransfer so values that don't survive vm.dump()
      * (Date, NaN, Map, Set, Error) are converted to sentinel objects.
@@ -773,7 +717,10 @@ export class QuickJsBridge {
 		var prepared = original(value);
 		return wrapSpecialValues(prepared);
 	};
-	function wrapSpecialValues(v) {
+	// __prepareForTransfer does not walk into a Map, a Set or the extra keys of an
+	// Error, and it does not walk an opaque payload. The inCollection flag marks
+	// those places, where a transfer marker can only come from user data.
+	function wrapSpecialValues(v, inCollection) {
 		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.
@@ -796,7 +743,7 @@ export class QuickJsBridge {
 			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]]);
+					errExtra[errKeys[ei]] = wrapSpecialValues(v[errKeys[ei]], true);
 				}
 			}
 			return { __isErrorValue: true, __name: v.name || 'Error', __message: v.message || '', __extra: errExtra };
@@ -804,20 +751,48 @@ export class QuickJsBridge {
 		if (v instanceof Map) {
 			var entries = [];
 			v.forEach(function(val, key) {
-				entries.push([wrapSpecialValues(key), wrapSpecialValues(val)]);
+				entries.push([wrapSpecialValues(key, true), wrapSpecialValues(val, true)]);
 			});
 			return { __isMap: true, __entries: entries };
 		}
 		if (v instanceof Set) {
 			var values = [];
 			v.forEach(function(val) {
-				values.push(wrapSpecialValues(val));
+				values.push(wrapSpecialValues(val, true));
 			});
 			return { __isSet: true, __values: values };
 		}
-		if (Array.isArray(v)) return v.map(wrapSpecialValues);
+		if (Array.isArray(v)) return v.map(function(item) { return wrapSpecialValues(item, inCollection); });
 		// Error sentinels are already in transfer shape — leave them intact.
 		if (v.__isError) return v;
+		// Outside a collection, these markers come from __prepareForTransfer above,
+		// so pass them to the host as they are.
+		if (!inCollection) {
+			if (typeof v['${TRANSFER_TYPE_KEY}'] === 'string') return v;
+			if (v['${TRANSFER_ESCAPED_KEY}'] === true) {
+				var payload = v.__value;
+				if (v['${TRANSFER_OPAQUE_KEY}'] === true) {
+					// The host gives an opaque payload back as data, so wrap its contents
+					// as a collection and keep any marker in them as data too.
+					var opaqueWrapper = { __value: wrapOwnKeys(payload, true) };
+					opaqueWrapper['${TRANSFER_ESCAPED_KEY}'] = true;
+					opaqueWrapper['${TRANSFER_OPAQUE_KEY}'] = true;
+					return opaqueWrapper;
+				}
+				if (payload !== null && typeof payload === 'object' && !Array.isArray(payload)) {
+					var walkedWrapper = { __value: wrapOwnKeys(payload, inCollection) };
+					walkedWrapper['${TRANSFER_ESCAPED_KEY}'] = true;
+					return walkedWrapper;
+				}
+				var plainWrapper = { __value: wrapSpecialValues(payload, inCollection) };
+				plainWrapper['${TRANSFER_ESCAPED_KEY}'] = true;
+				return plainWrapper;
+			}
+		}
+		return wrapOwnKeys(v, inCollection);
+	}
+
+	function wrapOwnKeys(v, inCollection) {
 		var result = {};
 		var keys = Object.keys(v);
 		var collides = false;
@@ -829,7 +804,18 @@ export class QuickJsBridge {
 			) {
 				collides = true;
 			}
-			result[key] = wrapSpecialValues(v[key]);
+			// Inside a collection a transfer marker is user data, so escape the object
+			// and the host reads the keys as the plain data they are.
+			if (
+				inCollection && (
+					key === '${TRANSFER_TYPE_KEY}' ||
+					key === '${TRANSFER_ESCAPED_KEY}' ||
+					key === '${TRANSFER_OPAQUE_KEY}'
+				)
+			) {
+				collides = true;
+			}
+			result[key] = wrapSpecialValues(v[key], inCollection);
 		}
 		// User objects whose keys collide with transfer markers are escaped so
 		// the host returns them as plain data (as isolated-vm does) instead of
@@ -1117,7 +1103,7 @@ export class QuickJsBridge {
             execResult.value.dispose();
             const result = unwrapSentinels(rawResult);
             if (isErrorSentinel(result)) {
-                throw this.reconstructError(result);
+                throw reconstructError(result);
             }
             this.logger.debug('[QuickJsBridge] Expression executed successfully');
             return result;
@@ -1156,17 +1142,6 @@ export class QuickJsBridge {
             ? `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');