@n8n/expression-runtime 0.7.0 → 0.9.0

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

@@ -55,6 +55,33 @@ var __importStar = (this && this.__importStar) || (function () {
         return _ivm;
     }
     const BUNDLE_RELATIVE_PATH = path.join('dist', 'bundle', 'runtime.iife.js');
+    /** Check if a value is an error sentinel returned by serializeError. */
+    function isErrorSentinel(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value.__isError === true);
+    }
+    /**
+     * 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,
+            };
+        }
+        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.
@@ -91,23 +118,13 @@ var __importStar = (this && this.__importStar) || (function () {
         initialized = false;
         disposed = false;
         config;
-        // Script compilation cache for performance
-        // Maps expression code -> compiled ivm.Script
-        scriptCache = new Map();
-        // Active ivm.Reference callbacks — released before each re-registration
-        // to prevent reference accumulation across execute() calls
-        valueAtPathRef;
-        arrayElementRef;
-        callFunctionRef;
-        // Pre-resolved reference to resetDataProxies() inside the isolate.
-        // Using applySync on a stored reference avoids the per-call
-        // ScriptCompiler::Compile() cost that evalSync incurs.
-        resetDataProxiesRef;
+        logger;
         constructor(config = {}) {
             this.config = {
                 ...types_1.DEFAULT_BRIDGE_CONFIG,
                 ...config,
             };
+            this.logger = this.config.logger;
             // Create isolate with memory limit
             // Note: memoryLimit is in MB
             this.isolate = new (getIvm().Isolate)({ memoryLimit: this.config.memoryLimit });
@@ -141,14 +158,8 @@ var __importStar = (this && this.__importStar) || (function () {
             await this.verifyProxySystem();
             // Inject E() error handler needed by tournament-generated try-catch code
             await this.injectErrorHandler();
-            // Store a reference to resetDataProxies for efficient per-call invocation
-            this.resetDataProxiesRef = await this.context.global.get('resetDataProxies', {
-                reference: true,
-            });
             this.initialized = true;
-            if (this.config.debug) {
-                console.log('[IsolatedVmBridge] Initialized successfully');
-            }
+            this.logger.info('[IsolatedVmBridge] Initialized successfully');
         }
         /**
          * Load runtime bundle into the isolate.
@@ -157,7 +168,7 @@ var __importStar = (this && this.__importStar) || (function () {
          * - DateTime, extend, extendOptional (expression engine globals)
          * - SafeObject and SafeError wrappers
          * - createDeepLazyProxy function
-         * - __data object initialization
+         * - buildContext function
          *
          * @private
          * @throws {Error} If context not initialized or bundle loading fails
@@ -170,20 +181,16 @@ var __importStar = (this && this.__importStar) || (function () {
                 // Load runtime bundle (includes vendor libraries + proxy system)
                 const runtimeBundle = await readRuntimeBundle();
                 // Evaluate bundle in isolate context
-                // This makes all exported globals available (DateTime, extend, extendOptional, SafeObject, SafeError, createDeepLazyProxy, resetDataProxies, __data)
+                // This makes all exported globals available (DateTime, extend, extendOptional, SafeObject, SafeError, createDeepLazyProxy, buildContext)
                 await this.context.eval(runtimeBundle);
-                if (this.config.debug) {
-                    console.log('[IsolatedVmBridge] Runtime bundle loaded');
-                }
+                this.logger.info('[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.debug) {
-                    console.log('[IsolatedVmBridge] Vendor libraries verified successfully');
-                }
+                this.logger.info('[IsolatedVmBridge] Vendor libraries verified successfully');
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
@@ -206,19 +213,16 @@ var __importStar = (this && this.__importStar) || (function () {
             try {
                 // Verify proxy system components loaded correctly
                 const hasProxyCreator = await this.context.eval('typeof createDeepLazyProxy !== "undefined"');
-                const hasData = await this.context.eval('typeof __data !== "undefined"');
                 const hasSafeObject = await this.context.eval('typeof SafeObject !== "undefined"');
                 const hasSafeError = await this.context.eval('typeof SafeError !== "undefined"');
-                const hasResetFunction = await this.context.eval('typeof resetDataProxies !== "undefined"');
-                if (!hasProxyCreator || !hasData || !hasSafeObject || !hasSafeError || !hasResetFunction) {
+                const hasBuildContext = await this.context.eval('typeof buildContext !== "undefined"');
+                if (!hasProxyCreator || !hasSafeObject || !hasSafeError || !hasBuildContext) {
                     throw new Error(`Proxy system verification failed: ` +
-                        `createDeepLazyProxy=${hasProxyCreator}, __data=${hasData}, ` +
+                        `createDeepLazyProxy=${hasProxyCreator}, ` +
                         `SafeObject=${hasSafeObject}, SafeError=${hasSafeError}, ` +
-                        `resetDataProxies=${hasResetFunction}`);
-                }
-                if (this.config.debug) {
-                    console.log('[IsolatedVmBridge] Proxy system verified successfully');
+                        `buildContext=${hasBuildContext}`);
                 }
+                this.logger.info('[IsolatedVmBridge] Proxy system verified successfully');
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
@@ -228,11 +232,22 @@ var __importStar = (this && this.__importStar) || (function () {
         /**
          * Inject the E() error handler into the isolate context.
          *
-         * Tournament wraps expressions with try-catch that calls E(error, this).
-         * This handler:
-         * - Re-throws security violations from __sanitize
-         * - Swallows TypeErrors (failed attack attempts return undefined)
-         * - Re-throws all other errors
+         * There are two exception-handling layers inside the isolate:
+         *
+         * 1. **Inner layer (this handler, `E()`)** — Tournament wraps each
+         *    expression with try-catch that calls `E(error, this)`. This handler
+         *    must match the legacy engine's behavior (set in expression.ts via
+         *    setErrorHandler):
+         *    - Re-throw ExpressionError / ExpressionExtensionError
+         *    - Swallow everything else (TypeErrors, generic Errors, etc.)
+         *
+         * 2. **Outer layer (`wrappedCode` try-catch in `execute()`)** — Catches
+         *    anything that escaped `E()` (e.g. re-thrown ExpressionErrors) and
+         *    serializes it into a sentinel object so the host can reconstruct it.
+         *
+         * Inside the isolate, errors from host callbacks arrive as sentinel
+         * objects ({ __isError, name, message, ... }) rather than class instances,
+         * so we match by name instead of instanceof.
          *
          * @private
          * @throws {Error} If context not initialized
@@ -244,208 +259,203 @@ var __importStar = (this && this.__importStar) || (function () {
             await this.context.eval(`
 			if (typeof E === 'undefined') {
 				globalThis.E = function(error, _context) {
-					// Re-throw security violations from __sanitize
-					if (error && error.message && error.message.includes('due to security concerns')) {
+					// 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 TypeErrors (failed attack attempts return undefined)
-					if (error instanceof TypeError) {
-						return undefined;
-					}
-					throw error;
+					// Swallow everything else (TypeErrors, generic Errors, etc.)
+					return undefined;
 				};
 			}
 		`);
-            if (this.config.debug) {
-                console.log('[IsolatedVmBridge] Error handler injected successfully');
-            }
+            this.logger.info('[IsolatedVmBridge] Error handler injected successfully');
         }
         /**
-         * Reset data proxies in the isolate context.
+         * Create an ivm.Reference callback for getting value/metadata at a path.
          *
-         * This method should be called before each execute() to:
-         * 1. Clear proxy caches from previous evaluations
-         * 2. Initialize fresh workflow data references
-         * 3. Expose workflow properties to globalThis
-         *
-         * The reset function runs in the isolate and calls back to the host
-         * via ivm.Reference callbacks to fetch workflow data.
+         * Used by createDeepLazyProxy when accessing properties. Returns metadata
+         * markers for functions, arrays, and objects, or the primitive value directly.
          *
+         * @param data - Current workflow data to use for callback responses
          * @private
-         * @throws {Error} If context not initialized or reset fails
          */
-        resetDataProxies(timezone) {
-            if (!this.resetDataProxiesRef) {
-                throw new Error('Context not initialized');
-            }
-            try {
-                this.resetDataProxiesRef.applySync(null, [timezone ?? null], {
-                    arguments: { copy: true },
-                });
-                if (this.config.debug) {
-                    console.log('[IsolatedVmBridge] Data proxies reset successfully');
+        createGetValueAtPathRef(data) {
+            return new (getIvm().Reference)((path) => {
+                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;
+                        }
+                    }
+                    // Handle functions - return metadata marker
+                    if (typeof value === 'function') {
+                        const fnString = value.toString();
+                        // Block native functions for security
+                        if (fnString.includes('[native code]')) {
+                            return undefined;
+                        }
+                        return { __isFunction: true, __name: path[path.length - 1] };
+                    }
+                    // Handle arrays - always lazy, only transfer length
+                    if (Array.isArray(value)) {
+                        return {
+                            __isArray: true,
+                            __length: value.length,
+                            __data: null,
+                        };
+                    }
+                    // Handle objects - return metadata with keys
+                    if (value !== null && typeof value === 'object') {
+                        return {
+                            __isObject: true,
+                            __keys: Object.keys(value),
+                        };
+                    }
+                    // Primitive value
+                    return value;
                 }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new Error(`Failed to reset data proxies: ${errorMessage}`);
-            }
+                catch (err) {
+                    return serializeError(err);
+                }
+            });
         }
         /**
-         * Register callback functions for cross-isolate communication.
-         *
-         * Creates three ivm.Reference callbacks that the runtime bundle uses
-         * to fetch data from the host process:
+         * Create an ivm.Reference callback for getting array elements at an index.
          *
-         * - __getValueAtPath: Returns metadata or primitive for a property path
-         * - __getArrayElement: Returns individual array elements
-         * - __callFunctionAtPath: Executes functions in host context
-         *
-         * These callbacks are called synchronously from isolate proxy traps.
+         * Used by array proxy when accessing numeric indices.
          *
          * @param data - Current workflow data to use for callback responses
          * @private
          */
-        registerCallbacks(data) {
-            if (!this.context) {
-                throw new Error('Context not initialized');
-            }
-            // Callback 1: Get value/metadata at path
-            // Used by createDeepLazyProxy when accessing properties
-            const getValueAtPath = new (getIvm().Reference)((path) => {
-                // 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;
+        createGetArrayElementRef(data) {
+            return new (getIvm().Reference)((path, 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;
+                        }
                     }
-                }
-                for (let i = startIndex; i < path.length; i++) {
-                    value = value?.[path[i]];
-                    if (value === undefined || value === null) {
-                        return value;
+                    else {
+                        const dollarFn = data.$;
+                        if (path.length >= 2 && path[0] === '$' && typeof dollarFn === 'function') {
+                            arr = dollarFn(path[1]);
+                            startIndex = 2;
+                        }
                     }
-                }
-                // Handle functions - return metadata marker
-                if (typeof value === 'function') {
-                    const fnString = value.toString();
-                    // Block native functions for security
-                    if (fnString.includes('[native code]')) {
+                    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;
                     }
-                    return { __isFunction: true, __name: path[path.length - 1] };
-                }
-                // Handle arrays - always lazy, only transfer length
-                if (Array.isArray(value)) {
-                    return {
-                        __isArray: true,
-                        __length: value.length,
-                        __data: null,
-                    };
+                    const element = arr[index];
+                    // 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;
                 }
-                // Handle objects - return metadata with keys
-                if (value !== null && typeof value === 'object') {
-                    return {
-                        __isObject: true,
-                        __keys: Object.keys(value),
-                    };
+                catch (err) {
+                    return serializeError(err);
                 }
-                // Primitive value
-                return value;
             });
-            // Callback 2: Get array element at index
-            // Used by array proxy when accessing numeric indices
-            const getArrayElement = new (getIvm().Reference)((path, index) => {
-                // 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);
+        }
+        /**
+         * Create an ivm.Reference callback for calling functions at a path.
+         *
+         * Used when expressions invoke functions from workflow data.
+         *
+         * @param data - Current workflow data to use for callback responses
+         * @private
+         */
+        createCallFunctionAtPathRef(data) {
+            return new (getIvm().Reference)((path, ...args) => {
+                try {
+                    // Navigate to function, tracking parent to preserve `this` context
+                    let fn = data;
+                    let parent = undefined;
+                    let startIndex = 0;
+                    const dollarFn = data.$;
+                    if (path.length >= 2 && path[0] === '$' && typeof dollarFn === 'function') {
+                        fn = dollarFn(path[1]);
                         startIndex = 2;
                     }
-                }
-                for (let i = startIndex; i < path.length; i++) {
-                    arr = arr?.[path[i]];
-                    if (arr === undefined || arr === null) {
-                        return undefined;
+                    for (let i = startIndex; i < path.length; i++) {
+                        parent = fn;
+                        fn = fn?.[path[i]];
                     }
-                }
-                if (!Array.isArray(arr)) {
-                    return undefined;
-                }
-                const element = arr[index];
-                // 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,
-                        };
+                    if (typeof fn !== 'function') {
+                        throw new Error(`${path.join('.')} is not a function`);
                     }
-                    return {
-                        __isObject: true,
-                        __keys: Object.keys(element),
-                    };
-                }
-                // Primitive element
-                return element;
-            });
-            // Callback 3: Call function at path with arguments
-            // Used when expressions invoke functions from workflow data
-            const callFunctionAtPath = new (getIvm().Reference)((path, ...args) => {
-                // Navigate to function, tracking parent to preserve `this` context
-                let fn = data;
-                let parent = undefined;
-                for (const key of path) {
-                    parent = fn;
-                    fn = fn?.[key];
-                }
-                if (typeof fn !== 'function') {
-                    throw new Error(`${path.join('.')} is not a function`);
+                    // Block native functions for security (same check as getValueAtPath)
+                    if (fn.toString().includes('[native code]')) {
+                        throw new Error(`${path.join('.')} is a native function and cannot be called`);
+                    }
+                    // Execute function with parent as `this` to preserve method context
+                    return fn.call(parent, ...args);
                 }
-                // Block native functions for security (same check as getValueAtPath)
-                if (fn.toString().includes('[native code]')) {
-                    throw new Error(`${path.join('.')} is a native function and cannot be called`);
+                catch (err) {
+                    return serializeError(err);
                 }
-                // Execute function with parent as `this` to preserve method context
-                return fn.call(parent, ...args);
             });
-            // Release previous references before replacing to avoid accumulation
-            this.valueAtPathRef?.release();
-            this.arrayElementRef?.release();
-            this.callFunctionRef?.release();
-            // Store references so they can be released on the next call or on dispose()
-            this.valueAtPathRef = getValueAtPath;
-            this.arrayElementRef = getArrayElement;
-            this.callFunctionRef = callFunctionAtPath;
-            // Register all callbacks in isolate global context
-            this.context.global.setSync('__getValueAtPath', getValueAtPath);
-            this.context.global.setSync('__getArrayElement', getArrayElement);
-            this.context.global.setSync('__callFunctionAtPath', callFunctionAtPath);
-            if (this.config.debug) {
-                console.log('[IsolatedVmBridge] Callbacks registered successfully');
-            }
         }
         /**
          * Execute JavaScript code in the isolated context.
          *
          * Flow:
-         * 1. Register callbacks as ivm.Reference for cross-isolate communication
-         * 2. Call resetDataProxies() to initialize workflow data proxies
-         * 3. Compile script (with caching for performance)
-         * 4. Execute with timeout enforcement
-         * 5. Return result (copied from isolate)
+         * 1. Create three ivm.Reference callbacks scoped to the current data
+         * 2. Use evalClosureSync to run the code in a closure where $0/$1/$2
+         *    are the callback references — no global mutable state
+         * 3. buildContext() inside the isolate creates a fresh evaluation context
+         *    from the closure-scoped references
+         *
+         * Each call gets its own closure, so nested and concurrent evaluations
+         * cannot interfere with each other.
          *
          * @param code - JavaScript expression to evaluate
          * @param data - Workflow data (e.g., { $json: {...}, $runIndex: 0 })
@@ -456,35 +466,58 @@ var __importStar = (this && this.__importStar) || (function () {
             if (!this.initialized || !this.context) {
                 throw new Error('Bridge not initialized. Call initialize() first.');
             }
+            const getValueAtPath = this.createGetValueAtPathRef(data);
+            const getArrayElement = this.createGetArrayElementRef(data);
+            const callFunctionAtPath = this.createCallFunctionAtPathRef(data);
             try {
-                // Step 1: Register callbacks with current data context
-                this.registerCallbacks(data);
-                // Step 2: Reset proxies for this evaluation
-                // This initializes $json, $binary, etc. as lazy proxies
-                this.resetDataProxies(options?.timezone);
-                // Step 3: Wrap transformed code so 'this' === __data in the isolate.
+                const timezone = options?.timezone ? JSON.stringify(options.timezone) : 'undefined';
+                // Wrap transformed code so 'this' === the closure-scoped context.
                 // Tournament generates: this.$json.email, this.$items(), etc.
-                // __data has $json, $items, etc. as lazy proxies (set in resetDataProxies).
-                const wrappedCode = `(function() { var __result = (function() {\n${code}\n}).call(__data); return __prepareForTransfer(__result); })()`;
-                let script = this.scriptCache.get(code);
-                if (!script) {
-                    script = this.isolate.compileScriptSync(wrappedCode);
-                    this.scriptCache.set(code, script);
-                    if (this.config.debug) {
-                        console.log('[IsolatedVmBridge] Script compiled and cached');
-                    }
-                }
-                // Step 4: Execute with timeout and copy result back
-                const result = script.runSync(this.context, {
-                    timeout: this.config.timeout,
-                    copy: true,
-                });
-                if (this.config.debug) {
-                    console.log('[IsolatedVmBridge] Expression executed successfully');
+                // buildContext() creates a fresh context with lazy proxies from the
+                // closure-scoped callback references ($0, $1, $2) — no globals touched.
+                // The outer try-catch serializes errors into a sentinel object and returns
+                // it as the result. Errors from host callbacks arrive as sentinels already
+                // (via serializeError), so we pass them through. This avoids a round-trip
+                // callback and keeps Error reconstruction on the host side only.
+                const wrappedCode = `
+var __ctx = buildContext($0, $1, $2, ${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 result = this.context.evalClosureSync(wrappedCode, [getValueAtPath, getArrayElement, callFunctionAtPath], { result: { copy: true }, timeout: this.config.timeout });
+                if (isErrorSentinel(result)) {
+                    throw this.reconstructError(result);
                 }
+                this.logger.debug('[IsolatedVmBridge] Expression executed successfully');
                 return result;
             }
             catch (error) {
+                // Re-throw reconstructed errors as-is.
+                // Note: TypeError is intentionally NOT included here — the isolate's
+                // E() handler swallows TypeErrors (failed attack attempts return undefined),
+                // so TypeErrors from host callbacks should also go through the generic
+                // wrapping for consistent behavior.
+                if (error instanceof Error &&
+                    (error.name === 'ExpressionError' || error.name === 'ExpressionExtensionError')) {
+                    throw error;
+                }
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 if (errorMessage.includes('Script execution timed out')) {
                     throw new types_1.TimeoutError(`Expression timed out after ${this.config.timeout}ms`, {});
@@ -494,6 +527,29 @@ var __importStar = (this && this.__importStar) || (function () {
                 }
                 throw new Error(`Expression evaluation failed: ${errorMessage}`);
             }
+            finally {
+                getValueAtPath.release();
+                getArrayElement.release();
+                callFunctionAtPath.release();
+            }
+        }
+        /**
+         * 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.
@@ -508,16 +564,9 @@ var __importStar = (this && this.__importStar) || (function () {
             if (!this.isolate.isDisposed) {
                 this.isolate.dispose();
             }
-            // Release callback references
-            this.valueAtPathRef?.release();
-            this.arrayElementRef?.release();
-            this.callFunctionRef?.release();
             this.disposed = true;
             this.initialized = false;
-            this.scriptCache.clear();
-            if (this.config.debug) {
-                console.log('[IsolatedVmBridge] Disposed');
-            }
+            this.logger.info('[IsolatedVmBridge] Disposed');
         }
         /**
          * Check if the bridge has been disposed.
@@ -525,7 +574,7 @@ var __importStar = (this && this.__importStar) || (function () {
          * @returns true if disposed, false otherwise
          */
         isDisposed() {
-            return this.disposed;
+            return this.disposed || this.isolate.isDisposed;
         }
     }
     exports.IsolatedVmBridge = IsolatedVmBridge;