@n8n/expression-runtime 0.7.0 → 0.9.0

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

@@ -10,6 +10,33 @@ function getIvm() {
     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.
@@ -46,23 +73,13 @@ export class IsolatedVmBridge {
     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 = {
             ...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 });
@@ -96,14 +113,8 @@ export class IsolatedVmBridge {
         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.
@@ -112,7 +123,7 @@ export class IsolatedVmBridge {
      * - 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
@@ -125,20 +136,16 @@ export class IsolatedVmBridge {
             // 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);
@@ -161,19 +168,16 @@ export class IsolatedVmBridge {
         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);
@@ -183,11 +187,22 @@ export class IsolatedVmBridge {
     /**
      * 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
@@ -199,208 +214,203 @@ export class IsolatedVmBridge {
         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 })
@@ -411,35 +421,58 @@ export class IsolatedVmBridge {
         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 TimeoutError(`Expression timed out after ${this.config.timeout}ms`, {});
@@ -449,6 +482,29 @@ export class IsolatedVmBridge {
             }
             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.
@@ -463,16 +519,9 @@ export class IsolatedVmBridge {
         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.
@@ -480,7 +529,7 @@ export class IsolatedVmBridge {
      * @returns true if disposed, false otherwise
      */
     isDisposed() {
-        return this.disposed;
+        return this.disposed || this.isolate.isDisposed;
     }
 }
 //# sourceMappingURL=isolated-vm-bridge.js.map