@n8n/expression-runtime 0.29.1 → 0.31.0

package/dist/cjs/bridge/isolated-vm-bridge.js

@@ -34,11 +34,14 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsolatedVmBridge = void 0;
-const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
 const types_1 = require("../types");
-const bridge_messages_1 = require("./bridge-messages");
+const luxon_transfer_1 = require("../runtime/luxon-transfer");
+const host_functions_1 = require("./host-functions");
 let _ivm = null;
+/** Runtime bundle source, read once per process by loadRuntimeBundle(). */
+let _runtimeBundle = null;
 function getIvm() {
     if (!_ivm) {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -50,33 +53,52 @@ 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;
-/** Check if a value is an error sentinel returned by serializeError. */
-function isErrorSentinel(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        value.__isError === true);
+// V8 compile cache for the runtime bundle (BridgeConfig.compileCache): the
+// first bundle compile produces it, later builds consume it and skip
+// re-parsing. V8 validates the data and recompiles when it is stale.
+let _bundleCachedData = null;
+// The runtime sets Script.cachedData when produceCachedData is passed, but
+// ivm's typings omit the property (CachedDataResult exists unattached).
+function producedCachedData(script) {
+    const data = Reflect.get(script, 'cachedData');
+    return data instanceof getIvm().ExternalCopy ? data : null;
 }
-/**
- * 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 isolate boundary (which
- * strips custom class identity and properties). The isolate-side proxy
- * detects __isError and reconstructs a proper Error to throw.
- */
-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,
-        };
+/** Globals the runtime bundle must define. Verified after every bundle load. */
+const RUNTIME_GLOBALS = [
+    'DateTime',
+    'extend',
+    'createDeepLazyProxy',
+    'SafeObject',
+    'SafeError',
+    'buildContext',
+];
+/** Evaluates inside the isolate to a JSON array of the RUNTIME_GLOBALS that are missing. */
+const MISSING_RUNTIME_GLOBALS_SOURCE = `JSON.stringify(${JSON.stringify(RUNTIME_GLOBALS)}.filter((name) => typeof globalThis[name] === 'undefined'))`;
+function assertRuntimeGlobals(missingJson) {
+    const missing = typeof missingJson === 'string' ? JSON.parse(missingJson) : missingJson;
+    if (Array.isArray(missing) && missing.length > 0) {
+        throw new Error(`Runtime bundle verification failed: missing ${missing.join(', ')}`);
     }
-    return { __isError: true, name: 'Error', message: String(err), extra: {} };
 }
+/**
+ * The E() error handler injected into every isolate; see injectErrorHandler()
+ * for the two exception-handling layers it participates in.
+ */
+const ERROR_HANDLER_SOURCE = `
+	if (typeof E === 'undefined') {
+		globalThis.E = function(error, _context) {
+			// Re-throw ExpressionError / ExpressionExtensionError to match
+			// the legacy handler in expression.ts. Errors from host callbacks
+			// arrive as sentinels (not class instances), so check by name.
+			const name = error?.name;
+			if (name === 'ExpressionError' || name === 'ExpressionExtensionError') {
+				throw error;
+			}
+			// Swallow everything else (TypeErrors, generic Errors, etc.)
+			return undefined;
+		};
+	}
+`;
 /**
  * Read the runtime IIFE bundle by walking up from `__dirname` until
  * `dist/bundle/runtime.iife.js` is found.
@@ -85,11 +107,14 @@ function serializeError(err) {
  *   - `src/bridge/`               (vitest running against source)
  *   - `dist/cjs/bridge/`          (CJS build)
  */
-async function readRuntimeBundle() {
+function loadRuntimeBundle() {
+    if (_runtimeBundle !== null)
+        return _runtimeBundle;
     let dir = __dirname;
     while (dir !== path.dirname(dir)) {
         try {
-            return await (0, promises_1.readFile)(path.join(dir, BUNDLE_RELATIVE_PATH), 'utf-8');
+            _runtimeBundle = (0, node_fs_1.readFileSync)(path.join(dir, BUNDLE_RELATIVE_PATH), 'utf-8');
+            return _runtimeBundle;
         }
         catch { }
         dir = path.dirname(dir);
@@ -149,8 +174,6 @@ class IsolatedVmBridge {
         await jail.set('global', jail.derefInto());
         // Load runtime bundle (DateTime, extend, SafeObject, proxy system)
         await this.loadVendorLibraries();
-        // Verify proxy system loaded correctly
-        await this.verifyProxySystem();
         // Inject E() error handler needed by tournament-generated try-catch code
         await this.injectErrorHandler();
         this.initialized = true;
@@ -174,54 +197,24 @@ class IsolatedVmBridge {
         }
         try {
             // Load runtime bundle (includes vendor libraries + proxy system)
-            const runtimeBundle = await readRuntimeBundle();
+            const runtimeBundle = loadRuntimeBundle();
             // Evaluate bundle in isolate context
             // This makes all exported globals available (DateTime, extend, extendOptional, SafeObject, SafeError, createDeepLazyProxy, buildContext)
-            await this.context.eval(runtimeBundle);
-            this.logger.debug('[IsolatedVmBridge] Runtime bundle loaded');
-            // Verify vendor libraries loaded correctly
-            const hasDateTime = await this.context.eval('typeof DateTime !== "undefined"');
-            const hasExtend = await this.context.eval('typeof extend !== "undefined"');
-            if (!hasDateTime || !hasExtend) {
-                throw new Error(`Library verification failed: DateTime=${hasDateTime}, extend=${hasExtend}`);
+            if (this.config.compileCache) {
+                const script = await this.isolate.compileScript(runtimeBundle, _bundleCachedData ? { cachedData: _bundleCachedData } : { produceCachedData: true });
+                if (!_bundleCachedData)
+                    _bundleCachedData = producedCachedData(script);
+                await script.run(this.context);
             }
-            this.logger.debug('[IsolatedVmBridge] Vendor libraries verified successfully');
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to load runtime bundle: ${errorMessage}`);
-        }
-    }
-    /**
-     * Verify the proxy system loaded correctly.
-     *
-     * The proxy system is loaded as part of the runtime bundle in loadVendorLibraries().
-     * This method verifies all required components are available.
-     *
-     * @private
-     * @throws {Error} If context not initialized or proxy system verification fails
-     */
-    async verifyProxySystem() {
-        if (!this.context) {
-            throw new Error('Context not initialized');
-        }
-        try {
-            // Verify proxy system components loaded correctly
-            const hasProxyCreator = await this.context.eval('typeof createDeepLazyProxy !== "undefined"');
-            const hasSafeObject = await this.context.eval('typeof SafeObject !== "undefined"');
-            const hasSafeError = await this.context.eval('typeof SafeError !== "undefined"');
-            const hasBuildContext = await this.context.eval('typeof buildContext !== "undefined"');
-            if (!hasProxyCreator || !hasSafeObject || !hasSafeError || !hasBuildContext) {
-                throw new Error(`Proxy system verification failed: ` +
-                    `createDeepLazyProxy=${hasProxyCreator}, ` +
-                    `SafeObject=${hasSafeObject}, SafeError=${hasSafeError}, ` +
-                    `buildContext=${hasBuildContext}`);
+            else {
+                await this.context.eval(runtimeBundle);
             }
-            this.logger.debug('[IsolatedVmBridge] Proxy system verified successfully');
+            assertRuntimeGlobals(await this.context.eval(MISSING_RUNTIME_GLOBALS_SOURCE));
+            this.logger.debug('[IsolatedVmBridge] Runtime bundle loaded and verified');
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to verify proxy system: ${errorMessage}`);
+            throw new Error(`Failed to load runtime bundle: ${errorMessage}`);
         }
     }
     /**
@@ -251,204 +244,98 @@ class IsolatedVmBridge {
         if (!this.context) {
             throw new Error('Context not initialized');
         }
-        await this.context.eval(`
-			if (typeof E === 'undefined') {
-				globalThis.E = function(error, _context) {
-					// Re-throw ExpressionError / ExpressionExtensionError to match
-					// the legacy handler in expression.ts. Errors from host callbacks
-					// arrive as sentinels (not class instances), so check by name.
-					const name = error?.name;
-					if (name === 'ExpressionError' || name === 'ExpressionExtensionError') {
-						throw error;
-					}
-					// Swallow everything else (TypeErrors, generic Errors, etc.)
-					return undefined;
-				};
-			}
-		`);
+        await this.context.eval(ERROR_HANDLER_SOURCE);
         this.logger.debug('[IsolatedVmBridge] Error handler injected successfully');
     }
+    /**
+     * Synchronous variant of initialize(): the same steps through isolated-vm's
+     * sync APIs, for on-demand creation inside the synchronous evaluate() path
+     * (lazy acquisition with an exhausted pool). Blocks the event loop for the
+     * duration of one isolate setup — pool warmup should stay on the async
+     * initialize().
+     */
+    initializeSync() {
+        if (this.initialized)
+            return;
+        try {
+            this.context = this.isolate.createContextSync();
+            const jail = this.context.global;
+            jail.setSync('global', jail.derefInto());
+            if (this.config.compileCache) {
+                const script = this.isolate.compileScriptSync(loadRuntimeBundle(), _bundleCachedData ? { cachedData: _bundleCachedData } : { produceCachedData: true });
+                if (!_bundleCachedData)
+                    _bundleCachedData = producedCachedData(script);
+                script.runSync(this.context);
+            }
+            else {
+                this.context.evalSync(loadRuntimeBundle());
+            }
+            assertRuntimeGlobals(this.context.evalSync(MISSING_RUNTIME_GLOBALS_SOURCE));
+            this.context.evalSync(ERROR_HANDLER_SOURCE);
+        }
+        catch (error) {
+            // A failed cold start must not retain the native isolate. dispose()
+            // has no awaits before the isolate is released, so not awaiting it
+            // here is safe.
+            void this.dispose();
+            throw error;
+        }
+        this.initialized = true;
+        this.logger.debug('[IsolatedVmBridge] Initialized synchronously');
+    }
     /**
      * Create an ivm.Callback for getting value/metadata at a path.
      *
-     * Used by createDeepLazyProxy when accessing properties. Returns metadata
-     * markers for arrays and objects, or the primitive value directly.
-     *
-     * Function-typed values are returned as `undefined` — every callable on
-     * the host data surface (`$('Foo').first()`, `$items()`, `$fromAI()`,
-     * `$evaluateExpression()`, `$getPairedItem()`) is wired in-isolate via
-     * the typed-RPC dispatcher (`callHost`). No expression form should
-     * reach a function through this path.
+     * Thin wrapper around the shared getValueAtPath (see host-functions.ts
+     * for navigation and guard semantics); errors are caught and returned
+     * as sentinels instead of crossing the isolate boundary.
      *
      * @param data - Current workflow data to use for callback responses
      * @private
      */
     createGetValueAtPathRef(data) {
-        return new (getIvm().Callback)((path) => {
+        return new (getIvm().Callback)((pathArr) => {
             try {
-                // Navigate to value
-                // Special-case: paths starting with ['$item', index] call data.$item(index)
-                // to get the sub-proxy for that item, then continue navigating the rest.
-                let value = data;
-                let startIndex = 0;
-                const itemFn = data.$item;
-                if (path.length >= 2 && path[0] === '$item' && typeof itemFn === 'function') {
-                    const itemIndex = parseInt(path[1], 10);
-                    if (!isNaN(itemIndex)) {
-                        value = itemFn(itemIndex);
-                        startIndex = 2;
-                    }
-                }
-                else {
-                    const dollarFn = data.$;
-                    if (path.length >= 2 && path[0] === '$' && typeof dollarFn === 'function') {
-                        value = dollarFn(path[1]);
-                        startIndex = 2;
-                    }
-                }
-                for (let i = startIndex; i < path.length; i++) {
-                    value = value?.[path[i]];
-                    if (value === undefined || value === null) {
-                        return value;
-                    }
-                }
-                // Functions are not reachable via the lazy-proxy data path —
-                // every callable on the host data surface routes through the
-                // typed-RPC dispatcher. Return undefined so any residual
-                // access surfaces as missing rather than as a stale metadata
-                // marker the runtime no longer knows how to interpret.
-                if (typeof value === 'function') {
-                    return undefined;
-                }
-                // Handle arrays - always lazy, only transfer length
-                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;
-                }
-                // Handle objects - return metadata with keys
-                if (value !== null && typeof value === 'object') {
-                    return {
-                        __isObject: true,
-                        __keys: Object.keys(value),
-                    };
-                }
-                // Primitive value
-                return value;
+                return (0, host_functions_1.getValueAtPath)(data, pathArr);
             }
             catch (err) {
-                return serializeError(err);
+                return (0, host_functions_1.serializeError)(err);
             }
         });
     }
     /**
      * Create an ivm.Callback for getting array elements at an index.
      *
-     * Used by array proxy when accessing numeric indices.
+     * Thin wrapper around the shared getArrayElement (see host-functions.ts
+     * for navigation and guard semantics); errors are caught and returned
+     * as sentinels instead of crossing the isolate boundary.
      *
      * @param data - Current workflow data to use for callback responses
      * @private
      */
     createGetArrayElementRef(data) {
-        return new (getIvm().Callback)((path, index) => {
+        return new (getIvm().Callback)((pathArr, index) => {
             try {
-                // Navigate to array
-                // Special-case: paths starting with ['$item', index] call data.$item(index)
-                let arr = data;
-                let startIndex = 0;
-                const itemFn = data.$item;
-                if (path.length >= 2 && path[0] === '$item' && typeof itemFn === 'function') {
-                    const itemIndex = parseInt(path[1], 10);
-                    if (!isNaN(itemIndex)) {
-                        arr = itemFn(itemIndex);
-                        startIndex = 2;
-                    }
-                }
-                else {
-                    const dollarFn = data.$;
-                    if (path.length >= 2 && path[0] === '$' && typeof dollarFn === 'function') {
-                        arr = dollarFn(path[1]);
-                        startIndex = 2;
-                    }
-                }
-                for (let i = startIndex; i < path.length; i++) {
-                    arr = arr?.[path[i]];
-                    if (arr === undefined || arr === null) {
-                        return undefined;
-                    }
-                }
-                if (!Array.isArray(arr)) {
-                    return undefined;
-                }
-                // Only genuine array indices are reachable; anything else (e.g.
-                // 'constructor', '__lookupGetter__') would read off the prototype
-                // chain and could leak a host function reference across the boundary.
-                if (!Number.isInteger(index) || index < 0) {
-                    return undefined;
-                }
-                const element = arr[index];
-                // Functions are never reachable through the data surface — mirror the
-                // guard in getValueAtPath so a host callable can't cross the boundary.
-                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 is object/array, return metadata
-                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),
-                    };
-                }
-                // Primitive element
-                return element;
+                return (0, host_functions_1.getArrayElement)(data, pathArr, index);
             }
             catch (err) {
-                return serializeError(err);
+                return (0, host_functions_1.serializeError)(err);
             }
         });
     }
     /**
-     * Create the single typed-RPC dispatcher.
-     *
-     * The isolate sends one envelope per typed RPC invocation:
-     *   `callHost({ type: 'getNodeFirst', nodeName, branchIndex?, runIndex? })`
-     *
-     * Inputs cross a trust boundary, so the dispatcher parses every envelope
-     * with the host-side zod schema (`bridgeMessageSchema`) before any
-     * dispatch happens. Anything that deviates from the declared shape —
-     * unknown `type`, missing required fields, extra unexpected fields,
-     * wrong field types — fails the parse and an error sentinel is returned
-     * to the caller.
+     * Create the ivm.Callback for the typed-RPC `callHost` channel.
      *
-     * After parsing, `switch (msg.type)` dispatches to a private handler with
-     * a fully narrowed message type. The operation set is exactly the cases
-     * in this switch; the `type` field selects a static branch in source,
-     * not a property lookup on a runtime object.
+     * Thin wrapper around the shared dispatchHostCall (see host-functions.ts
+     * for envelope validation and per-message rationale); errors — including
+     * zod parse failures — are caught and returned as sentinels instead of
+     * crossing the isolate boundary.
      *
-     * Return-value note: handlers must return plain, structured-clone-able
-     * data. Results cross into the isolate through an ivm.Callback, which copies
-     * them via the structured-clone algorithm — return JSON-shaped values, not
-     * isolated-vm objects (`Reference`/`ExternalCopy`) or other non-cloneable
-     * values.
+     * Return-value note: the dispatcher returns plain, structured-clone-able
+     * data. Results cross into the isolate through an ivm.Callback, which
+     * copies them via the structured-clone algorithm — JSON-shaped values,
+     * not isolated-vm objects (`Reference`/`ExternalCopy`) or other
+     * non-cloneable values.
      *
      * @param data - Current workflow data
      * @private
@@ -456,183 +343,13 @@ class IsolatedVmBridge {
     createCallHostRef(data) {
         return new (getIvm().Callback)((rawMsg) => {
             try {
-                const msg = bridge_messages_1.bridgeMessageSchema.parse(rawMsg);
-                switch (msg.type) {
-                    case 'getNodeFirst':
-                        return this.handleGetNodeFirst(msg, data);
-                    case 'getNodeLast':
-                        return this.handleGetNodeLast(msg, data);
-                    case 'getNodeAll':
-                        return this.handleGetNodeAll(msg, data);
-                    case 'getInputFirst':
-                        return this.handleGetInputFirst(data);
-                    case 'getInputLast':
-                        return this.handleGetInputLast(data);
-                    case 'getInputAll':
-                        return this.handleGetInputAll(data);
-                    case 'getItems':
-                        return this.handleGetItems(msg, data);
-                    case 'fromAi':
-                        return this.handleFromAi(msg, data);
-                    case 'getNodePairedItem':
-                        return this.handleGetNodePairedItem(msg, data);
-                    case 'getNodeItemMatching':
-                        return this.handleGetNodeItemMatching(msg, data);
-                    case 'getNodeItem':
-                        return this.handleGetNodeItem(msg, data);
-                    case 'evaluateExpression':
-                        return this.handleEvaluateExpression(msg, data);
-                    case 'getPairedItem':
-                        return this.handleGetPairedItem(msg, data);
-                    default: {
-                        // Unreachable at runtime — zod rejects unknown `type` values
-                        // before the switch. The `never` assignment is the compile-time
-                        // guard: a new schema added to `bridgeMessageSchema` without a
-                        // matching case here becomes a type error.
-                        const exhaustive = msg;
-                        void exhaustive;
-                        throw new Error('Unhandled bridge message');
-                    }
-                }
+                return (0, host_functions_1.dispatchHostCall)(rawMsg, data);
             }
             catch (err) {
-                return serializeError(err);
+                return (0, host_functions_1.serializeError)(err);
             }
         });
     }
-    /**
-     * Handlers for the `$('Foo').{first,last,all}` typed RPCs.
-     *
-     * Each handler reads a fixed literal property name off the host-side node
-     * proxy — the isolate cannot influence which property is dereferenced.
-     * Eliminating `data.$` as a host-callable entirely would require reaching
-     * the `WorkflowDataProxy` internals (e.g. `getNodeExecutionOrPinnedData`)
-     * rather than the public `$()` API; that's a follow-up.
-     *
-     * `data.$` is a host-wired function (`WorkflowDataProxy`'s `$`). If it
-     * ever isn't, optional chaining short-circuits to `undefined` — the same
-     * observable result the runtime's `E()` handler produces from any thrown
-     * error here.
-     *
-     * @private
-     */
-    handleGetNodeFirst(msg, data) {
-        return data.$?.(msg.nodeName)?.first?.(msg.branchIndex, msg.runIndex);
-    }
-    handleGetNodeLast(msg, data) {
-        return data.$?.(msg.nodeName)?.last?.(msg.branchIndex, msg.runIndex);
-    }
-    handleGetNodeAll(msg, data) {
-        return data.$?.(msg.nodeName)?.all?.(msg.branchIndex, msg.runIndex);
-    }
-    /**
-     * Handlers for the `$input.{first,last,all}` typed RPCs.
-     *
-     * Each reads a fixed literal property name off `data.$input` (the host's
-     * `WorkflowDataProxy` input proxy). The host enforces zero arguments on
-     * these methods — the schemas have no fields besides `type`, so the
-     * isolate cannot pass anything that would trigger the "should have no
-     * arguments" error path on the host side.
-     *
-     * @private
-     */
-    handleGetInputFirst(data) {
-        return data.$input?.first?.();
-    }
-    handleGetInputLast(data) {
-        return data.$input?.last?.();
-    }
-    handleGetInputAll(data) {
-        return data.$input?.all?.();
-    }
-    /**
-     * Handler for `$items(nodeName?, outputIndex?, runIndex?)` — the
-     * global accessor for a node's execution data. Reads the literal
-     * `$items` property off `data` (host-wired by `WorkflowDataProxy`)
-     * and forwards the validated args verbatim. The host applies its own
-     * defaults when fields are `undefined`.
-     *
-     * @private
-     */
-    handleGetItems(msg, data) {
-        return data.$items?.(msg.nodeName, msg.outputIndex, msg.runIndex);
-    }
-    /**
-     * Handler for `$fromAI(name, description?, type?, defaultValue?)` and its
-     * `$fromAi` / `$fromai` aliases. Reads the literal `$fromAI` property
-     * off `data` (host-wired) and forwards the args. The host validates
-     * `name` (required + regex) and applies its own resolution / fallback
-     * logic, so empty / invalid names surface as the host's structured
-     * `ExpressionError` rather than a generic zod parse error.
-     *
-     * Note: `msg.valueType` maps to the host's third positional parameter
-     * (`_type` in `WorkflowDataProxy.handleFromAi`). The bridge protocol
-     * renames it to avoid collision with the `type` discriminator on the
-     * envelope — the host parameter currently goes unused, but if it ever
-     * gains a name (`type`), this mapping should stay explicit.
-     *
-     * @private
-     */
-    handleFromAi(msg, data) {
-        return data.$fromAI?.(msg.name, msg.description, msg.valueType, msg.defaultValue);
-    }
-    /**
-     * Handlers for the `$('Foo').pairedItem(itemIndex?)` / `.itemMatching(...)` /
-     * `.item` cluster. Three separate typed RPCs, each reading exactly one
-     * literal property off the host node proxy.
-     *
-     * The split is load-bearing: the host's `pairedItemMethod` closure
-     * captures which property name the proxy `get` trap saw, and uses
-     * that to pick the right error message (e.g. "Missing item index for
-     * .itemMatching()") and to decide between method-call vs getter
-     * semantics for `.item`. Reading the matching property here lets
-     * those host-side branches fire exactly as they do in the legacy
-     * engine; no in-isolate validation needed.
-     *
-     * @private
-     */
-    handleGetNodePairedItem(msg, data) {
-        return data.$?.(msg.nodeName)?.pairedItem?.(msg.itemIndex);
-    }
-    handleGetNodeItemMatching(msg, data) {
-        return data.$?.(msg.nodeName)?.itemMatching?.(msg.itemIndex);
-    }
-    handleGetNodeItem(msg, data) {
-        // `.item` is a host getter — accessing it invokes the resolver and
-        // returns the value immediately. Optional chaining only short-
-        // circuits on null/undefined; the getter still fires on access.
-        return data.$?.(msg.nodeName)?.item;
-    }
-    /**
-     * Handler for `$evaluateExpression(expression, itemIndex?)`. Forwards
-     * the string to the host's nested-evaluation helper, which re-enters
-     * the expression engine on the inner expression. Under the VM engine
-     * this round-trips through the bridge again as a new evaluation on the
-     * enclosing call's time budget, which is the same shape the legacy
-     * engine supports.
-     *
-     * @private
-     */
-    handleEvaluateExpression(msg, data) {
-        return data.$evaluateExpression?.(msg.expression, msg.itemIndex);
-    }
-    /**
-     * Handler for `$getPairedItem(destinationNodeName, incomingSourceData,
-     * initialPairedItem)`. Forwards directly to the host binding, which
-     * walks the paired-item ancestry chain back to the named upstream node
-     * and returns the matching execution item.
-     *
-     * The two trailing host parameters — `usedMethodName` and
-     * `nodeBeforeLast` — are deliberately not part of the wire protocol:
-     * the host's default for `usedMethodName` is already `$getPairedItem`,
-     * and `nodeBeforeLast` is an internal recursion argument the host sets
-     * during traversal.
-     *
-     * @private
-     */
-    handleGetPairedItem(msg, data) {
-        return data.$getPairedItem?.(msg.destinationNodeName, msg.incomingSourceData, msg.initialPairedItem);
-    }
     /**
      * Execute JavaScript code in the isolated context.
      *
@@ -721,11 +438,13 @@ try {
   };
 }`;
             const result = this.context.evalClosureSync(wrappedCode, [getValueAtPath, getArrayElement, callHost], { result: { copy: true }, timeout });
-            if (isErrorSentinel(result)) {
-                throw this.reconstructError(result);
+            if ((0, host_functions_1.isErrorSentinel)(result)) {
+                throw (0, host_functions_1.reconstructError)(result);
             }
             this.logger.debug('[IsolatedVmBridge] Expression executed successfully');
-            return result;
+            // The structured clone above drops the prototype of a class instance, so
+            // rebuild the luxon instances from the markers the isolate sent.
+            return (0, luxon_transfer_1.unwrapLuxonValues)(result);
         }
         catch (error) {
             // Re-throw reconstructed errors as-is.
@@ -756,24 +475,6 @@ try {
             ? `Nested expressions timed out after sharing the ${this.config.timeout}ms limit`
             : `Expression timed out after ${this.config.timeout}ms`, {});
     }
-    /**
-     * Reconstruct an error from serialized isolate data.
-     *
-     * Maps error names back to their host-side classes and restores
-     * custom properties that would otherwise be lost crossing the boundary.
-     */
-    reconstructError(data) {
-        const error = new Error(data.message);
-        error.name = data.name || 'Error';
-        if (data.stack) {
-            error.stack = data.stack;
-        }
-        // Restore custom properties transferred via copy: true
-        if (data.extra) {
-            Object.assign(error, data.extra);
-        }
-        return error;
-    }
     /**
      * Dispose of the isolate and free resources.
      *