@decaf-ts/integrations 0.3.10 → 0.3.12

package/lib/esm/graph/engine/execution/IsolatedVmCodeSandboxEvaluator.js

@@ -0,0 +1,440 @@
+/**
+ * @module integrations/graph/execution/IsolatedVmCodeSandboxEvaluator
+ * @summary {@link CodeSandboxEvaluator} backed by `isolated-vm` (ALFRED-5 §7).
+ * @description Provides a fully isolated V8 sandbox for the Code Node
+ * (DECAF-32 §22.4) and code-based conditions. Uses `isolated-vm` for true
+ * heap isolation (unlike Node's `vm` module which shares the host heap),
+ * `acorn` + `acorn-walk` for AST-based static validation, and `typescript`
+ * for TS transpilation.
+ *
+ * Restrictions enforced (ALFRED-5 §7.10–7.12, DECAF-34 §7.5):
+ *
+ * - **No imports** — `import` declarations are rejected by AST validation.
+ * - **No requires** — `require` is in the blocked-identifier set and is not
+ *   exposed in the sandbox context.
+ * - **No exports** — `export` declarations are rejected by AST validation.
+ * - **Pure functions only** — no system API access. Blocked identifiers
+ *   include `process`, `global`, `globalThis`, `Function`, `eval`, `fetch`,
+ *   `XMLHttpRequest`, `WebSocket`, `Worker`, `Deno`, `Bun`, `module`,
+ *   `exports`. The sandbox context exposes only the data variables
+ *   (`$input`, `$vars`, `$item`, `$index`, `$node`, `$output`).
+ * - **No `eval()` / `new Function()`** — rejected by AST validation.
+ *
+ * The user code is transpiled (TS → JS) if needed, statically validated,
+ * wrapped in a strict-mode async function that receives the data variables as
+ * parameters, compiled in an isolated V8 instance, and executed with a
+ * timeout and memory limit. The result is copied back to the host heap.
+ *
+ * @example
+ * ```ts
+ * const evaluator = new IsolatedVmCodeSandboxEvaluator();
+ * const result = await evaluator.evaluate({
+ *   code: "return $input.a + $input.b;",
+ *   input: { a: 2, b: 3 },
+ * });
+ * // result === 5
+ * ```
+ */
+import ivm from "isolated-vm";
+import * as acorn from "acorn";
+import * as walk from "acorn-walk";
+import * as ts from "typescript";
+import { GraphExecutionError } from "./../errors/GraphExecutionError.js";
+/**
+ * Default sandbox execution timeout in milliseconds.
+ */
+const DEFAULT_TIMEOUT_MS = 1000;
+/**
+ * Default memory limit for the isolated V8 heap in MB.
+ */
+const DEFAULT_MEMORY_MB = 32;
+/**
+ * Maximum code length (characters) accepted by the evaluator.
+ */
+const MAX_CODE_LENGTH = 100_000;
+/**
+ * Identifiers that are forbidden in sandboxed code (ALFRED-5 §7.10).
+ *
+ * Any AST node of type `Identifier` whose `name` is in this set causes the
+ * validator to reject the code. This covers both free-standing references
+ * (`process.env`) and call targets (`require(...)`).
+ */
+const BLOCKED_IDENTIFIERS = new Set([
+    "process",
+    "require",
+    "module",
+    "exports",
+    "global",
+    "globalThis",
+    "Function",
+    "eval",
+    "fetch",
+    "XMLHttpRequest",
+    "WebSocket",
+    "Worker",
+    "Deno",
+    "Bun",
+    "__dispatch",
+]);
+/**
+ * Transpiles TypeScript code to JavaScript (ALFRED-5 §7.4).
+ *
+ * When the language is `'javascript'` the code is returned unchanged. For
+ * `'typescript'` the code is transpiled using the TypeScript compiler with
+ * module kind `None` (no import/export emitted) and target `ES2022`.
+ *
+ * @param code - The user-authored code.
+ * @param language - The code language (`'javascript'` or `'typescript'`).
+ * @returns Transpiled JavaScript code.
+ */
+function transpileTypeScript(code, language) {
+    if (language === "javascript")
+        return code;
+    const result = ts.transpileModule(code, {
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.None,
+            strict: true,
+            noEmitHelpers: true,
+            importHelpers: false,
+        },
+    });
+    // Strip the "use strict"; directive that ts.transpileModule adds — the
+    // sandbox wrapper already enforces strict mode, and the directive breaks
+    // expression-mode wrapping (return (...)).
+    return result.outputText.replace(/^"use strict";\s*/, "");
+}
+/**
+ * Statically validates user code using an AST walk (ALFRED-5 §7.11).
+ *
+ * Rejects:
+ * - `ImportDeclaration` — no imports allowed.
+ * - `ExportNamedDeclaration` / `ExportDefaultDeclaration` — no exports.
+ * - `Identifier` whose name is in {@link BLOCKED_IDENTIFIERS}.
+ * - `NewExpression` with callee `Function` — no `new Function()`.
+ * - `CallExpression` with callee `eval` — no `eval()`.
+ *
+ * @param code - JavaScript code to validate (after TS transpilation).
+ * @throws {GraphExecutionError} when a forbidden construct is found.
+ */
+function validateSafeCode(code) {
+    if (code.length > MAX_CODE_LENGTH) {
+        throw new GraphExecutionError(`Code exceeds the maximum length of ${MAX_CODE_LENGTH} characters`, "GRAPH_CODE_SANDBOX_CODE_TOO_LONG", { length: code.length });
+    }
+    let ast;
+    try {
+        // First, try parsing the code wrapped in a function with sourceType
+        // "script". This handles `return` statements (which are valid inside a
+        // function) and lets us detect blocked identifiers, eval(), and
+        // new Function() via the AST walk.
+        ast = acorn.parse(`async function __validate() {\n${code}\n}`, {
+            ecmaVersion: "latest",
+            sourceType: "script",
+        });
+    }
+    catch {
+        // If the function-wrapped parse fails (e.g. because the code has
+        // top-level `import` or `export` declarations which are invalid inside
+        // a function), try parsing the raw code with sourceType "module" so
+        // import/export declarations are recognised as AST nodes.
+        try {
+            ast = acorn.parse(code, {
+                ecmaVersion: "latest",
+                sourceType: "module",
+            });
+        }
+        catch (err) {
+            throw new GraphExecutionError(`Code failed to parse: ${err.message}`, "GRAPH_CODE_SANDBOX_PARSE_ERROR", { code, error: err.message });
+        }
+    }
+    walk.full(ast, (node) => {
+        const n = node;
+        if (n["type"] === "ImportDeclaration") {
+            throw new GraphExecutionError("Imports are not allowed in Code nodes.", "GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN", { token: "import" });
+        }
+        if (n["type"] === "ExportNamedDeclaration" ||
+            n["type"] === "ExportDefaultDeclaration") {
+            throw new GraphExecutionError("Exports are not allowed in Code nodes.", "GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN", { token: "export" });
+        }
+        if (n["type"] === "Identifier" &&
+            typeof n["name"] === "string" &&
+            BLOCKED_IDENTIFIERS.has(n["name"])) {
+            throw new GraphExecutionError(`Identifier "${n["name"]}" is not allowed in Code nodes.`, "GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN", { token: n["name"] });
+        }
+        if (n["type"] === "NewExpression" &&
+            n["callee"]?.["name"] === "Function") {
+            throw new GraphExecutionError("new Function() is not allowed in Code nodes.", "GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN", { token: "Function" });
+        }
+        if (n["type"] === "CallExpression" &&
+            n["callee"]?.["name"] === "eval") {
+            throw new GraphExecutionError("eval() is not allowed in Code nodes.", "GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN", { token: "eval" });
+        }
+    });
+}
+/**
+ * Determines whether the given code contains a top-level `return` statement.
+ *
+ * When the code has no `return`, it is treated as a single expression and
+ * wrapped in `return (...)` so the user can write `($input.a + $input.b)`
+ * instead of `return $input.a + $input.b`.
+ */
+function hasReturnStatement(code) {
+    return /\breturn\b[\s;]/.test(code);
+}
+/**
+ * `isolated-vm`-backed {@link CodeSandboxEvaluator} (ALFRED-5 §7.18).
+ *
+ * This evaluator provides a truly isolated V8 sandbox — the code runs in a
+ * separate isolate with its own heap, separate from the host process. The
+ * sandbox context exposes only the data variables (`$input`, `$vars`, `$item`,
+ * `$index`, `$node`, `$output`); no host globals are available.
+ *
+ * Execution pipeline:
+ * 1. **Transpile** — TypeScript code is transpiled to JavaScript via
+ *    `typescript.transpileModule` (ALFRED-5 §7.4).
+ * 2. **Validate** — the JavaScript code is parsed with `acorn` and walked with
+ *    `acorn-walk` to reject imports, exports, blocked identifiers, `eval()`,
+ *    and `new Function()` (ALFRED-5 §7.11).
+ * 3. **Isolate** — a new `isolated-vm` `Isolate` is created with a memory
+ *    limit. A context is created and the data variables are copied into the
+ *    isolate's heap via `ExternalCopy`.
+ * 4. **Compile & run** — the wrapped code is compiled and executed with a
+ *    timeout. The result is copied back to the host heap.
+ * 5. **Dispose** — the isolate is always disposed in a `finally` block.
+ *
+ * The user code is wrapped in a strict-mode async function:
+ *
+ * ```js
+ * "use strict";
+ * async function __userFunction($input, $vars, $item, $index, $node, $output) {
+ *   <user code>
+ * }
+ * __userFunction($input, $vars, $item, $index, $node, $output);
+ * ```
+ *
+ * When the code has no `return` statement it is treated as a single expression
+ * and wrapped in `return (...)`.
+ */
+export class IsolatedVmCodeSandboxEvaluator {
+    /**
+     * @param defaultTimeoutMs - Default execution timeout in milliseconds.
+     * @param defaultMemoryMb - Default isolate memory limit in MB.
+     */
+    constructor(defaultTimeoutMs = DEFAULT_TIMEOUT_MS, defaultMemoryMb = DEFAULT_MEMORY_MB) {
+        this.defaultTimeoutMs = defaultTimeoutMs;
+        this.defaultMemoryMb = defaultMemoryMb;
+    }
+    async evaluate(ctx) {
+        const code = ctx.code;
+        if (!code || typeof code !== "string" || code.trim().length === 0) {
+            throw new GraphExecutionError("Code sandbox received empty code", "GRAPH_CODE_SANDBOX_EMPTY_CODE");
+        }
+        const language = ctx.language ?? "javascript";
+        const jsCode = transpileTypeScript(code, language);
+        validateSafeCode(jsCode);
+        const expressionMode = !hasReturnStatement(jsCode);
+        const codeForMode = expressionMode
+            ? jsCode.replace(/[\s;]+$/, "")
+            : jsCode;
+        const sandboxVars = {
+            $input: ctx.input ?? {},
+            $vars: ctx.vars ?? {},
+            $item: ctx.item,
+            $index: ctx.index,
+            $node: ctx.nodes ?? {},
+            $output: undefined,
+        };
+        const paramNames = Object.keys(sandboxVars);
+        // const paramValues = Object.values(sandboxVars);
+        // Build the wrapped script. The user code runs inside an async function
+        // with named parameters. The result is JSON-stringified inside the isolate
+        // so it can be transferred back as a plain string (isolated-vm cannot
+        // deep-copy arbitrary objects via `script.run()` with `promise: true`).
+        // The spec requires JSON-serializable output, so this is safe.
+        const userBody = expressionMode ? `return (${codeForMode});` : codeForMode;
+        const wrapped = `"use strict";\nasync function __userFunction(${paramNames.join(", ")}) {\n${userBody}\n}\n__userFunction(${paramNames.join(", ")}).then(function(__r) { return JSON.stringify({ v: __r }); });`;
+        const isolate = new ivm.Isolate({ memoryLimit: this.defaultMemoryMb });
+        const context = await isolate.createContext();
+        try {
+            const jail = context.global;
+            // Inject a `console` object into the isolate whose methods forward to
+            // the Context logger (bound to runId). The logger is called via
+            // `ivm.Reference` so the isolate can invoke host functions without
+            // leaking the host heap.
+            if (ctx.logger) {
+                await this.injectConsole(jail, ctx.logger, context);
+            }
+            for (const [name, value] of Object.entries(sandboxVars)) {
+                await jail.set(name, new ivm.ExternalCopy(value === undefined ? null : value).copyInto());
+            }
+            let script;
+            try {
+                script = await isolate.compileScript(wrapped, {
+                    filename: "graph-code-node.js",
+                });
+            }
+            catch (err) {
+                if (expressionMode) {
+                    const fallbackBody = codeForMode;
+                    const fallbackWrapped = `"use strict";\nasync function __userFunction(${paramNames.join(", ")}) {\n${fallbackBody}\n}\n__userFunction(${paramNames.join(", ")}).then(function(__r) { return JSON.stringify({ v: __r }); });`;
+                    try {
+                        script = await isolate.compileScript(fallbackWrapped, {
+                            filename: "graph-code-node.js",
+                        });
+                    }
+                    catch (fallbackErr) {
+                        throw new GraphExecutionError(`Code failed to compile: ${fallbackErr.message}`, "GRAPH_CODE_SANDBOX_COMPILE_ERROR", { code: jsCode, error: fallbackErr.message });
+                    }
+                }
+                else {
+                    throw new GraphExecutionError(`Code failed to compile: ${err.message}`, "GRAPH_CODE_SANDBOX_COMPILE_ERROR", { code: jsCode, error: err.message });
+                }
+            }
+            let rawResult;
+            try {
+                rawResult = await script.run(context, {
+                    timeout: this.defaultTimeoutMs,
+                    promise: true,
+                });
+            }
+            catch (err) {
+                const msg = err.message;
+                if (msg.includes("timed out") || msg.includes("timeout")) {
+                    throw new GraphExecutionError(`Code execution timed out after ${this.defaultTimeoutMs} ms`, "GRAPH_CODE_SANDBOX_TIMEOUT", { timeoutMs: this.defaultTimeoutMs });
+                }
+                if (msg.includes("memory") || msg.includes("heap")) {
+                    throw new GraphExecutionError(`Code exceeded the memory limit of ${this.defaultMemoryMb} MB`, "GRAPH_CODE_SANDBOX_MEMORY_LIMIT", { memoryMb: this.defaultMemoryMb });
+                }
+                throw new GraphExecutionError(`Code execution failed: ${msg}`, "GRAPH_CODE_SANDBOX_RUNTIME_ERROR", { code: jsCode, error: msg });
+            }
+            // The script returns a JSON string `{"v": <result>}`. Parse it back.
+            if (typeof rawResult !== "string") {
+                throw new GraphExecutionError("Code sandbox returned an unexpected non-string result", "GRAPH_CODE_SANDBOX_UNEXPECTED_RESULT", { result: rawResult });
+            }
+            return JSON.parse(rawResult).v;
+        }
+        finally {
+            context.release();
+            isolate.dispose();
+        }
+    }
+    /**
+     * Injects a `console` object into the isolate whose methods forward to the
+     * Context logger (bound to `runId`).
+     *
+     * Every standard `console.*` method is supported:
+     * `log`, `info`, `warn`, `error`, `debug`, `trace`, `dir`, `dirxml`,
+     * `table`, `group`, `groupCollapsed`, `groupEnd`, `time`, `timeEnd`,
+     * `timeLog`, `assert`, `count`, `countReset`, `clear`.
+     *
+     * Arguments are serialised inside the isolate (via `JSON.stringify` with a
+     * safe fallback) before being passed across the isolate boundary, because
+     * `isolated-vm` cannot copy arbitrary host objects.
+     *
+     * @param jail - The isolate's global object.
+     * @param logger - The Context logger that receives the forwarded calls.
+     * @param context - The isolate context (for running the init script).
+     */
+    async injectConsole(jail, logger, context) {
+        const dispatch = new ivm.Reference(function (level, argsJson) {
+            let parsed;
+            try {
+                parsed = JSON.parse(argsJson);
+            }
+            catch {
+                parsed = [argsJson];
+            }
+            const msg = parsed
+                .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
+                .join(" ");
+            const meta = parsed.length === 1 ? parsed[0] : parsed;
+            switch (level) {
+                case "log":
+                case "info":
+                    logger.info(msg, meta);
+                    break;
+                case "warn":
+                    logger.warn(msg, meta);
+                    break;
+                case "error":
+                    logger.error(msg, meta);
+                    break;
+                case "debug":
+                    logger.debug(msg, meta);
+                    break;
+                case "trace":
+                    logger.trace(msg, meta);
+                    break;
+                case "dir":
+                case "dirxml":
+                case "table":
+                    logger.debug(msg, meta);
+                    break;
+                case "group":
+                case "groupCollapsed":
+                    logger.debug(`[group] ${msg}`, meta);
+                    break;
+                case "groupEnd":
+                    logger.debug("[groupEnd]", undefined);
+                    break;
+                case "time":
+                case "timeEnd":
+                case "timeLog":
+                    logger.debug(`[${level}] ${msg}`, meta);
+                    break;
+                case "assert":
+                    if (!parsed[0])
+                        logger.error(`Assertion failed: ${msg}`, meta);
+                    break;
+                case "count":
+                case "countReset":
+                    logger.debug(`[${level}] ${msg}`, meta);
+                    break;
+                case "clear":
+                    break;
+                default:
+                    logger.info(msg, meta);
+            }
+        });
+        await jail.set("__dispatch", dispatch);
+        context.evalSync(`
+      function __ser() {
+        var out = [];
+        for (var i = 0; i < arguments.length; i++) {
+          var a = arguments[i];
+          try { out.push(typeof a === 'object' ? JSON.parse(JSON.stringify(a)) : a); }
+          catch (e) { out.push(String(a)); }
+        }
+        return JSON.stringify(out);
+      }
+      function __call(level) {
+        return function() {
+          __dispatch.applySync(undefined, [level, __ser.apply(null, arguments)]);
+        };
+      }
+      globalThis.console = {
+        log: __call('log'),
+        info: __call('info'),
+        warn: __call('warn'),
+        error: __call('error'),
+        debug: __call('debug'),
+        trace: __call('trace'),
+        dir: __call('dir'),
+        dirxml: __call('dirxml'),
+        table: __call('table'),
+        group: __call('group'),
+        groupCollapsed: __call('groupCollapsed'),
+        groupEnd: __call('groupEnd'),
+        time: __call('time'),
+        timeEnd: __call('timeEnd'),
+        timeLog: __call('timeLog'),
+        assert: __call('assert'),
+        count: __call('count'),
+        countReset: __call('countReset'),
+        clear: __call('clear')
+      };
+    `);
+        dispatch.release();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"IsolatedVmCodeSandboxEvaluator.js","sourceRoot":"","sources":["../../../../../src/graph/engine/execution/IsolatedVmCodeSandboxEvaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/execution/IsolatedVmCodeSandboxEvaluator\n * @summary {@link CodeSandboxEvaluator} backed by `isolated-vm` (ALFRED-5 §7).\n * @description Provides a fully isolated V8 sandbox for the Code Node\n * (DECAF-32 §22.4) and code-based conditions. Uses `isolated-vm` for true\n * heap isolation (unlike Node's `vm` module which shares the host heap),\n * `acorn` + `acorn-walk` for AST-based static validation, and `typescript`\n * for TS transpilation.\n *\n * Restrictions enforced (ALFRED-5 §7.10–7.12, DECAF-34 §7.5):\n *\n * - **No imports** — `import` declarations are rejected by AST validation.\n * - **No requires** — `require` is in the blocked-identifier set and is not\n *   exposed in the sandbox context.\n * - **No exports** — `export` declarations are rejected by AST validation.\n * - **Pure functions only** — no system API access. Blocked identifiers\n *   include `process`, `global`, `globalThis`, `Function`, `eval`, `fetch`,\n *   `XMLHttpRequest`, `WebSocket`, `Worker`, `Deno`, `Bun`, `module`,\n *   `exports`. The sandbox context exposes only the data variables\n *   (`$input`, `$vars`, `$item`, `$index`, `$node`, `$output`).\n * - **No `eval()` / `new Function()`** — rejected by AST validation.\n *\n * The user code is transpiled (TS → JS) if needed, statically validated,\n * wrapped in a strict-mode async function that receives the data variables as\n * parameters, compiled in an isolated V8 instance, and executed with a\n * timeout and memory limit. The result is copied back to the host heap.\n *\n * @example\n * ```ts\n * const evaluator = new IsolatedVmCodeSandboxEvaluator();\n * const result = await evaluator.evaluate({\n *   code: \"return $input.a + $input.b;\",\n *   input: { a: 2, b: 3 },\n * });\n * // result === 5\n * ```\n */\nimport ivm from \"isolated-vm\";\nimport * as acorn from \"acorn\";\nimport * as walk from \"acorn-walk\";\nimport * as ts from \"typescript\";\nimport type {\n  CodeSandboxEvaluator,\n  CodeSandboxContext,\n  SandboxLogger,\n} from \"./CodeSandboxEvaluator\";\nimport { GraphExecutionError } from \"../errors/GraphExecutionError\";\n\n/**\n * Default sandbox execution timeout in milliseconds.\n */\nconst DEFAULT_TIMEOUT_MS = 1000;\n\n/**\n * Default memory limit for the isolated V8 heap in MB.\n */\nconst DEFAULT_MEMORY_MB = 32;\n\n/**\n * Maximum code length (characters) accepted by the evaluator.\n */\nconst MAX_CODE_LENGTH = 100_000;\n\n/**\n * Identifiers that are forbidden in sandboxed code (ALFRED-5 §7.10).\n *\n * Any AST node of type `Identifier` whose `name` is in this set causes the\n * validator to reject the code. This covers both free-standing references\n * (`process.env`) and call targets (`require(...)`).\n */\nconst BLOCKED_IDENTIFIERS: ReadonlySet<string> = new Set([\n  \"process\",\n  \"require\",\n  \"module\",\n  \"exports\",\n  \"global\",\n  \"globalThis\",\n  \"Function\",\n  \"eval\",\n  \"fetch\",\n  \"XMLHttpRequest\",\n  \"WebSocket\",\n  \"Worker\",\n  \"Deno\",\n  \"Bun\",\n  \"__dispatch\",\n]);\n\n/**\n * Transpiles TypeScript code to JavaScript (ALFRED-5 §7.4).\n *\n * When the language is `'javascript'` the code is returned unchanged. For\n * `'typescript'` the code is transpiled using the TypeScript compiler with\n * module kind `None` (no import/export emitted) and target `ES2022`.\n *\n * @param code - The user-authored code.\n * @param language - The code language (`'javascript'` or `'typescript'`).\n * @returns Transpiled JavaScript code.\n */\nfunction transpileTypeScript(\n  code: string,\n  language: \"javascript\" | \"typescript\"\n): string {\n  if (language === \"javascript\") return code;\n\n  const result = ts.transpileModule(code, {\n    compilerOptions: {\n      target: ts.ScriptTarget.ES2022,\n      module: ts.ModuleKind.None,\n      strict: true,\n      noEmitHelpers: true,\n      importHelpers: false,\n    },\n  });\n\n  // Strip the \"use strict\"; directive that ts.transpileModule adds — the\n  // sandbox wrapper already enforces strict mode, and the directive breaks\n  // expression-mode wrapping (return (...)).\n  return result.outputText.replace(/^\"use strict\";\\s*/, \"\");\n}\n\n/**\n * Statically validates user code using an AST walk (ALFRED-5 §7.11).\n *\n * Rejects:\n * - `ImportDeclaration` — no imports allowed.\n * - `ExportNamedDeclaration` / `ExportDefaultDeclaration` — no exports.\n * - `Identifier` whose name is in {@link BLOCKED_IDENTIFIERS}.\n * - `NewExpression` with callee `Function` — no `new Function()`.\n * - `CallExpression` with callee `eval` — no `eval()`.\n *\n * @param code - JavaScript code to validate (after TS transpilation).\n * @throws {GraphExecutionError} when a forbidden construct is found.\n */\nfunction validateSafeCode(code: string): void {\n  if (code.length > MAX_CODE_LENGTH) {\n    throw new GraphExecutionError(\n      `Code exceeds the maximum length of ${MAX_CODE_LENGTH} characters`,\n      \"GRAPH_CODE_SANDBOX_CODE_TOO_LONG\",\n      { length: code.length }\n    );\n  }\n\n  let ast: acorn.AnyNode;\n  try {\n    // First, try parsing the code wrapped in a function with sourceType\n    // \"script\". This handles `return` statements (which are valid inside a\n    // function) and lets us detect blocked identifiers, eval(), and\n    // new Function() via the AST walk.\n    ast = acorn.parse(`async function __validate() {\\n${code}\\n}`, {\n      ecmaVersion: \"latest\",\n      sourceType: \"script\",\n    }) as acorn.AnyNode;\n  } catch {\n    // If the function-wrapped parse fails (e.g. because the code has\n    // top-level `import` or `export` declarations which are invalid inside\n    // a function), try parsing the raw code with sourceType \"module\" so\n    // import/export declarations are recognised as AST nodes.\n    try {\n      ast = acorn.parse(code, {\n        ecmaVersion: \"latest\",\n        sourceType: \"module\",\n      }) as acorn.AnyNode;\n    } catch (err) {\n      throw new GraphExecutionError(\n        `Code failed to parse: ${(err as Error).message}`,\n        \"GRAPH_CODE_SANDBOX_PARSE_ERROR\",\n        { code, error: (err as Error).message }\n      );\n    }\n  }\n\n  walk.full(ast as never, (node: acorn.AnyNode) => {\n    const n = node as unknown as Record<string, unknown>;\n\n    if (n[\"type\"] === \"ImportDeclaration\") {\n      throw new GraphExecutionError(\n        \"Imports are not allowed in Code nodes.\",\n        \"GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN\",\n        { token: \"import\" }\n      );\n    }\n\n    if (\n      n[\"type\"] === \"ExportNamedDeclaration\" ||\n      n[\"type\"] === \"ExportDefaultDeclaration\"\n    ) {\n      throw new GraphExecutionError(\n        \"Exports are not allowed in Code nodes.\",\n        \"GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN\",\n        { token: \"export\" }\n      );\n    }\n\n    if (\n      n[\"type\"] === \"Identifier\" &&\n      typeof n[\"name\"] === \"string\" &&\n      BLOCKED_IDENTIFIERS.has(n[\"name\"])\n    ) {\n      throw new GraphExecutionError(\n        `Identifier \"${n[\"name\"]}\" is not allowed in Code nodes.`,\n        \"GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN\",\n        { token: n[\"name\"] }\n      );\n    }\n\n    if (\n      n[\"type\"] === \"NewExpression\" &&\n      (n[\"callee\"] as Record<string, unknown>)?.[\"name\"] === \"Function\"\n    ) {\n      throw new GraphExecutionError(\n        \"new Function() is not allowed in Code nodes.\",\n        \"GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN\",\n        { token: \"Function\" }\n      );\n    }\n\n    if (\n      n[\"type\"] === \"CallExpression\" &&\n      (n[\"callee\"] as Record<string, unknown>)?.[\"name\"] === \"eval\"\n    ) {\n      throw new GraphExecutionError(\n        \"eval() is not allowed in Code nodes.\",\n        \"GRAPH_CODE_SANDBOX_FORBIDDEN_TOKEN\",\n        { token: \"eval\" }\n      );\n    }\n  });\n}\n\n/**\n * Determines whether the given code contains a top-level `return` statement.\n *\n * When the code has no `return`, it is treated as a single expression and\n * wrapped in `return (...)` so the user can write `($input.a + $input.b)`\n * instead of `return $input.a + $input.b`.\n */\nfunction hasReturnStatement(code: string): boolean {\n  return /\\breturn\\b[\\s;]/.test(code);\n}\n\n/**\n * `isolated-vm`-backed {@link CodeSandboxEvaluator} (ALFRED-5 §7.18).\n *\n * This evaluator provides a truly isolated V8 sandbox — the code runs in a\n * separate isolate with its own heap, separate from the host process. The\n * sandbox context exposes only the data variables (`$input`, `$vars`, `$item`,\n * `$index`, `$node`, `$output`); no host globals are available.\n *\n * Execution pipeline:\n * 1. **Transpile** — TypeScript code is transpiled to JavaScript via\n *    `typescript.transpileModule` (ALFRED-5 §7.4).\n * 2. **Validate** — the JavaScript code is parsed with `acorn` and walked with\n *    `acorn-walk` to reject imports, exports, blocked identifiers, `eval()`,\n *    and `new Function()` (ALFRED-5 §7.11).\n * 3. **Isolate** — a new `isolated-vm` `Isolate` is created with a memory\n *    limit. A context is created and the data variables are copied into the\n *    isolate's heap via `ExternalCopy`.\n * 4. **Compile & run** — the wrapped code is compiled and executed with a\n *    timeout. The result is copied back to the host heap.\n * 5. **Dispose** — the isolate is always disposed in a `finally` block.\n *\n * The user code is wrapped in a strict-mode async function:\n *\n * ```js\n * \"use strict\";\n * async function __userFunction($input, $vars, $item, $index, $node, $output) {\n *   <user code>\n * }\n * __userFunction($input, $vars, $item, $index, $node, $output);\n * ```\n *\n * When the code has no `return` statement it is treated as a single expression\n * and wrapped in `return (...)`.\n */\nexport class IsolatedVmCodeSandboxEvaluator implements CodeSandboxEvaluator {\n  private readonly defaultTimeoutMs: number;\n  private readonly defaultMemoryMb: number;\n\n  /**\n   * @param defaultTimeoutMs - Default execution timeout in milliseconds.\n   * @param defaultMemoryMb - Default isolate memory limit in MB.\n   */\n  constructor(\n    defaultTimeoutMs: number = DEFAULT_TIMEOUT_MS,\n    defaultMemoryMb: number = DEFAULT_MEMORY_MB\n  ) {\n    this.defaultTimeoutMs = defaultTimeoutMs;\n    this.defaultMemoryMb = defaultMemoryMb;\n  }\n\n  async evaluate(ctx: CodeSandboxContext): Promise<unknown> {\n    const code = ctx.code;\n    if (!code || typeof code !== \"string\" || code.trim().length === 0) {\n      throw new GraphExecutionError(\n        \"Code sandbox received empty code\",\n        \"GRAPH_CODE_SANDBOX_EMPTY_CODE\"\n      );\n    }\n\n    const language = ctx.language ?? \"javascript\";\n    const jsCode = transpileTypeScript(code, language);\n\n    validateSafeCode(jsCode);\n\n    const expressionMode = !hasReturnStatement(jsCode);\n    const codeForMode = expressionMode\n      ? jsCode.replace(/[\\s;]+$/, \"\")\n      : jsCode;\n\n    const sandboxVars: Record<string, unknown> = {\n      $input: ctx.input ?? {},\n      $vars: ctx.vars ?? {},\n      $item: ctx.item,\n      $index: ctx.index,\n      $node: ctx.nodes ?? {},\n      $output: undefined,\n    };\n\n    const paramNames = Object.keys(sandboxVars);\n    // const paramValues = Object.values(sandboxVars);\n\n    // Build the wrapped script. The user code runs inside an async function\n    // with named parameters. The result is JSON-stringified inside the isolate\n    // so it can be transferred back as a plain string (isolated-vm cannot\n    // deep-copy arbitrary objects via `script.run()` with `promise: true`).\n    // The spec requires JSON-serializable output, so this is safe.\n    const userBody = expressionMode ? `return (${codeForMode});` : codeForMode;\n    const wrapped = `\"use strict\";\\nasync function __userFunction(${paramNames.join(\", \")}) {\\n${userBody}\\n}\\n__userFunction(${paramNames.join(\", \")}).then(function(__r) { return JSON.stringify({ v: __r }); });`;\n\n    const isolate = new ivm.Isolate({ memoryLimit: this.defaultMemoryMb });\n    const context = await isolate.createContext();\n\n    try {\n      const jail = context.global;\n\n      // Inject a `console` object into the isolate whose methods forward to\n      // the Context logger (bound to runId). The logger is called via\n      // `ivm.Reference` so the isolate can invoke host functions without\n      // leaking the host heap.\n      if (ctx.logger) {\n        await this.injectConsole(jail, ctx.logger, context);\n      }\n\n      for (const [name, value] of Object.entries(sandboxVars)) {\n        await jail.set(\n          name,\n          new ivm.ExternalCopy(value === undefined ? null : value).copyInto()\n        );\n      }\n\n      let script: ivm.Script;\n      try {\n        script = await isolate.compileScript(wrapped, {\n          filename: \"graph-code-node.js\",\n        });\n      } catch (err) {\n        if (expressionMode) {\n          const fallbackBody = codeForMode;\n          const fallbackWrapped = `\"use strict\";\\nasync function __userFunction(${paramNames.join(\", \")}) {\\n${fallbackBody}\\n}\\n__userFunction(${paramNames.join(\", \")}).then(function(__r) { return JSON.stringify({ v: __r }); });`;\n          try {\n            script = await isolate.compileScript(fallbackWrapped, {\n              filename: \"graph-code-node.js\",\n            });\n          } catch (fallbackErr) {\n            throw new GraphExecutionError(\n              `Code failed to compile: ${(fallbackErr as Error).message}`,\n              \"GRAPH_CODE_SANDBOX_COMPILE_ERROR\",\n              { code: jsCode, error: (fallbackErr as Error).message }\n            );\n          }\n        } else {\n          throw new GraphExecutionError(\n            `Code failed to compile: ${(err as Error).message}`,\n            \"GRAPH_CODE_SANDBOX_COMPILE_ERROR\",\n            { code: jsCode, error: (err as Error).message }\n          );\n        }\n      }\n\n      let rawResult: unknown;\n      try {\n        rawResult = await script.run(context, {\n          timeout: this.defaultTimeoutMs,\n          promise: true,\n        });\n      } catch (err) {\n        const msg = (err as Error).message;\n        if (msg.includes(\"timed out\") || msg.includes(\"timeout\")) {\n          throw new GraphExecutionError(\n            `Code execution timed out after ${this.defaultTimeoutMs} ms`,\n            \"GRAPH_CODE_SANDBOX_TIMEOUT\",\n            { timeoutMs: this.defaultTimeoutMs }\n          );\n        }\n        if (msg.includes(\"memory\") || msg.includes(\"heap\")) {\n          throw new GraphExecutionError(\n            `Code exceeded the memory limit of ${this.defaultMemoryMb} MB`,\n            \"GRAPH_CODE_SANDBOX_MEMORY_LIMIT\",\n            { memoryMb: this.defaultMemoryMb }\n          );\n        }\n        throw new GraphExecutionError(\n          `Code execution failed: ${msg}`,\n          \"GRAPH_CODE_SANDBOX_RUNTIME_ERROR\",\n          { code: jsCode, error: msg }\n        );\n      }\n\n      // The script returns a JSON string `{\"v\": <result>}`. Parse it back.\n      if (typeof rawResult !== \"string\") {\n        throw new GraphExecutionError(\n          \"Code sandbox returned an unexpected non-string result\",\n          \"GRAPH_CODE_SANDBOX_UNEXPECTED_RESULT\",\n          { result: rawResult }\n        );\n      }\n      return JSON.parse(rawResult).v;\n    } finally {\n      context.release();\n      isolate.dispose();\n    }\n  }\n\n  /**\n   * Injects a `console` object into the isolate whose methods forward to the\n   * Context logger (bound to `runId`).\n   *\n   * Every standard `console.*` method is supported:\n   * `log`, `info`, `warn`, `error`, `debug`, `trace`, `dir`, `dirxml`,\n   * `table`, `group`, `groupCollapsed`, `groupEnd`, `time`, `timeEnd`,\n   * `timeLog`, `assert`, `count`, `countReset`, `clear`.\n   *\n   * Arguments are serialised inside the isolate (via `JSON.stringify` with a\n   * safe fallback) before being passed across the isolate boundary, because\n   * `isolated-vm` cannot copy arbitrary host objects.\n   *\n   * @param jail - The isolate's global object.\n   * @param logger - The Context logger that receives the forwarded calls.\n   * @param context - The isolate context (for running the init script).\n   */\n  private async injectConsole(\n    jail: ivm.Context[\"global\"],\n    logger: SandboxLogger,\n    context: ivm.Context\n  ): Promise<void> {\n    const dispatch = new ivm.Reference(function (level: string, argsJson: string) {\n      let parsed: unknown[];\n      try {\n        parsed = JSON.parse(argsJson) as unknown[];\n      } catch {\n        parsed = [argsJson];\n      }\n      const msg = parsed\n        .map((a) => (typeof a === \"string\" ? a : JSON.stringify(a)))\n        .join(\" \");\n      const meta = parsed.length === 1 ? parsed[0] : parsed;\n      switch (level) {\n        case \"log\":\n        case \"info\":\n          logger.info(msg, meta);\n          break;\n        case \"warn\":\n          logger.warn(msg, meta);\n          break;\n        case \"error\":\n          logger.error(msg, meta);\n          break;\n        case \"debug\":\n          logger.debug(msg, meta);\n          break;\n        case \"trace\":\n          logger.trace(msg, meta);\n          break;\n        case \"dir\":\n        case \"dirxml\":\n        case \"table\":\n          logger.debug(msg, meta);\n          break;\n        case \"group\":\n        case \"groupCollapsed\":\n          logger.debug(`[group] ${msg}`, meta);\n          break;\n        case \"groupEnd\":\n          logger.debug(\"[groupEnd]\", undefined);\n          break;\n        case \"time\":\n        case \"timeEnd\":\n        case \"timeLog\":\n          logger.debug(`[${level}] ${msg}`, meta);\n          break;\n        case \"assert\":\n          if (!parsed[0]) logger.error(`Assertion failed: ${msg}`, meta);\n          break;\n        case \"count\":\n        case \"countReset\":\n          logger.debug(`[${level}] ${msg}`, meta);\n          break;\n        case \"clear\":\n          break;\n        default:\n          logger.info(msg, meta);\n      }\n    });\n\n    await jail.set(\"__dispatch\", dispatch);\n\n    context.evalSync(`\n      function __ser() {\n        var out = [];\n        for (var i = 0; i < arguments.length; i++) {\n          var a = arguments[i];\n          try { out.push(typeof a === 'object' ? JSON.parse(JSON.stringify(a)) : a); }\n          catch (e) { out.push(String(a)); }\n        }\n        return JSON.stringify(out);\n      }\n      function __call(level) {\n        return function() {\n          __dispatch.applySync(undefined, [level, __ser.apply(null, arguments)]);\n        };\n      }\n      globalThis.console = {\n        log: __call('log'),\n        info: __call('info'),\n        warn: __call('warn'),\n        error: __call('error'),\n        debug: __call('debug'),\n        trace: __call('trace'),\n        dir: __call('dir'),\n        dirxml: __call('dirxml'),\n        table: __call('table'),\n        group: __call('group'),\n        groupCollapsed: __call('groupCollapsed'),\n        groupEnd: __call('groupEnd'),\n        time: __call('time'),\n        timeEnd: __call('timeEnd'),\n        timeLog: __call('timeLog'),\n        assert: __call('assert'),\n        count: __call('count'),\n        countReset: __call('countReset'),\n        clear: __call('clear')\n      };\n    `);\n\n    dispatch.release();\n  }\n}\n"]}

package/lib/esm/graph/engine/execution/LogGraphNodeExecutor.js

@@ -0,0 +1,14 @@
+/**
+ * Executor for `core.flow.log` nodes.
+ *
+ * Reads the `value` input port, logs it through `context.log()`, and returns
+ * it unchanged on the `logged` output port.
+ */
+export class LogGraphNodeExecutor {
+    async execute(input, context) {
+        const value = input["value"];
+        await context.log("Log node", { value });
+        return { logged: value };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nR3JhcGhOb2RlRXhlY3V0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2V4ZWN1dGlvbi9Mb2dHcmFwaE5vZGVFeGVjdXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXQTs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyxvQkFBb0I7SUFDL0IsS0FBSyxDQUFDLE9BQU8sQ0FDWCxLQUEyQixFQUMzQixPQUE4QjtRQUU5QixNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDN0IsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDLFVBQVUsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7UUFDekMsT0FBTyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQztJQUMzQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL2V4ZWN1dGlvbi9Mb2dHcmFwaE5vZGVFeGVjdXRvclxuICogQHN1bW1hcnkgRXhlY3V0b3IgZm9yIHRoZSBMb2cgZmxvdy1jb250cm9sIG5vZGUuXG4gKiBAZGVzY3JpcHRpb24gTG9ncyB0aGUgaW5wdXQgdmFsdWUgdmlhIHRoZSBleGVjdXRpb24gY29udGV4dCdzIGxvZ2dlciBhbmRcbiAqIGZvcndhcmRzIGl0IHVuY2hhbmdlZCBvbiB0aGUgYGxvZ2dlZGAgb3V0cHV0IHBvcnQuIFVzZWZ1bCBmb3IgZGVidWdnaW5nLFxuICogYXVkaXQgdHJhaWxzLCBhbmQgZGlzY2FyZC9zaWRlLWVmZmVjdCBicmFuY2hlcyBpbiBhIHdvcmtmbG93LlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoTm9kZUV4ZWN1dG9yIH0gZnJvbSBcIi4vR3JhcGhOb2RlRXhlY3V0b3JcIjtcbmltcG9ydCB0eXBlIHsgR3JhcGhFeGVjdXRpb25Db250ZXh0IH0gZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25Db250ZXh0XCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uVmFsdWVzIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5cbi8qKlxuICogRXhlY3V0b3IgZm9yIGBjb3JlLmZsb3cubG9nYCBub2Rlcy5cbiAqXG4gKiBSZWFkcyB0aGUgYHZhbHVlYCBpbnB1dCBwb3J0LCBsb2dzIGl0IHRocm91Z2ggYGNvbnRleHQubG9nKClgLCBhbmQgcmV0dXJuc1xuICogaXQgdW5jaGFuZ2VkIG9uIHRoZSBgbG9nZ2VkYCBvdXRwdXQgcG9ydC5cbiAqL1xuZXhwb3J0IGNsYXNzIExvZ0dyYXBoTm9kZUV4ZWN1dG9yIGltcGxlbWVudHMgR3JhcGhOb2RlRXhlY3V0b3Ige1xuICBhc3luYyBleGVjdXRlKFxuICAgIGlucHV0OiBHcmFwaEV4ZWN1dGlvblZhbHVlcyxcbiAgICBjb250ZXh0OiBHcmFwaEV4ZWN1dGlvbkNvbnRleHRcbiAgKTogUHJvbWlzZTxHcmFwaEV4ZWN1dGlvblZhbHVlcz4ge1xuICAgIGNvbnN0IHZhbHVlID0gaW5wdXRbXCJ2YWx1ZVwiXTtcbiAgICBhd2FpdCBjb250ZXh0LmxvZyhcIkxvZyBub2RlXCIsIHsgdmFsdWUgfSk7XG4gICAgcmV0dXJuIHsgbG9nZ2VkOiB2YWx1ZSB9O1xuICB9XG59XG4iXX0=

package/lib/esm/graph/engine/execution/SwitchGraphNodeExecutor.js

@@ -2,18 +2,23 @@ import { GraphExecutionError } from "./../errors/GraphExecutionError.js";
 import { ConditionExpressionEvaluator } from "./../loops/ConditionExpressionEvaluator.js";
 /**
  * Reads the Switch metadata from the node definition's graph metadata.
+ *
+ * The metadata is stored under `graph.metadata.switch` (the location used by
+ * statically-declared `@node` workflows). When absent, falls back to an empty
+ * default with the `default` port enabled.
  */
 function readSwitchMetadata(context) {
     const meta = context.node.graph?.metadata;
     if (!meta)
-        return { cases: [], defaultPort: "default" };
+        return { cases: [], defaultPort: "default", hasDefault: true };
     const switchMeta = meta["switch"];
     if (!switchMeta || !Array.isArray(switchMeta.cases)) {
-        return { cases: [], defaultPort: "default" };
+        return { cases: [], defaultPort: "default", hasDefault: true };
     }
     return {
         cases: switchMeta.cases,
         defaultPort: switchMeta.defaultPort ?? "default",
+        hasDefault: switchMeta.hasDefault !== false,
     };
 }
 /**
@@ -38,8 +43,9 @@ function isConditionExpression(cond) {
  * Executor for `core.flow.switch` nodes.
  *
  * Evaluates each case's condition in order and routes the input to the
- * first matching case's output port. When no case matches, routes to the
- * `default` output port.
+ * first matching case's output port. When no case matches:
+ * - If `hasDefault` is `true` (or omitted), routes to the `default` output port.
+ * - If `hasDefault` is `false`, returns an empty output (the input is dropped).
  *
  * Condition evaluation:
  * - `ConditionExpression` — evaluated via {@link ConditionExpressionEvaluator}.
@@ -61,6 +67,10 @@ export class SwitchGraphNodeExecutor {
                 return { [switchCase.outputPort]: inputValue };
             }
         }
+        // No case matched — route to the default port when it is enabled.
+        if (meta.hasDefault === false) {
+            return {};
+        }
         const defaultPort = meta.defaultPort ?? "default";
         return { [defaultPort]: inputValue };
     }
@@ -87,12 +97,19 @@ export class SwitchGraphNodeExecutor {
         await context.log(`Evaluating code condition`, {
             language: condition.language ?? "javascript",
         });
+        const md = context.metadata;
         const result = await evaluator.evaluate({
             code: condition.code,
             language: condition.language,
             input,
+            vars: md?.vars ?? undefined,
+            item: md?.item,
+            index: md?.index,
+            nodes: md?.nodes ??
+                undefined,
+            logger: context.logger,
         });
         return !!result;
     }
 }
-//# sourceMappingURL=SwitchGraphNodeExecutor.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SwitchGraphNodeExecutor.js","sourceRoot":"","sources":["../../../../../src/graph/engine/execution/SwitchGraphNodeExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/execution/SwitchGraphNodeExecutor\n * @summary Executor for the Switch flow-control node (DECAF-32 §22.2.2).\n * @description Evaluates each case's condition against the node's input and\n * routes the input to the first matching case's output port. Falls back to\n * the `default` output when no case matches. Supports both\n * {@link ConditionExpression} (graphical mode) and {@link CodeCondition}\n * (code mode via the pluggable {@link CodeSandboxEvaluator}).\n */\nimport type { GraphNodeExecutor } from \"./GraphNodeExecutor\";\nimport type { GraphExecutionContext } from \"./GraphExecutionContext\";\nimport type { GraphExecutionValues } from \"../types\";\nimport type {\n  SwitchCaseCondition,\n  SwitchNodeMetadata,\n  ConditionExpression,\n  CodeCondition,\n} from \"../../shared/types\";\nimport { GraphExecutionError } from \"../errors/GraphExecutionError\";\nimport { ConditionExpressionEvaluator } from \"../loops/ConditionExpressionEvaluator\";\nimport type { CodeSandboxEvaluator } from \"./CodeSandboxEvaluator\";\n\n/**\n * Reads the Switch metadata from the node definition's graph metadata.\n *\n * The metadata is stored under `graph.metadata.switch` (the location used by\n * statically-declared `@node` workflows). When absent, falls back to an empty\n * default with the `default` port enabled.\n */\nfunction readSwitchMetadata(\n  context: GraphExecutionContext\n): SwitchNodeMetadata {\n  const meta = context.node.graph?.metadata as\n    | Record<string, unknown>\n    | undefined;\n  if (!meta) return { cases: [], defaultPort: \"default\", hasDefault: true };\n  const switchMeta = meta[\"switch\"] as SwitchNodeMetadata | undefined;\n  if (!switchMeta || !Array.isArray(switchMeta.cases)) {\n    return { cases: [], defaultPort: \"default\", hasDefault: true };\n  }\n  return {\n    cases: switchMeta.cases,\n    defaultPort: switchMeta.defaultPort ?? \"default\",\n    hasDefault: switchMeta.hasDefault !== false,\n  };\n}\n\n/**\n * Detects whether a condition is a `CodeCondition` (has `type: \"code\"`).\n */\nfunction isCodeCondition(cond: SwitchCaseCondition): cond is CodeCondition {\n  return (\n    typeof cond === \"object\" &&\n    cond !== null &&\n    \"type\" in cond &&\n    cond.type === \"code\"\n  );\n}\n\n/**\n * Detects whether a condition is a `ConditionExpression` (has `op` field).\n */\nfunction isConditionExpression(\n  cond: SwitchCaseCondition\n): cond is ConditionExpression {\n  return (\n    typeof cond === \"object\" &&\n    cond !== null &&\n    \"op\" in cond &&\n    typeof cond.op === \"string\"\n  );\n}\n\n/**\n * Executor for `core.flow.switch` nodes.\n *\n * Evaluates each case's condition in order and routes the input to the\n * first matching case's output port. When no case matches:\n * - If `hasDefault` is `true` (or omitted), routes to the `default` output port.\n * - If `hasDefault` is `false`, returns an empty output (the input is dropped).\n *\n * Condition evaluation:\n * - `ConditionExpression` — evaluated via {@link ConditionExpressionEvaluator}.\n * - `CodeCondition` — evaluated via the pluggable {@link CodeSandboxEvaluator}\n *   from the engine's config. Throws `GRAPH_CODE_SANDBOX_NOT_CONFIGURED`\n *   when no evaluator is registered.\n */\nexport class SwitchGraphNodeExecutor implements GraphNodeExecutor {\n  private readonly expressionEvaluator = new ConditionExpressionEvaluator();\n\n  constructor(\n    private readonly engine?: { codeSandboxEvaluator?: CodeSandboxEvaluator }\n  ) {}\n\n  async execute(\n    input: GraphExecutionValues,\n    context: GraphExecutionContext\n  ): Promise<GraphExecutionValues> {\n    const meta = readSwitchMetadata(context);\n    const inputValue = input[\"value\"] ?? input;\n\n    for (const switchCase of meta.cases) {\n      const matches = await this.evaluateCondition(\n        switchCase.condition,\n        inputValue,\n        input,\n        context\n      );\n      if (matches) {\n        return { [switchCase.outputPort]: inputValue };\n      }\n    }\n\n    // No case matched — route to the default port when it is enabled.\n    if (meta.hasDefault === false) {\n      return {};\n    }\n    const defaultPort = meta.defaultPort ?? \"default\";\n    return { [defaultPort]: inputValue };\n  }\n\n  /**\n   * Evaluates a single switch case condition.\n   */\n  private async evaluateCondition(\n    condition: SwitchCaseCondition,\n    inputValue: unknown,\n    fullInput: GraphExecutionValues,\n    context: GraphExecutionContext\n  ): Promise<boolean> {\n    if (isCodeCondition(condition)) {\n      return this.evaluateCodeCondition(condition, fullInput, context);\n    }\n\n    if (isConditionExpression(condition)) {\n      return this.expressionEvaluator.evaluate(condition, inputValue);\n    }\n\n    throw new GraphExecutionError(\n      \"Unknown switch case condition type — must be ConditionExpression (op) or CodeCondition (type: 'code')\",\n      \"GRAPH_UNKNOWN_SWITCH_CONDITION\",\n      { condition }\n    );\n  }\n\n  /**\n   * Evaluates a code condition via the pluggable sandbox evaluator.\n   */\n  private async evaluateCodeCondition(\n    condition: CodeCondition,\n    input: GraphExecutionValues,\n    context: GraphExecutionContext\n  ): Promise<boolean> {\n    const evaluator = this.engine?.codeSandboxEvaluator;\n    if (!evaluator) {\n      throw new GraphExecutionError(\n        \"Code conditions require a CodeSandboxEvaluator to be registered in GraphExecutionEngineConfig.codeSandboxEvaluator\",\n        \"GRAPH_CODE_SANDBOX_NOT_CONFIGURED\",\n        { code: condition.code }\n      );\n    }\n\n    await context.log(`Evaluating code condition`, {\n      language: condition.language ?? \"javascript\",\n    });\n\n    const md = context.metadata as Record<string, unknown> | undefined;\n\n    const result = await evaluator.evaluate({\n      code: condition.code,\n      language: condition.language,\n      input,\n      vars: (md?.vars as Record<string, unknown> | undefined) ?? undefined,\n      item: md?.item,\n      index: md?.index as number | undefined,\n      nodes:\n        (md?.nodes as Record<string, Record<string, unknown>> | undefined) ??\n        undefined,\n      logger: context.logger as unknown as\n        | import(\"./CodeSandboxEvaluator\").SandboxLogger\n        | undefined,\n    });\n\n    return !!result;\n  }\n}\n"]}

package/lib/esm/graph/engine/execution/index.js

@@ -10,4 +10,7 @@ export * from "./GraphExecutionFrame.js";
 export * from "./GraphExecutionEngine.js";
 export * from "./CodeSandboxEvaluator.js";
 export * from "./SwitchGraphNodeExecutor.js";
-//# sourceMappingURL=index.js.map
+export * from "./CodeGraphNodeExecutor.js";
+export * from "./LogGraphNodeExecutor.js";
+export * from "./IsolatedVmCodeSandboxEvaluator.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2V4ZWN1dGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsMkNBQXdDO0FBQ3hDLHVDQUFvQztBQUNwQywwQ0FBdUM7QUFDdkMseUNBQXNDO0FBQ3RDLDBDQUF1QztBQUN2QywwQ0FBdUM7QUFDdkMsNkNBQTBDO0FBQzFDLDJDQUF3QztBQUN4QywwQ0FBdUM7QUFDdkMsb0RBQWlEIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9leGVjdXRpb25cbiAqIEBzdW1tYXJ5IEdyYXBoIGV4ZWN1dGlvbiBjb250ZXh0IGFuZCBleGVjdXRvciBpbnRlcmZhY2UuXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgZ3JhcGggZXhlY3V0aW9uIGNvbnRleHQgYW5kIG5vZGUgZXhlY3V0b3IgaW50ZXJmYWNlLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvbkNvbnRleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblJlc3VsdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25GcmFtZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25FbmdpbmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0NvZGVTYW5kYm94RXZhbHVhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Td2l0Y2hHcmFwaE5vZGVFeGVjdXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ29kZUdyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Mb2dHcmFwaE5vZGVFeGVjdXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vSXNvbGF0ZWRWbUNvZGVTYW5kYm94RXZhbHVhdG9yXCI7XG4iXX0=