n8n-workflow 2.31.3 → 2.32.1

package/dist/cjs/expression-sandboxing.js

@@ -1,485 +1,475 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "@n8n/tournament", "./errors", "./utils"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.sanitizer = exports.PrototypeSanitizer = exports.DollarSignValidator = exports.ThisSanitizer = exports.DOLLAR_SIGN_ERROR = exports.sanitizerName = void 0;
-    const tournament_1 = require("@n8n/tournament");
-    const errors_1 = require("./errors");
-    const utils_1 = require("./utils");
-    exports.sanitizerName = '__sanitize';
-    const sanitizerIdentifier = tournament_1.astBuilders.identifier(exports.sanitizerName);
-    const DATA_NODE_NAME = '___n8n_data';
-    const RESERVED_VARIABLE_NAMES = new Set([DATA_NODE_NAME, exports.sanitizerName]);
-    const isAstNode = (value) => typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string';
-    const getBoundIdentifiers = (node, acc = []) => {
-        if (!isAstNode(node))
-            return acc;
-        switch (node.type) {
-            case 'Identifier': {
-                if (typeof node.name === 'string')
-                    acc.push(node.name);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizer = exports.PrototypeSanitizer = exports.DollarSignValidator = exports.ThisSanitizer = exports.DOLLAR_SIGN_ERROR = exports.sanitizerName = void 0;
+const tournament_1 = require("@n8n/tournament");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+exports.sanitizerName = '__sanitize';
+const sanitizerIdentifier = tournament_1.astBuilders.identifier(exports.sanitizerName);
+const DATA_NODE_NAME = '___n8n_data';
+const RESERVED_VARIABLE_NAMES = new Set([DATA_NODE_NAME, exports.sanitizerName]);
+const isAstNode = (value) => typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string';
+const getBoundIdentifiers = (node, acc = []) => {
+    if (!isAstNode(node))
+        return acc;
+    switch (node.type) {
+        case 'Identifier': {
+            if (typeof node.name === 'string')
+                acc.push(node.name);
+            break;
+        }
+        case 'ObjectPattern': {
+            if (!Array.isArray(node.properties))
                 break;
-            }
-            case 'ObjectPattern': {
-                if (!Array.isArray(node.properties))
-                    break;
-                for (const property of node.properties) {
-                    if (!isAstNode(property))
-                        continue;
-                    if (property.type === 'Property') {
-                        getBoundIdentifiers(property.value, acc);
-                    }
-                    else if (property.type === 'RestElement') {
-                        getBoundIdentifiers(property.argument, acc);
-                    }
+            for (const property of node.properties) {
+                if (!isAstNode(property))
+                    continue;
+                if (property.type === 'Property') {
+                    getBoundIdentifiers(property.value, acc);
                 }
-                break;
-            }
-            case 'ArrayPattern': {
-                if (!Array.isArray(node.elements))
-                    break;
-                for (const element of node.elements) {
-                    getBoundIdentifiers(element, acc);
+                else if (property.type === 'RestElement') {
+                    getBoundIdentifiers(property.argument, acc);
                 }
-                break;
-            }
-            case 'AssignmentPattern': {
-                getBoundIdentifiers(node.left, acc);
-                break;
             }
-            case 'RestElement': {
-                getBoundIdentifiers(node.argument, acc);
+            break;
+        }
+        case 'ArrayPattern': {
+            if (!Array.isArray(node.elements))
                 break;
+            for (const element of node.elements) {
+                getBoundIdentifiers(element, acc);
             }
-            case 'VariableDeclaration': {
-                if (!Array.isArray(node.declarations))
-                    break;
-                for (const declaration of node.declarations) {
-                    if (!isAstNode(declaration) || declaration.type !== 'VariableDeclarator')
-                        continue;
-                    getBoundIdentifiers(declaration.id, acc);
-                }
+            break;
+        }
+        case 'AssignmentPattern': {
+            getBoundIdentifiers(node.left, acc);
+            break;
+        }
+        case 'RestElement': {
+            getBoundIdentifiers(node.argument, acc);
+            break;
+        }
+        case 'VariableDeclaration': {
+            if (!Array.isArray(node.declarations))
                 break;
+            for (const declaration of node.declarations) {
+                if (!isAstNode(declaration) || declaration.type !== 'VariableDeclarator')
+                    continue;
+                getBoundIdentifiers(declaration.id, acc);
             }
+            break;
         }
-        return acc;
-    };
-    const getReservedIdentifier = (node) => getBoundIdentifiers(node).find((name) => RESERVED_VARIABLE_NAMES.has(name));
-    exports.DOLLAR_SIGN_ERROR = 'Cannot access "$" without calling it as a function';
-    const EMPTY_CONTEXT = tournament_1.astBuilders.objectExpression([
-        tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('process'), tournament_1.astBuilders.objectExpression([])),
-        tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('require'), tournament_1.astBuilders.objectExpression([])),
-        tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('module'), tournament_1.astBuilders.objectExpression([])),
-        tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('Buffer'), tournament_1.astBuilders.objectExpression([])),
-    ]);
-    const SAFE_GLOBAL = tournament_1.astBuilders.objectExpression([]);
-    const SAFE_THIS = tournament_1.astBuilders.sequenceExpression([tournament_1.astBuilders.literal(0), EMPTY_CONTEXT]);
-    /**
-     * Helper to check if an expression is a valid property access with $ as the property.
-     * Returns true for obj.$ or obj.nested.$ but false for bare $ or other expression contexts.
-     */
-    const isValidDollarPropertyAccess = (expr) => {
-        if (typeof expr !== 'object' ||
-            expr === null ||
-            !('type' in expr) ||
-            expr.type !== 'MemberExpression' ||
-            !('property' in expr) ||
-            !('object' in expr)) {
-            return false;
-        }
-        const property = expr.property;
-        const object = expr.object;
-        // $ must be the property
-        const isPropertyDollar = typeof property === 'object' &&
-            property !== null &&
-            'name' in property &&
-            property.name === '$';
-        // $ must NOT be the object (to block $.something)
-        const isObjectDollar = typeof object === 'object' && object !== null && 'name' in object && object.name === '$';
-        // Object must be an Identifier (obj) or MemberExpression (obj.nested)
-        // This excludes bare $ or $ in other expression contexts
-        const isObjectValid = typeof object === 'object' &&
-            object !== null &&
-            'type' in object &&
-            (object.type === 'Identifier' || object.type === 'MemberExpression');
-        return isPropertyDollar && !isObjectDollar && isObjectValid;
-    };
-    const GLOBAL_IDENTIFIERS = new Set(['globalThis']);
-    const BLOCKED_SPREAD_GLOBALS = new Set(['process', 'global', 'globalThis', 'Buffer']);
-    /**
-     * Prevents regular functions from binding their `this` to the Node.js global.
-     */
-    const ThisSanitizer = (ast, dataNode) => {
-        (0, tournament_1.astVisit)(ast, {
-            visitCallExpression(path) {
-                const { node } = path;
-                if (node.callee.type !== 'FunctionExpression') {
-                    this.traverse(path);
-                    return;
-                }
-                const fnExpression = node.callee;
-                /**
-                 * Called function expressions (IIFEs) - both anonymous and named:
-                 *
-                 * ```js
-                 * (function(x) { return x * 2; })(5)
-                 * (function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); })(5)
-                 *
-                 * // become
-                 *
-                 * (function(x) { return x * 2; }).call({ process: {} }, 5)
-                 * (function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); }).call({ process: {} }, 5)
-                 * ```
-                 */
-                this.traverse(path); // depth first to transform inside out
-                const callExpression = tournament_1.astBuilders.callExpression(tournament_1.astBuilders.memberExpression(fnExpression, tournament_1.astBuilders.identifier('call')), [EMPTY_CONTEXT, ...node.arguments]);
-                path.replace(callExpression);
-                return false;
-            },
-            visitFunctionExpression(path) {
-                const { node } = path;
-                /**
-                 * Callable function expressions (callbacks) - both anonymous and named:
-                 *
-                 * ```js
-                 * [1, 2, 3].map(function(n) { return n * 2; })
-                 * [1, 2, 3].map(function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); })
-                 *
-                 * // become
-                 *
-                 * [1, 2, 3].map((function(n) { return n * 2; }).bind({ process: {} }))
-                 * [1, 2, 3].map((function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); }).bind({ process: {} }))
-                 * ```
-                 */
-                this.traverse(path);
-                const boundFunction = tournament_1.astBuilders.callExpression(tournament_1.astBuilders.memberExpression(node, tournament_1.astBuilders.identifier('bind')), [
-                    EMPTY_CONTEXT,
-                ]);
-                path.replace(boundFunction);
-                return false;
-            },
-            visitIdentifier(path) {
-                this.traverse(path);
-                const { node } = path;
-                if (GLOBAL_IDENTIFIERS.has(node.name)) {
-                    const parent = path.parent;
-                    const isPropertyName = typeof parent === 'object' &&
-                        parent !== null &&
-                        'name' in parent &&
-                        parent.name === 'property';
-                    if (!isPropertyName)
-                        path.replace(SAFE_GLOBAL);
-                }
-            },
-            visitThisExpression(path) {
-                this.traverse(path);
-                /**
-                 * Replace `this` with a safe context object.
-                 * This prevents arrow functions from accessing the real global context:
-                 *
-                 * ```js
-                 * (() => this?.process)()  // becomes (() => (0, { process: {} })?.process)()
-                 * ```
-                 *
-                 * Arrow functions don't have their own `this` binding - they inherit from
-                 * the outer lexical scope. Without this fix, `this` inside an arrow function
-                 * would resolve to the Node.js global object, exposing process.env and other
-                 * sensitive data.
-                 *
-                 * We use SAFE_THIS (a sequence expression) instead of EMPTY_CONTEXT directly
-                 * to ensure the object literal is unambiguously parsed as an expression.
-                 */
-                path.replace(SAFE_THIS);
-            },
-        });
-    };
-    exports.ThisSanitizer = ThisSanitizer;
-    /**
-     * Validates that the $ identifier is only used in allowed contexts.
-     * This prevents user errors like `{{ $ }}` which would return the function object itself.
-     *
-     * Allowed contexts:
-     * - As a function call: $()
-     * - As a property name: obj.$ (where $ is a valid property name in JavaScript)
-     *
-     * Disallowed contexts:
-     * - Bare identifier: $
-     * - As object in member expression: $.property
-     * - In expressions: "prefix" + $, [1, 2, $], etc.
-     */
-    const DollarSignValidator = (ast, _dataNode) => {
-        (0, tournament_1.astVisit)(ast, {
-            visitIdentifier(path) {
+    }
+    return acc;
+};
+const getReservedIdentifier = (node) => getBoundIdentifiers(node).find((name) => RESERVED_VARIABLE_NAMES.has(name));
+exports.DOLLAR_SIGN_ERROR = 'Cannot access "$" without calling it as a function';
+const EMPTY_CONTEXT = tournament_1.astBuilders.objectExpression([
+    tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('process'), tournament_1.astBuilders.objectExpression([])),
+    tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('require'), tournament_1.astBuilders.objectExpression([])),
+    tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('module'), tournament_1.astBuilders.objectExpression([])),
+    tournament_1.astBuilders.property('init', tournament_1.astBuilders.identifier('Buffer'), tournament_1.astBuilders.objectExpression([])),
+]);
+const SAFE_GLOBAL = tournament_1.astBuilders.objectExpression([]);
+const SAFE_THIS = tournament_1.astBuilders.sequenceExpression([tournament_1.astBuilders.literal(0), EMPTY_CONTEXT]);
+/**
+ * Helper to check if an expression is a valid property access with $ as the property.
+ * Returns true for obj.$ or obj.nested.$ but false for bare $ or other expression contexts.
+ */
+const isValidDollarPropertyAccess = (expr) => {
+    if (typeof expr !== 'object' ||
+        expr === null ||
+        !('type' in expr) ||
+        expr.type !== 'MemberExpression' ||
+        !('property' in expr) ||
+        !('object' in expr)) {
+        return false;
+    }
+    const property = expr.property;
+    const object = expr.object;
+    // $ must be the property
+    const isPropertyDollar = typeof property === 'object' &&
+        property !== null &&
+        'name' in property &&
+        property.name === '$';
+    // $ must NOT be the object (to block $.something)
+    const isObjectDollar = typeof object === 'object' && object !== null && 'name' in object && object.name === '$';
+    // Object must be an Identifier (obj) or MemberExpression (obj.nested)
+    // This excludes bare $ or $ in other expression contexts
+    const isObjectValid = typeof object === 'object' &&
+        object !== null &&
+        'type' in object &&
+        (object.type === 'Identifier' || object.type === 'MemberExpression');
+    return isPropertyDollar && !isObjectDollar && isObjectValid;
+};
+const GLOBAL_IDENTIFIERS = new Set(['globalThis']);
+const BLOCKED_SPREAD_GLOBALS = new Set(['process', 'global', 'globalThis', 'Buffer']);
+/**
+ * Prevents regular functions from binding their `this` to the Node.js global.
+ */
+const ThisSanitizer = (ast, dataNode) => {
+    (0, tournament_1.astVisit)(ast, {
+        visitCallExpression(path) {
+            const { node } = path;
+            if (node.callee.type !== 'FunctionExpression') {
                 this.traverse(path);
-                const node = path.node;
-                // Only check for the exact identifier '$'
-                if (node.name !== '$')
-                    return;
-                // Runtime type checking since path properties are typed as 'any'
+                return;
+            }
+            const fnExpression = node.callee;
+            /**
+             * Called function expressions (IIFEs) - both anonymous and named:
+             *
+             * ```js
+             * (function(x) { return x * 2; })(5)
+             * (function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); })(5)
+             *
+             * // become
+             *
+             * (function(x) { return x * 2; }).call({ process: {} }, 5)
+             * (function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); }).call({ process: {} }, 5)
+             * ```
+             */
+            this.traverse(path); // depth first to transform inside out
+            const callExpression = tournament_1.astBuilders.callExpression(tournament_1.astBuilders.memberExpression(fnExpression, tournament_1.astBuilders.identifier('call')), [EMPTY_CONTEXT, ...node.arguments]);
+            path.replace(callExpression);
+            return false;
+        },
+        visitFunctionExpression(path) {
+            const { node } = path;
+            /**
+             * Callable function expressions (callbacks) - both anonymous and named:
+             *
+             * ```js
+             * [1, 2, 3].map(function(n) { return n * 2; })
+             * [1, 2, 3].map(function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); })
+             *
+             * // become
+             *
+             * [1, 2, 3].map((function(n) { return n * 2; }).bind({ process: {} }))
+             * [1, 2, 3].map((function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); }).bind({ process: {} }))
+             * ```
+             */
+            this.traverse(path);
+            const boundFunction = tournament_1.astBuilders.callExpression(tournament_1.astBuilders.memberExpression(node, tournament_1.astBuilders.identifier('bind')), [
+                EMPTY_CONTEXT,
+            ]);
+            path.replace(boundFunction);
+            return false;
+        },
+        visitIdentifier(path) {
+            this.traverse(path);
+            const { node } = path;
+            if (GLOBAL_IDENTIFIERS.has(node.name)) {
                 const parent = path.parent;
-                // Check if parent is a path object with a 'name' property
-                if (typeof parent !== 'object' || parent === null || !('name' in parent)) {
-                    throw new errors_1.ExpressionError(exports.DOLLAR_SIGN_ERROR);
-                }
-                // Allow $ when it's the callee: $()
-                // parent.name === 'callee' means the parent path represents the callee field
-                if (parent.name === 'callee') {
-                    return;
-                }
-                // Block when $ is the object in a MemberExpression: $.something
-                // parent.name === 'object' means the parent path represents the object field
-                if (parent.name === 'object') {
-                    throw new errors_1.ExpressionError(exports.DOLLAR_SIGN_ERROR);
-                }
-                // Check if $ is the property of a MemberExpression: obj.$
-                // For obj.$: parent.name is 'expression' and grandparent has ExpressionStatement
-                // The ExpressionStatement should contain a MemberExpression with $ as property
-                if ('parent' in parent && typeof parent.parent === 'object' && parent.parent !== null) {
-                    const grandparent = parent.parent;
-                    if ('value' in grandparent &&
-                        typeof grandparent.value === 'object' &&
-                        grandparent.value !== null) {
-                        const gpNode = grandparent.value;
-                        // ExpressionStatement has an 'expression' field containing the actual expression
-                        if ('type' in gpNode && gpNode.type === 'ExpressionStatement' && 'expression' in gpNode) {
-                            // Check if this is a valid property access like obj.$
-                            if (isValidDollarPropertyAccess(gpNode.expression)) {
-                                return;
-                            }
+                const isPropertyName = typeof parent === 'object' &&
+                    parent !== null &&
+                    'name' in parent &&
+                    parent.name === 'property';
+                if (!isPropertyName)
+                    path.replace(SAFE_GLOBAL);
+            }
+        },
+        visitThisExpression(path) {
+            this.traverse(path);
+            /**
+             * Replace `this` with a safe context object.
+             * This prevents arrow functions from accessing the real global context:
+             *
+             * ```js
+             * (() => this?.process)()  // becomes (() => (0, { process: {} })?.process)()
+             * ```
+             *
+             * Arrow functions don't have their own `this` binding - they inherit from
+             * the outer lexical scope. Without this fix, `this` inside an arrow function
+             * would resolve to the Node.js global object, exposing process.env and other
+             * sensitive data.
+             *
+             * We use SAFE_THIS (a sequence expression) instead of EMPTY_CONTEXT directly
+             * to ensure the object literal is unambiguously parsed as an expression.
+             */
+            path.replace(SAFE_THIS);
+        },
+    });
+};
+exports.ThisSanitizer = ThisSanitizer;
+/**
+ * Validates that the $ identifier is only used in allowed contexts.
+ * This prevents user errors like `{{ $ }}` which would return the function object itself.
+ *
+ * Allowed contexts:
+ * - As a function call: $()
+ * - As a property name: obj.$ (where $ is a valid property name in JavaScript)
+ *
+ * Disallowed contexts:
+ * - Bare identifier: $
+ * - As object in member expression: $.property
+ * - In expressions: "prefix" + $, [1, 2, $], etc.
+ */
+const DollarSignValidator = (ast, _dataNode) => {
+    (0, tournament_1.astVisit)(ast, {
+        visitIdentifier(path) {
+            this.traverse(path);
+            const node = path.node;
+            // Only check for the exact identifier '$'
+            if (node.name !== '$')
+                return;
+            // Runtime type checking since path properties are typed as 'any'
+            const parent = path.parent;
+            // Check if parent is a path object with a 'name' property
+            if (typeof parent !== 'object' || parent === null || !('name' in parent)) {
+                throw new errors_1.ExpressionError(exports.DOLLAR_SIGN_ERROR);
+            }
+            // Allow $ when it's the callee: $()
+            // parent.name === 'callee' means the parent path represents the callee field
+            if (parent.name === 'callee') {
+                return;
+            }
+            // Block when $ is the object in a MemberExpression: $.something
+            // parent.name === 'object' means the parent path represents the object field
+            if (parent.name === 'object') {
+                throw new errors_1.ExpressionError(exports.DOLLAR_SIGN_ERROR);
+            }
+            // Check if $ is the property of a MemberExpression: obj.$
+            // For obj.$: parent.name is 'expression' and grandparent has ExpressionStatement
+            // The ExpressionStatement should contain a MemberExpression with $ as property
+            if ('parent' in parent && typeof parent.parent === 'object' && parent.parent !== null) {
+                const grandparent = parent.parent;
+                if ('value' in grandparent &&
+                    typeof grandparent.value === 'object' &&
+                    grandparent.value !== null) {
+                    const gpNode = grandparent.value;
+                    // ExpressionStatement has an 'expression' field containing the actual expression
+                    if ('type' in gpNode && gpNode.type === 'ExpressionStatement' && 'expression' in gpNode) {
+                        // Check if this is a valid property access like obj.$
+                        if (isValidDollarPropertyAccess(gpNode.expression)) {
+                            return;
                         }
                     }
                 }
-                // Disallow all other cases (bare $, $ in expressions, etc.)
-                throw new errors_1.ExpressionError(exports.DOLLAR_SIGN_ERROR);
-            },
-        });
-    };
-    exports.DollarSignValidator = DollarSignValidator;
-    const blockedBaseClasses = new Set([
-        'Function',
-        'GeneratorFunction',
-        'AsyncFunction',
-        'AsyncGeneratorFunction',
-    ]);
-    /**
-     * Builds an AST node that safely resolves a spread argument like `...process`.
-     *
-     * Tournament's VariablePolyfill rewrites plain identifiers (e.g. `process`)
-     * to look them up from the data context, but it does NOT handle identifiers
-     * inside SpreadElement / SpreadProperty nodes. Without this fix, `{...process}`
-     * would resolve to the real Node.js `process` object.
-     *
-     * The generated code checks the data context first, falling back to a throw:
-     *
-     *   ("process" in data) ? data.process : (() => { throw new Error("...") })()
-     *
-     * - If the workflow has a variable called "process" → spread that (safe, user-defined)
-     * - Otherwise → throw at runtime, blocking access to the real global
-     */
-    const buildSafeSpreadArg = (name, dataNode) => {
-        // "process" in ___n8n_data
-        const isInDataContext = tournament_1.astBuilders.binaryExpression('in', tournament_1.astBuilders.literal(name), dataNode);
-        // ___n8n_data.process
-        const readFromDataContext = tournament_1.astBuilders.memberExpression(dataNode, tournament_1.astBuilders.identifier(name));
-        // (() => { throw new Error('Cannot spread "process" ...') })()
-        //
-        // This is an IIFE because `throw` is a statement, not an expression,
-        // so it cannot appear directly inside a ternary's falsy branch.
-        const throwSecurityError = tournament_1.astBuilders.callExpression(tournament_1.astBuilders.arrowFunctionExpression([], tournament_1.astBuilders.blockStatement([
-            tournament_1.astBuilders.throwStatement(tournament_1.astBuilders.newExpression(tournament_1.astBuilders.identifier('Error'), [
-                tournament_1.astBuilders.literal(`Cannot spread "${name}" due to security concerns`),
-            ])),
-        ])), []);
-        // Full result:
-        //   ("process" in ___n8n_data) ? ___n8n_data.process : (() => { throw ... })()
-        return tournament_1.astBuilders.conditionalExpression(isInDataContext, readFromDataContext, throwSecurityError);
-    };
-    const PrototypeSanitizer = (ast, dataNode) => {
-        (0, tournament_1.astVisit)(ast, {
-            visitVariableDeclarator(path) {
-                this.traverse(path);
-                const node = path.node;
-                const reservedIdentifier = getReservedIdentifier(node.id);
-                if (reservedIdentifier === undefined)
-                    return;
-                throw new errors_1.ExpressionReservedVariableError(reservedIdentifier);
-            },
-            visitFunction(path) {
-                this.traverse(path);
-                const node = path.node;
-                const functionName = getReservedIdentifier(node.id);
-                if (functionName !== undefined) {
-                    throw new errors_1.ExpressionReservedVariableError(functionName);
+            }
+            // Disallow all other cases (bare $, $ in expressions, etc.)
+            throw new errors_1.ExpressionError(exports.DOLLAR_SIGN_ERROR);
+        },
+    });
+};
+exports.DollarSignValidator = DollarSignValidator;
+const blockedBaseClasses = new Set([
+    'Function',
+    'GeneratorFunction',
+    'AsyncFunction',
+    'AsyncGeneratorFunction',
+]);
+/**
+ * Builds an AST node that safely resolves a spread argument like `...process`.
+ *
+ * Tournament's VariablePolyfill rewrites plain identifiers (e.g. `process`)
+ * to look them up from the data context, but it does NOT handle identifiers
+ * inside SpreadElement / SpreadProperty nodes. Without this fix, `{...process}`
+ * would resolve to the real Node.js `process` object.
+ *
+ * The generated code checks the data context first, falling back to a throw:
+ *
+ *   ("process" in data) ? data.process : (() => { throw new Error("...") })()
+ *
+ * - If the workflow has a variable called "process" → spread that (safe, user-defined)
+ * - Otherwise → throw at runtime, blocking access to the real global
+ */
+const buildSafeSpreadArg = (name, dataNode) => {
+    // "process" in ___n8n_data
+    const isInDataContext = tournament_1.astBuilders.binaryExpression('in', tournament_1.astBuilders.literal(name), dataNode);
+    // ___n8n_data.process
+    const readFromDataContext = tournament_1.astBuilders.memberExpression(dataNode, tournament_1.astBuilders.identifier(name));
+    // (() => { throw new Error('Cannot spread "process" ...') })()
+    //
+    // This is an IIFE because `throw` is a statement, not an expression,
+    // so it cannot appear directly inside a ternary's falsy branch.
+    const throwSecurityError = tournament_1.astBuilders.callExpression(tournament_1.astBuilders.arrowFunctionExpression([], tournament_1.astBuilders.blockStatement([
+        tournament_1.astBuilders.throwStatement(tournament_1.astBuilders.newExpression(tournament_1.astBuilders.identifier('Error'), [
+            tournament_1.astBuilders.literal(`Cannot spread "${name}" due to security concerns`),
+        ])),
+    ])), []);
+    // Full result:
+    //   ("process" in ___n8n_data) ? ___n8n_data.process : (() => { throw ... })()
+    return tournament_1.astBuilders.conditionalExpression(isInDataContext, readFromDataContext, throwSecurityError);
+};
+const PrototypeSanitizer = (ast, dataNode) => {
+    (0, tournament_1.astVisit)(ast, {
+        visitVariableDeclarator(path) {
+            this.traverse(path);
+            const node = path.node;
+            const reservedIdentifier = getReservedIdentifier(node.id);
+            if (reservedIdentifier === undefined)
+                return;
+            throw new errors_1.ExpressionReservedVariableError(reservedIdentifier);
+        },
+        visitFunction(path) {
+            this.traverse(path);
+            const node = path.node;
+            const functionName = getReservedIdentifier(node.id);
+            if (functionName !== undefined) {
+                throw new errors_1.ExpressionReservedVariableError(functionName);
+            }
+            for (const param of node.params) {
+                const paramName = getReservedIdentifier(param);
+                if (paramName !== undefined) {
+                    throw new errors_1.ExpressionReservedVariableError(paramName);
                 }
-                for (const param of node.params) {
-                    const paramName = getReservedIdentifier(param);
-                    if (paramName !== undefined) {
-                        throw new errors_1.ExpressionReservedVariableError(paramName);
+            }
+        },
+        visitCatchClause(path) {
+            this.traverse(path);
+            const node = path.node;
+            const catchParamName = getReservedIdentifier(node.param);
+            if (catchParamName === undefined)
+                return;
+            throw new errors_1.ExpressionReservedVariableError(catchParamName);
+        },
+        visitClassDeclaration(path) {
+            this.traverse(path);
+            const node = path.node;
+            const className = getReservedIdentifier(node.id);
+            if (className !== undefined) {
+                throw new errors_1.ExpressionReservedVariableError(className);
+            }
+            if (node.superClass) {
+                if (node.superClass.type === 'Identifier') {
+                    if (blockedBaseClasses.has(node.superClass.name)) {
+                        throw new errors_1.ExpressionClassExtensionError(node.superClass.name);
                     }
                 }
-            },
-            visitCatchClause(path) {
-                this.traverse(path);
-                const node = path.node;
-                const catchParamName = getReservedIdentifier(node.param);
-                if (catchParamName === undefined)
-                    return;
-                throw new errors_1.ExpressionReservedVariableError(catchParamName);
-            },
-            visitClassDeclaration(path) {
-                this.traverse(path);
-                const node = path.node;
-                const className = getReservedIdentifier(node.id);
-                if (className !== undefined) {
-                    throw new errors_1.ExpressionReservedVariableError(className);
+                else {
+                    throw new errors_1.ExpressionError('Cannot use dynamic class extension due to security concerns');
                 }
-                if (node.superClass) {
-                    if (node.superClass.type === 'Identifier') {
-                        if (blockedBaseClasses.has(node.superClass.name)) {
-                            throw new errors_1.ExpressionClassExtensionError(node.superClass.name);
-                        }
-                    }
-                    else {
-                        throw new errors_1.ExpressionError('Cannot use dynamic class extension due to security concerns');
+            }
+        },
+        visitClassExpression(path) {
+            this.traverse(path);
+            const node = path.node;
+            const className = getReservedIdentifier(node.id);
+            if (className !== undefined) {
+                throw new errors_1.ExpressionReservedVariableError(className);
+            }
+            if (node.superClass) {
+                if (node.superClass.type === 'Identifier') {
+                    if (blockedBaseClasses.has(node.superClass.name)) {
+                        throw new errors_1.ExpressionClassExtensionError(node.superClass.name);
                     }
                 }
-            },
-            visitClassExpression(path) {
-                this.traverse(path);
-                const node = path.node;
-                const className = getReservedIdentifier(node.id);
-                if (className !== undefined) {
-                    throw new errors_1.ExpressionReservedVariableError(className);
+                else {
+                    throw new errors_1.ExpressionError('Cannot use dynamic class extension due to security concerns');
                 }
-                if (node.superClass) {
-                    if (node.superClass.type === 'Identifier') {
-                        if (blockedBaseClasses.has(node.superClass.name)) {
-                            throw new errors_1.ExpressionClassExtensionError(node.superClass.name);
-                        }
-                    }
-                    else {
-                        throw new errors_1.ExpressionError('Cannot use dynamic class extension due to security concerns');
-                    }
+            }
+        },
+        visitAssignmentExpression(path) {
+            this.traverse(path);
+            const node = path.node;
+            const assignedIdentifier = getReservedIdentifier(node.left);
+            if (assignedIdentifier === undefined)
+                return;
+            throw new errors_1.ExpressionReservedVariableError(assignedIdentifier);
+        },
+        visitUpdateExpression(path) {
+            this.traverse(path);
+            const node = path.node;
+            const updatedIdentifier = getReservedIdentifier(node.argument);
+            if (updatedIdentifier === undefined)
+                return;
+            throw new errors_1.ExpressionReservedVariableError(updatedIdentifier);
+        },
+        visitForOfStatement(path) {
+            this.traverse(path);
+            const node = path.node;
+            const loopBinding = getReservedIdentifier(node.left);
+            if (loopBinding === undefined)
+                return;
+            throw new errors_1.ExpressionReservedVariableError(loopBinding);
+        },
+        visitForInStatement(path) {
+            this.traverse(path);
+            const node = path.node;
+            const loopBinding = getReservedIdentifier(node.left);
+            if (loopBinding === undefined)
+                return;
+            throw new errors_1.ExpressionReservedVariableError(loopBinding);
+        },
+        visitMemberExpression(path) {
+            this.traverse(path);
+            const node = path.node;
+            if (!node.computed) {
+                // This is static, so we're safe to error here
+                if (node.property.type !== 'Identifier') {
+                    throw new errors_1.ExpressionError(`Unknown property type ${node.property.type} while sanitising expression`);
                 }
-            },
-            visitAssignmentExpression(path) {
-                this.traverse(path);
-                const node = path.node;
-                const assignedIdentifier = getReservedIdentifier(node.left);
-                if (assignedIdentifier === undefined)
-                    return;
-                throw new errors_1.ExpressionReservedVariableError(assignedIdentifier);
-            },
-            visitUpdateExpression(path) {
-                this.traverse(path);
-                const node = path.node;
-                const updatedIdentifier = getReservedIdentifier(node.argument);
-                if (updatedIdentifier === undefined)
-                    return;
-                throw new errors_1.ExpressionReservedVariableError(updatedIdentifier);
-            },
-            visitForOfStatement(path) {
-                this.traverse(path);
-                const node = path.node;
-                const loopBinding = getReservedIdentifier(node.left);
-                if (loopBinding === undefined)
-                    return;
-                throw new errors_1.ExpressionReservedVariableError(loopBinding);
-            },
-            visitForInStatement(path) {
-                this.traverse(path);
-                const node = path.node;
-                const loopBinding = getReservedIdentifier(node.left);
-                if (loopBinding === undefined)
-                    return;
-                throw new errors_1.ExpressionReservedVariableError(loopBinding);
-            },
-            visitMemberExpression(path) {
-                this.traverse(path);
-                const node = path.node;
-                if (!node.computed) {
-                    // This is static, so we're safe to error here
-                    if (node.property.type !== 'Identifier') {
-                        throw new errors_1.ExpressionError(`Unknown property type ${node.property.type} while sanitising expression`);
+                if (!(0, utils_1.isSafeObjectProperty)(node.property.name)) {
+                    throw new errors_1.ExpressionError(`Cannot access "${node.property.name}" due to security concerns`);
+                }
+            }
+            else if (node.property.type === 'StringLiteral' || node.property.type === 'Literal') {
+                // Check any static strings against our forbidden list
+                if (!(0, utils_1.isSafeObjectProperty)(node.property.value)) {
+                    throw new errors_1.ExpressionError(`Cannot access "${node.property.value}" due to security concerns`);
+                }
+            }
+            else {
+                path.replace(tournament_1.astBuilders.memberExpression(
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+                node.object, 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                tournament_1.astBuilders.callExpression(tournament_1.astBuilders.memberExpression(dataNode, sanitizerIdentifier), [
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    node.property,
+                ]), true));
+            }
+        },
+        visitObjectPattern(path) {
+            this.traverse(path);
+            const node = path.node;
+            for (const prop of node.properties) {
+                if (prop.type === 'Property') {
+                    if (prop.computed) {
+                        throw new errors_1.ExpressionComputedDestructuringError();
                     }
-                    if (!(0, utils_1.isSafeObjectProperty)(node.property.name)) {
-                        throw new errors_1.ExpressionError(`Cannot access "${node.property.name}" due to security concerns`);
+                    let keyName;
+                    if (prop.key.type === 'Identifier') {
+                        keyName = prop.key.name;
                     }
-                }
-                else if (node.property.type === 'StringLiteral' || node.property.type === 'Literal') {
-                    // Check any static strings against our forbidden list
-                    if (!(0, utils_1.isSafeObjectProperty)(node.property.value)) {
-                        throw new errors_1.ExpressionError(`Cannot access "${node.property.value}" due to security concerns`);
+                    else if (prop.key.type === 'StringLiteral' || prop.key.type === 'Literal') {
+                        keyName = String(prop.key.value);
                     }
-                }
-                else {
-                    path.replace(tournament_1.astBuilders.memberExpression(
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
-                    node.object, 
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    tournament_1.astBuilders.callExpression(tournament_1.astBuilders.memberExpression(dataNode, sanitizerIdentifier), [
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        node.property,
-                    ]), true));
-                }
-            },
-            visitObjectPattern(path) {
-                this.traverse(path);
-                const node = path.node;
-                for (const prop of node.properties) {
-                    if (prop.type === 'Property') {
-                        if (prop.computed) {
-                            throw new errors_1.ExpressionComputedDestructuringError();
-                        }
-                        let keyName;
-                        if (prop.key.type === 'Identifier') {
-                            keyName = prop.key.name;
-                        }
-                        else if (prop.key.type === 'StringLiteral' || prop.key.type === 'Literal') {
-                            keyName = String(prop.key.value);
-                        }
-                        if (keyName !== undefined && !(0, utils_1.isSafeObjectProperty)(keyName)) {
-                            throw new errors_1.ExpressionDestructuringError(keyName);
-                        }
+                    if (keyName !== undefined && !(0, utils_1.isSafeObjectProperty)(keyName)) {
+                        throw new errors_1.ExpressionDestructuringError(keyName);
                     }
                 }
-            },
-            visitSpreadElement(path) {
-                this.traverse(path);
-                const { argument } = path.node;
-                if (argument.type === 'Identifier' && BLOCKED_SPREAD_GLOBALS.has(argument.name)) {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-                    path.node.argument = buildSafeSpreadArg(argument.name, dataNode);
-                }
-            },
-            visitSpreadProperty(path) {
-                this.traverse(path);
-                const { argument } = path.node;
-                if (argument.type === 'Identifier' && BLOCKED_SPREAD_GLOBALS.has(argument.name)) {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-                    path.node.argument = buildSafeSpreadArg(argument.name, dataNode);
-                }
-            },
-            visitWithStatement() {
-                throw new errors_1.ExpressionWithStatementError();
-            },
-        });
-    };
-    exports.PrototypeSanitizer = PrototypeSanitizer;
-    const sanitizer = (value) => {
-        const propertyKey = String(value);
-        if (!(0, utils_1.isSafeObjectProperty)(propertyKey)) {
-            throw new errors_1.ExpressionError(`Cannot access "${propertyKey}" due to security concerns`);
-        }
-        return propertyKey;
-    };
-    exports.sanitizer = sanitizer;
-});
+            }
+        },
+        visitSpreadElement(path) {
+            this.traverse(path);
+            const { argument } = path.node;
+            if (argument.type === 'Identifier' && BLOCKED_SPREAD_GLOBALS.has(argument.name)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+                path.node.argument = buildSafeSpreadArg(argument.name, dataNode);
+            }
+        },
+        visitSpreadProperty(path) {
+            this.traverse(path);
+            const { argument } = path.node;
+            if (argument.type === 'Identifier' && BLOCKED_SPREAD_GLOBALS.has(argument.name)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+                path.node.argument = buildSafeSpreadArg(argument.name, dataNode);
+            }
+        },
+        visitWithStatement() {
+            throw new errors_1.ExpressionWithStatementError();
+        },
+    });
+};
+exports.PrototypeSanitizer = PrototypeSanitizer;
+const sanitizer = (value) => {
+    const propertyKey = String(value);
+    if (!(0, utils_1.isSafeObjectProperty)(propertyKey)) {
+        throw new errors_1.ExpressionError(`Cannot access "${propertyKey}" due to security concerns`);
+    }
+    return propertyKey;
+};
+exports.sanitizer = sanitizer;
 //# sourceMappingURL=expression-sandboxing.js.map