@decaf-ts/integrations 0.3.7 → 0.3.9

package/lib/cjs/graph/engine/execution/GraphExecutionFrame.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphExecutionFrame = void 0;
+/**
+ * Mutable state for a single graph execution run.
+ */
+class GraphExecutionFrame {
+    constructor(runId, plan, valueStore, eventFactory) {
+        this.nodeResults = new Map();
+        this.events = [];
+        this.runId = runId;
+        this.plan = plan;
+        this.valueStore = valueStore;
+        this.eventFactory = eventFactory;
+        this.startedAt = new Date();
+    }
+    /** Records a node execution result. */
+    recordNodeResult(result) {
+        this.nodeResults.set(result.nodeId, result);
+    }
+    /** Appends an event to the run's event log. */
+    appendEvent(event) {
+        this.events.push(event);
+    }
+    /** Marks the run as finished. */
+    finish() {
+        this.finishedAt = new Date();
+    }
+}
+exports.GraphExecutionFrame = GraphExecutionFrame;
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/engine/execution/GraphExecutionResult.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraphExecutionResult = buildGraphExecutionResult;
+/**
+ * Builds a {@link GraphExecutionResult} from a completed frame.
+ */
+function buildGraphExecutionResult(frame, workflow, inputs, status, metadata) {
+    const outputs = frame.valueStore.getWorkflowValues();
+    const nodeResults = {};
+    for (const [id, result] of frame.nodeResults) {
+        nodeResults[id] = result;
+    }
+    const events = [...frame.events];
+    const runId = frame.runId;
+    return {
+        runId,
+        workflowId: workflow.name,
+        status,
+        workflow,
+        inputs: { ...inputs },
+        outputs,
+        nodeResults,
+        events,
+        startedAt: frame.startedAt,
+        finishedAt: frame.finishedAt,
+        metadata,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/engine/execution/GraphNodeExecutor.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhOb2RlRXhlY3V0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2V4ZWN1dGlvbi9HcmFwaE5vZGVFeGVjdXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9leGVjdXRpb24vR3JhcGhOb2RlRXhlY3V0b3JcbiAqIEBzdW1tYXJ5IEludGVyZmFjZSBpbXBsZW1lbnRlZCBieSBldmVyeSBncmFwaCBub2RlIGV4ZWN1dG9yLlxuICogQGRlc2NyaXB0aW9uIEEgbm9kZSBleGVjdXRvciByZWNlaXZlcyB0aGUgbm9kZSdzIHJlc29sdmVkIGlucHV0IHZhbHVlcyBhbmQgYSB7QGxpbmsgR3JhcGhFeGVjdXRpb25Db250ZXh0fSwgYW5kIHJldHVybnMgdGhlIG5vZGUncyBvdXRwdXQgdmFsdWVzLlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uQ29udGV4dCB9IGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uQ29udGV4dFwiO1xuaW1wb3J0IHR5cGUgeyBHcmFwaEV4ZWN1dGlvblZhbHVlcyB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG4vKipcbiAqIEV4ZWN1dG9yIGZvciBhIHNwZWNpZmljIGdyYXBoIG5vZGUga2luZC5cbiAqXG4gKiBJbXBsZW1lbnRhdGlvbnMgYXJlIHJlZ2lzdGVyZWQgaW4gdGhlIHtAbGluayBHcmFwaE5vZGVFeGVjdXRvclJlZ2lzdHJ5fVxuICogYW5kIHJlc29sdmVkIGJ5IHRoZSBlbmdpbmUgdXNpbmcgdGhlIG5vZGUncyBga2luZGAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR3JhcGhOb2RlRXhlY3V0b3I8XG4gIElucHV0IGV4dGVuZHMgR3JhcGhFeGVjdXRpb25WYWx1ZXMgPSBHcmFwaEV4ZWN1dGlvblZhbHVlcyxcbiAgT3V0cHV0IGV4dGVuZHMgR3JhcGhFeGVjdXRpb25WYWx1ZXMgPSBHcmFwaEV4ZWN1dGlvblZhbHVlcyxcbj4ge1xuICAvKipcbiAgICogRXhlY3V0ZXMgdGhlIG5vZGUgbG9naWMuXG4gICAqXG4gICAqIEBwYXJhbSBpbnB1dCAtIFJlc29sdmVkIGlucHV0IHZhbHVlcyBrZXllZCBieSBwb3J0IG5hbWUuXG4gICAqIEBwYXJhbSBjb250ZXh0IC0gRGVjYWYgY29udGV4dCBmb3IgZW1pdHRpbmcgcHJvZ3Jlc3MgYW5kIGV2ZW50cy5cbiAgICogQHJldHVybnMgVGhlIG5vZGUncyBvdXRwdXQgdmFsdWVzIGtleWVkIGJ5IHBvcnQgbmFtZS5cbiAgICovXG4gIGV4ZWN1dGUoXG4gICAgaW5wdXQ6IElucHV0LFxuICAgIGNvbnRleHQ6IEdyYXBoRXhlY3V0aW9uQ29udGV4dFxuICApOiBQcm9taXNlPE91dHB1dD4gfCBPdXRwdXQ7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhOb2RlRXhlY3V0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJHcmFwaE5vZGVFeGVjdXRvci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUNBLDh2REFBOHZEIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHt9O1xuLy8jIHNvdXJjZU1hcHBpbmdVUkw9ZGF0YTphcHBsaWNhdGlvbi9qc29uO2Jhc2U2NCxleUoyWlhKemFXOXVJam96TENKbWFXeGxJam9pUjNKaGNHaE9iMlJsUlhobFkzVjBiM0l1YW5NaUxDSnpiM1Z5WTJWU2IyOTBJam9pSWl3aWMyOTFjbU5sY3lJNld5SXVMaTh1TGk4dUxpOHVMaTh1TGk5emNtTXZaM0poY0dndlpXNW5hVzVsTDJWNFpXTjFkR2x2Ymk5SGNtRndhRTV2WkdWRmVHVmpkWFJ2Y2k1MGN5SmRMQ0p1WVcxbGN5STZXMTBzSW0xaGNIQnBibWR6SWpvaUlpd2ljMjkxY21ObGMwTnZiblJsYm5RaU9sc2lMeW9xWEc0Z0tpQkFiVzlrZFd4bElHbHVkR1ZuY21GMGFXOXVjeTluY21Gd2FDOWxlR1ZqZFhScGIyNHZSM0poY0doT2IyUmxSWGhsWTNWMGIzSmNiaUFxSUVCemRXMXRZWEo1SUVsdWRHVnlabUZqWlNCcGJYQnNaVzFsYm5SbFpDQmllU0JsZG1WeWVTQm5jbUZ3YUNCdWIyUmxJR1Y0WldOMWRHOXlMbHh1SUNvZ1FHUmxjMk55YVhCMGFXOXVJRUVnYm05a1pTQmxlR1ZqZFhSdmNpQnlaV05sYVhabGN5QjBhR1VnYm05a1pTZHpJSEpsYzI5c2RtVmtJR2x1Y0hWMElIWmhiSFZsY3lCaGJtUWdZU0I3UUd4cGJtc2dSM0poY0doRmVHVmpkWFJwYjI1RGIyNTBaWGgwZlN3Z1lXNWtJSEpsZEhWeWJuTWdkR2hsSUc1dlpHVW5jeUJ2ZFhSd2RYUWdkbUZzZFdWekxseHVJQ292WEc1cGJYQnZjblFnZEhsd1pTQjdJRWR5WVhCb1JYaGxZM1YwYVc5dVEyOXVkR1Y0ZENCOUlHWnliMjBnWENJdUwwZHlZWEJvUlhobFkzVjBhVzl1UTI5dWRHVjRkRndpTzF4dWFXMXdiM0owSUhSNWNHVWdleUJIY21Gd2FFVjRaV04xZEdsdmJsWmhiSFZsY3lCOUlHWnliMjBnWENJdUxpOTBlWEJsYzF3aU8xeHVYRzR2S2lwY2JpQXFJRVY0WldOMWRHOXlJR1p2Y2lCaElITndaV05wWm1saklHZHlZWEJvSUc1dlpHVWdhMmx1WkM1Y2JpQXFYRzRnS2lCSmJYQnNaVzFsYm5SaGRHbHZibk1nWVhKbElISmxaMmx6ZEdWeVpXUWdhVzRnZEdobElIdEFiR2x1YXlCSGNtRndhRTV2WkdWRmVHVmpkWFJ2Y2xKbFoybHpkSEo1ZlZ4dUlDb2dZVzVrSUhKbGMyOXNkbVZrSUdKNUlIUm9aU0JsYm1kcGJtVWdkWE5wYm1jZ2RHaGxJRzV2WkdVbmN5QmdhMmx1WkdBdVhHNGdLaTljYm1WNGNHOXlkQ0JwYm5SbGNtWmhZMlVnUjNKaGNHaE9iMlJsUlhobFkzVjBiM0k4WEc0Z0lFbHVjSFYwSUdWNGRHVnVaSE1nUjNKaGNHaEZlR1ZqZFhScGIyNVdZV3gxWlhNZ1BTQkhjbUZ3YUVWNFpXTjFkR2x2YmxaaGJIVmxjeXhjYmlBZ1QzVjBjSFYwSUdWNGRHVnVaSE1nUjNKaGNHaEZlR1ZqZFhScGIyNVdZV3gxWlhNZ1BTQkhjbUZ3YUVWNFpXTjFkR2x2YmxaaGJIVmxjeXhjYmo0Z2UxeHVJQ0F2S2lwY2JpQWdJQ29nUlhobFkzVjBaWE1nZEdobElHNXZaR1VnYkc5bmFXTXVYRzRnSUNBcVhHNGdJQ0FxSUVCd1lYSmhiU0JwYm5CMWRDQXRJRkpsYzI5c2RtVmtJR2x1Y0hWMElIWmhiSFZsY3lCclpYbGxaQ0JpZVNCd2IzSjBJRzVoYldVdVhHNGdJQ0FxSUVCd1lYSmhiU0JqYjI1MFpYaDBJQzBnUkdWallXWWdZMjl1ZEdWNGRDQm1iM0lnWlcxcGRIUnBibWNnY0hKdlozSmxjM01nWVc1a0lHVjJaVzUwY3k1Y2JpQWdJQ29nUUhKbGRIVnlibk1nVkdobElHNXZaR1VuY3lCdmRYUndkWFFnZG1Gc2RXVnpJR3RsZVdWa0lHSjVJSEJ2Y25RZ2JtRnRaUzVjYmlBZ0lDb3ZYRzRnSUdWNFpXTjFkR1VvWEc0Z0lDQWdhVzV3ZFhRNklFbHVjSFYwTEZ4dUlDQWdJR052Ym5SbGVIUTZJRWR5WVhCb1JYaGxZM1YwYVc5dVEyOXVkR1Y0ZEZ4dUlDQXBPaUJRY205dGFYTmxQRTkxZEhCMWRENGdmQ0JQZFhSd2RYUTdYRzU5WEc0aVhYMD0iXX0=

package/lib/cjs/graph/engine/execution/SwitchGraphNodeExecutor.cjs

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchGraphNodeExecutor = void 0;
+const GraphExecutionError_js_1 = require("./../errors/GraphExecutionError.cjs");
+const ConditionExpressionEvaluator_js_1 = require("./../loops/ConditionExpressionEvaluator.cjs");
+/**
+ * Reads the Switch metadata from the node definition's graph metadata.
+ */
+function readSwitchMetadata(context) {
+    const meta = context.node.graph?.metadata;
+    if (!meta)
+        return { cases: [], defaultPort: "default" };
+    const switchMeta = meta["switch"];
+    if (!switchMeta || !Array.isArray(switchMeta.cases)) {
+        return { cases: [], defaultPort: "default" };
+    }
+    return {
+        cases: switchMeta.cases,
+        defaultPort: switchMeta.defaultPort ?? "default",
+    };
+}
+/**
+ * Detects whether a condition is a `CodeCondition` (has `type: "code"`).
+ */
+function isCodeCondition(cond) {
+    return (typeof cond === "object" &&
+        cond !== null &&
+        "type" in cond &&
+        cond.type === "code");
+}
+/**
+ * Detects whether a condition is a `ConditionExpression` (has `op` field).
+ */
+function isConditionExpression(cond) {
+    return (typeof cond === "object" &&
+        cond !== null &&
+        "op" in cond &&
+        typeof cond.op === "string");
+}
+/**
+ * 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.
+ *
+ * Condition evaluation:
+ * - `ConditionExpression` — evaluated via {@link ConditionExpressionEvaluator}.
+ * - `CodeCondition` — evaluated via the pluggable {@link CodeSandboxEvaluator}
+ *   from the engine's config. Throws `GRAPH_CODE_SANDBOX_NOT_CONFIGURED`
+ *   when no evaluator is registered.
+ */
+class SwitchGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+        this.expressionEvaluator = new ConditionExpressionEvaluator_js_1.ConditionExpressionEvaluator();
+    }
+    async execute(input, context) {
+        const meta = readSwitchMetadata(context);
+        const inputValue = input["value"] ?? input;
+        for (const switchCase of meta.cases) {
+            const matches = await this.evaluateCondition(switchCase.condition, inputValue, input, context);
+            if (matches) {
+                return { [switchCase.outputPort]: inputValue };
+            }
+        }
+        const defaultPort = meta.defaultPort ?? "default";
+        return { [defaultPort]: inputValue };
+    }
+    /**
+     * Evaluates a single switch case condition.
+     */
+    async evaluateCondition(condition, inputValue, fullInput, context) {
+        if (isCodeCondition(condition)) {
+            return this.evaluateCodeCondition(condition, fullInput, context);
+        }
+        if (isConditionExpression(condition)) {
+            return this.expressionEvaluator.evaluate(condition, inputValue);
+        }
+        throw new GraphExecutionError_js_1.GraphExecutionError("Unknown switch case condition type — must be ConditionExpression (op) or CodeCondition (type: 'code')", "GRAPH_UNKNOWN_SWITCH_CONDITION", { condition });
+    }
+    /**
+     * Evaluates a code condition via the pluggable sandbox evaluator.
+     */
+    async evaluateCodeCondition(condition, input, context) {
+        const evaluator = this.engine?.codeSandboxEvaluator;
+        if (!evaluator) {
+            throw new GraphExecutionError_js_1.GraphExecutionError("Code conditions require a CodeSandboxEvaluator to be registered in GraphExecutionEngineConfig.codeSandboxEvaluator", "GRAPH_CODE_SANDBOX_NOT_CONFIGURED", { code: condition.code });
+        }
+        await context.log(`Evaluating code condition`, {
+            language: condition.language ?? "javascript",
+        });
+        const result = await evaluator.evaluate({
+            code: condition.code,
+            language: condition.language,
+            input,
+        });
+        return !!result;
+    }
+}
+exports.SwitchGraphNodeExecutor = SwitchGraphNodeExecutor;
+//# 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 */\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\" };\n  const switchMeta = meta[\"switch\"] as SwitchNodeMetadata | undefined;\n  if (!switchMeta || !Array.isArray(switchMeta.cases)) {\n    return { cases: [], defaultPort: \"default\" };\n  }\n  return {\n    cases: switchMeta.cases,\n    defaultPort: switchMeta.defaultPort ?? \"default\",\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, routes to the\n * `default` output port.\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    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 result = await evaluator.evaluate({\n      code: condition.code,\n      language: condition.language,\n      input,\n    });\n\n    return !!result;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SwitchGraphNodeExecutor.js","sourceRoot":"","sources":["SwitchGraphNodeExecutor.js"],"names":[],"mappings":"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","sourcesContent":["import { GraphExecutionError } from \"./../errors/GraphExecutionError.js\";\nimport { ConditionExpressionEvaluator } from \"./../loops/ConditionExpressionEvaluator.js\";\n/**\n * Reads the Switch metadata from the node definition's graph metadata.\n */\nfunction readSwitchMetadata(context) {\n    const meta = context.node.graph?.metadata;\n    if (!meta)\n        return { cases: [], defaultPort: \"default\" };\n    const switchMeta = meta[\"switch\"];\n    if (!switchMeta || !Array.isArray(switchMeta.cases)) {\n        return { cases: [], defaultPort: \"default\" };\n    }\n    return {\n        cases: switchMeta.cases,\n        defaultPort: switchMeta.defaultPort ?? \"default\",\n    };\n}\n/**\n * Detects whether a condition is a `CodeCondition` (has `type: \"code\"`).\n */\nfunction isCodeCondition(cond) {\n    return (typeof cond === \"object\" &&\n        cond !== null &&\n        \"type\" in cond &&\n        cond.type === \"code\");\n}\n/**\n * Detects whether a condition is a `ConditionExpression` (has `op` field).\n */\nfunction isConditionExpression(cond) {\n    return (typeof cond === \"object\" &&\n        cond !== null &&\n        \"op\" in cond &&\n        typeof cond.op === \"string\");\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, routes to the\n * `default` output port.\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 {\n    constructor(engine) {\n        this.engine = engine;\n        this.expressionEvaluator = new ConditionExpressionEvaluator();\n    }\n    async execute(input, context) {\n        const meta = readSwitchMetadata(context);\n        const inputValue = input[\"value\"] ?? input;\n        for (const switchCase of meta.cases) {\n            const matches = await this.evaluateCondition(switchCase.condition, inputValue, input, context);\n            if (matches) {\n                return { [switchCase.outputPort]: inputValue };\n            }\n        }\n        const defaultPort = meta.defaultPort ?? \"default\";\n        return { [defaultPort]: inputValue };\n    }\n    /**\n     * Evaluates a single switch case condition.\n     */\n    async evaluateCondition(condition, inputValue, fullInput, context) {\n        if (isCodeCondition(condition)) {\n            return this.evaluateCodeCondition(condition, fullInput, context);\n        }\n        if (isConditionExpression(condition)) {\n            return this.expressionEvaluator.evaluate(condition, inputValue);\n        }\n        throw new GraphExecutionError(\"Unknown switch case condition type — must be ConditionExpression (op) or CodeCondition (type: 'code')\", \"GRAPH_UNKNOWN_SWITCH_CONDITION\", { condition });\n    }\n    /**\n     * Evaluates a code condition via the pluggable sandbox evaluator.\n     */\n    async evaluateCodeCondition(condition, input, context) {\n        const evaluator = this.engine?.codeSandboxEvaluator;\n        if (!evaluator) {\n            throw new GraphExecutionError(\"Code conditions require a CodeSandboxEvaluator to be registered in GraphExecutionEngineConfig.codeSandboxEvaluator\", \"GRAPH_CODE_SANDBOX_NOT_CONFIGURED\", { code: condition.code });\n        }\n        await context.log(`Evaluating code condition`, {\n            language: condition.language ?? \"javascript\",\n        });\n        const result = await evaluator.evaluate({\n            code: condition.code,\n            language: condition.language,\n            input,\n        });\n        return !!result;\n    }\n}\n//# 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 */\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\" };\n  const switchMeta = meta[\"switch\"] as SwitchNodeMetadata | undefined;\n  if (!switchMeta || !Array.isArray(switchMeta.cases)) {\n    return { cases: [], defaultPort: \"default\" };\n  }\n  return {\n    cases: switchMeta.cases,\n    defaultPort: switchMeta.defaultPort ?? \"default\",\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, routes to the\n * `default` output port.\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    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 result = await evaluator.evaluate({\n      code: condition.code,\n      language: condition.language,\n      input,\n    });\n\n    return !!result;\n  }\n}\n"]}"]}

package/lib/cjs/graph/{execution → engine/execution}/index.cjs

@@ -26,5 +26,5 @@ __exportStar(require("./GraphExecutionFrame.cjs"), exports);
 __exportStar(require("./GraphExecutionEngine.cjs"), exports);
 __exportStar(require("./CodeSandboxEvaluator.cjs"), exports);
 __exportStar(require("./SwitchGraphNodeExecutor.cjs"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZXhlY3V0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCwyQ0FBd0M7QUFDeEMsdUNBQW9DO0FBQ3BDLDBDQUF1QztBQUN2Qyx5Q0FBc0M7QUFDdEMsMENBQXVDO0FBQ3ZDLDBDQUF1QztBQUN2Qyw2Q0FBMEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL2V4ZWN1dGlvblxuICogQHN1bW1hcnkgR3JhcGggZXhlY3V0aW9uIGNvbnRleHQgYW5kIGV4ZWN1dG9yIGludGVyZmFjZS5cbiAqIEBkZXNjcmlwdGlvbiBSZS1leHBvcnRzIHRoZSBncmFwaCBleGVjdXRpb24gY29udGV4dCBhbmQgbm9kZSBleGVjdXRvciBpbnRlcmZhY2UuXG4gKi9cbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uQ29udGV4dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhOb2RlRXhlY3V0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uUmVzdWx0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvbkZyYW1lXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvbkVuZ2luZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ29kZVNhbmRib3hFdmFsdWF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1N3aXRjaEdyYXBoTm9kZUV4ZWN1dG9yXCI7XG4iXX0=
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2V4ZWN1dGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsMkNBQXdDO0FBQ3hDLHVDQUFvQztBQUNwQywwQ0FBdUM7QUFDdkMseUNBQXNDO0FBQ3RDLDBDQUF1QztBQUN2QywwQ0FBdUM7QUFDdkMsNkNBQTBDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9leGVjdXRpb25cbiAqIEBzdW1tYXJ5IEdyYXBoIGV4ZWN1dGlvbiBjb250ZXh0IGFuZCBleGVjdXRvciBpbnRlcmZhY2UuXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgZ3JhcGggZXhlY3V0aW9uIGNvbnRleHQgYW5kIG5vZGUgZXhlY3V0b3IgaW50ZXJmYWNlLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvbkNvbnRleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblJlc3VsdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25GcmFtZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25FbmdpbmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0NvZGVTYW5kYm94RXZhbHVhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Td2l0Y2hHcmFwaE5vZGVFeGVjdXRvclwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7Ozs7R0FJRztBQUNILDZEQUEyQztBQUMzQyx5REFBdUM7QUFDdkMsNERBQTBDO0FBQzFDLDJEQUF5QztBQUN6Qyw0REFBMEM7QUFDMUMsNERBQTBDO0FBQzFDLCtEQUE2QztBQUM3QyxzaUNBQXNpQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvZXhlY3V0aW9uXG4gKiBAc3VtbWFyeSBHcmFwaCBleGVjdXRpb24gY29udGV4dCBhbmQgZXhlY3V0b3IgaW50ZXJmYWNlLlxuICogQGRlc2NyaXB0aW9uIFJlLWV4cG9ydHMgdGhlIGdyYXBoIGV4ZWN1dGlvbiBjb250ZXh0IGFuZCBub2RlIGV4ZWN1dG9yIGludGVyZmFjZS5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25Db250ZXh0LmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaE5vZGVFeGVjdXRvci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25SZXN1bHQuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uRnJhbWUuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uRW5naW5lLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Db2RlU2FuZGJveEV2YWx1YXRvci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vU3dpdGNoR3JhcGhOb2RlRXhlY3V0b3IuanNcIjtcbi8vIyBzb3VyY2VNYXBwaW5nVVJMPWRhdGE6YXBwbGljYXRpb24vanNvbjtiYXNlNjQsZXlKMlpYSnphVzl1SWpvekxDSm1hV3hsSWpvaWFXNWtaWGd1YW5NaUxDSnpiM1Z5WTJWU2IyOTBJam9pSWl3aWMyOTFjbU5sY3lJNld5SXVMaTh1TGk4dUxpOHVMaTh1TGk5emNtTXZaM0poY0dndlpXNW5hVzVsTDJWNFpXTjFkR2x2Ymk5cGJtUmxlQzUwY3lKZExDSnVZVzFsY3lJNlcxMHNJbTFoY0hCcGJtZHpJam9pUVVGQlFUczdPenRIUVVsSE8wRkJRMGdzTWtOQlFYZERPMEZCUTNoRExIVkRRVUZ2UXp0QlFVTndReXd3UTBGQmRVTTdRVUZEZGtNc2VVTkJRWE5ETzBGQlEzUkRMREJEUVVGMVF6dEJRVU4yUXl3d1EwRkJkVU03UVVGRGRrTXNOa05CUVRCRElpd2ljMjkxY21ObGMwTnZiblJsYm5RaU9sc2lMeW9xWEc0Z0tpQkFiVzlrZFd4bElHbHVkR1ZuY21GMGFXOXVjeTluY21Gd2FDOWxlR1ZqZFhScGIyNWNiaUFxSUVCemRXMXRZWEo1SUVkeVlYQm9JR1Y0WldOMWRHbHZiaUJqYjI1MFpYaDBJR0Z1WkNCbGVHVmpkWFJ2Y2lCcGJuUmxjbVpoWTJVdVhHNGdLaUJBWkdWelkzSnBjSFJwYjI0Z1VtVXRaWGh3YjNKMGN5QjBhR1VnWjNKaGNHZ2daWGhsWTNWMGFXOXVJR052Ym5SbGVIUWdZVzVrSUc1dlpHVWdaWGhsWTNWMGIzSWdhVzUwWlhKbVlXTmxMbHh1SUNvdlhHNWxlSEJ2Y25RZ0tpQm1jbTl0SUZ3aUxpOUhjbUZ3YUVWNFpXTjFkR2x2YmtOdmJuUmxlSFJjSWp0Y2JtVjRjRzl5ZENBcUlHWnliMjBnWENJdUwwZHlZWEJvVG05a1pVVjRaV04xZEc5eVhDSTdYRzVsZUhCdmNuUWdLaUJtY205dElGd2lMaTlIY21Gd2FFVjRaV04xZEdsdmJsSmxjM1ZzZEZ3aU8xeHVaWGh3YjNKMElDb2dabkp2YlNCY0lpNHZSM0poY0doRmVHVmpkWFJwYjI1R2NtRnRaVndpTzF4dVpYaHdiM0owSUNvZ1puSnZiU0JjSWk0dlIzSmhjR2hGZUdWamRYUnBiMjVGYm1kcGJtVmNJanRjYm1WNGNHOXlkQ0FxSUdaeWIyMGdYQ0l1TDBOdlpHVlRZVzVrWW05NFJYWmhiSFZoZEc5eVhDSTdYRzVsZUhCdmNuUWdLaUJtY205dElGd2lMaTlUZDJsMFkyaEhjbUZ3YUU1dlpHVkZlR1ZqZFhSdmNsd2lPMXh1SWwxOSJdfQ==

package/lib/cjs/graph/engine/index.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @module integrations/graph/engine
+ * @summary Graph execution engine (backend-only).
+ * @description Reference interpreter for Decaf graph workflows. Executes
+ * workflows declared with `@decaf-ts/ui-decorators/graph`, emits events
+ * through Decaf's Observable pipeline, supports structured loops, configurable
+ * value stores, and pinnable/cacheable nodes.
+ *
+ * Re-exports `../shared` so backend consumers have a single import surface.
+ */
+// Re-export frontend-safe declarations so backend consumers have one surface.
+__exportStar(require("./../shared/index.cjs"), exports);
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./decorators.cjs"), exports);
+__exportStar(require("./errors/GraphExecutionError.cjs"), exports);
+__exportStar(require("./errors/GraphCycleError.cjs"), exports);
+__exportStar(require("./errors/GraphInputError.cjs"), exports);
+__exportStar(require("./errors/GraphLoopLimitError.cjs"), exports);
+__exportStar(require("./errors/GraphPinningError.cjs"), exports);
+__exportStar(require("./errors/GraphPortError.cjs"), exports);
+__exportStar(require("./errors/GraphStoreError.cjs"), exports);
+__exportStar(require("./errors/GraphTopologyError.cjs"), exports);
+__exportStar(require("./events/GraphExecutionEvent.cjs"), exports);
+__exportStar(require("./events/GraphExecutionObserver.cjs"), exports);
+__exportStar(require("./events/GraphExecutionEventEmitter.cjs"), exports);
+__exportStar(require("./events/GraphExecutionEventFactory.cjs"), exports);
+__exportStar(require("./execution/GraphExecutionContext.cjs"), exports);
+__exportStar(require("./execution/GraphNodeExecutor.cjs"), exports);
+__exportStar(require("./execution/GraphExecutionFrame.cjs"), exports);
+__exportStar(require("./execution/GraphExecutionResult.cjs"), exports);
+__exportStar(require("./execution/GraphExecutionEngine.cjs"), exports);
+__exportStar(require("./execution/CodeSandboxEvaluator.cjs"), exports);
+__exportStar(require("./execution/SwitchGraphNodeExecutor.cjs"), exports);
+__exportStar(require("./registry/GraphNodeExecutorRegistry.cjs"), exports);
+__exportStar(require("./registry/GraphNodeExecutorResolver.cjs"), exports);
+__exportStar(require("./store/GraphValueKey.cjs"), exports);
+__exportStar(require("./store/GraphCachedValue.cjs"), exports);
+__exportStar(require("./store/GraphValueStoreAdapter.cjs"), exports);
+__exportStar(require("./store/InMemoryGraphValueStoreAdapter.cjs"), exports);
+__exportStar(require("./store/GraphValueStore.cjs"), exports);
+__exportStar(require("./planning/GraphExecutionPlanNode.cjs"), exports);
+__exportStar(require("./planning/GraphExecutionPlanEdge.cjs"), exports);
+__exportStar(require("./planning/GraphExecutionPlanLayer.cjs"), exports);
+__exportStar(require("./planning/GraphExecutionPlan.cjs"), exports);
+__exportStar(require("./planning/GraphRelationResolver.cjs"), exports);
+__exportStar(require("./planning/GraphExecutionPlanner.cjs"), exports);
+__exportStar(require("./planning/GraphTopology.cjs"), exports);
+// Validation (TASK-215)
+__exportStar(require("./validation/GraphDefinitionValidator.cjs"), exports);
+__exportStar(require("./validation/GraphPortSchemaResolver.cjs"), exports);
+__exportStar(require("./validation/GraphValueValidator.cjs"), exports);
+// Loops (TASK-216)
+__exportStar(require("./loops/GraphConditionEvaluator.cjs"), exports);
+__exportStar(require("./loops/ConditionExpressionEvaluator.cjs"), exports);
+__exportStar(require("./loops/GraphLoopExecutionContext.cjs"), exports);
+__exportStar(require("./loops/ForeachGraphNodeExecutor.cjs"), exports);
+__exportStar(require("./loops/WhileGraphNodeExecutor.cjs"), exports);
+__exportStar(require("./loops/UntilGraphNodeExecutor.cjs"), exports);
+// Pinning (TASK-217/218)
+__exportStar(require("./pinning/GraphPinningMetadata.cjs"), exports);
+__exportStar(require("./pinning/GraphPinningPolicy.cjs"), exports);
+__exportStar(require("./pinning/GraphPinningDependencyResolver.cjs"), exports);
+__exportStar(require("./pinning/GraphPinningService.cjs"), exports);
+// Snapshots (TASK-219)
+__exportStar(require("./snapshots/GraphExecutionSnapshotMapper.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;GASG;AACH,8EAA8E;AAC9E,uDAAqC;AACrC,iDAA+B;AAC/B,6CAA2B;AAC3B,kDAAgC;AAChC,kEAAgD;AAChD,8DAA4C;AAC5C,8DAA4C;AAC5C,kEAAgD;AAChD,gEAA8C;AAC9C,6DAA2C;AAC3C,8DAA4C;AAC5C,iEAA+C;AAC/C,kEAAgD;AAChD,qEAAmD;AACnD,yEAAuD;AACvD,yEAAuD;AACvD,uEAAqD;AACrD,mEAAiD;AACjD,qEAAmD;AACnD,sEAAoD;AACpD,sEAAoD;AACpD,sEAAoD;AACpD,yEAAuD;AACvD,0EAAwD;AACxD,0EAAwD;AACxD,2DAAyC;AACzC,8DAA4C;AAC5C,oEAAkD;AAClD,4EAA0D;AAC1D,6DAA2C;AAC3C,uEAAqD;AACrD,uEAAqD;AACrD,wEAAsD;AACtD,mEAAiD;AACjD,sEAAoD;AACpD,sEAAoD;AACpD,8DAA4C;AAC5C,wBAAwB;AACxB,2EAAyD;AACzD,0EAAwD;AACxD,sEAAoD;AACpD,mBAAmB;AACnB,qEAAmD;AACnD,0EAAwD;AACxD,uEAAqD;AACrD,sEAAoD;AACpD,oEAAkD;AAClD,oEAAkD;AAClD,yBAAyB;AACzB,oEAAkD;AAClD,kEAAgD;AAChD,8EAA4D;AAC5D,mEAAiD;AACjD,uBAAuB;AACvB,8EAA4D;AAC5D,05KAA05K","sourcesContent":["/**\n * @module integrations/graph/engine\n * @summary Graph execution engine (backend-only).\n * @description Reference interpreter for Decaf graph workflows. Executes\n * workflows declared with `@decaf-ts/ui-decorators/graph`, emits events\n * through Decaf's Observable pipeline, supports structured loops, configurable\n * value stores, and pinnable/cacheable nodes.\n *\n * Re-exports `../shared` so backend consumers have a single import surface.\n */\n// Re-export frontend-safe declarations so backend consumers have one surface.\nexport * from \"./../shared/index.js\";\nexport * from \"./constants.js\";\nexport * from \"./types.js\";\nexport * from \"./decorators.js\";\nexport * from \"./errors/GraphExecutionError.js\";\nexport * from \"./errors/GraphCycleError.js\";\nexport * from \"./errors/GraphInputError.js\";\nexport * from \"./errors/GraphLoopLimitError.js\";\nexport * from \"./errors/GraphPinningError.js\";\nexport * from \"./errors/GraphPortError.js\";\nexport * from \"./errors/GraphStoreError.js\";\nexport * from \"./errors/GraphTopologyError.js\";\nexport * from \"./events/GraphExecutionEvent.js\";\nexport * from \"./events/GraphExecutionObserver.js\";\nexport * from \"./events/GraphExecutionEventEmitter.js\";\nexport * from \"./events/GraphExecutionEventFactory.js\";\nexport * from \"./execution/GraphExecutionContext.js\";\nexport * from \"./execution/GraphNodeExecutor.js\";\nexport * from \"./execution/GraphExecutionFrame.js\";\nexport * from \"./execution/GraphExecutionResult.js\";\nexport * from \"./execution/GraphExecutionEngine.js\";\nexport * from \"./execution/CodeSandboxEvaluator.js\";\nexport * from \"./execution/SwitchGraphNodeExecutor.js\";\nexport * from \"./registry/GraphNodeExecutorRegistry.js\";\nexport * from \"./registry/GraphNodeExecutorResolver.js\";\nexport * from \"./store/GraphValueKey.js\";\nexport * from \"./store/GraphCachedValue.js\";\nexport * from \"./store/GraphValueStoreAdapter.js\";\nexport * from \"./store/InMemoryGraphValueStoreAdapter.js\";\nexport * from \"./store/GraphValueStore.js\";\nexport * from \"./planning/GraphExecutionPlanNode.js\";\nexport * from \"./planning/GraphExecutionPlanEdge.js\";\nexport * from \"./planning/GraphExecutionPlanLayer.js\";\nexport * from \"./planning/GraphExecutionPlan.js\";\nexport * from \"./planning/GraphRelationResolver.js\";\nexport * from \"./planning/GraphExecutionPlanner.js\";\nexport * from \"./planning/GraphTopology.js\";\n// Validation (TASK-215)\nexport * from \"./validation/GraphDefinitionValidator.js\";\nexport * from \"./validation/GraphPortSchemaResolver.js\";\nexport * from \"./validation/GraphValueValidator.js\";\n// Loops (TASK-216)\nexport * from \"./loops/GraphConditionEvaluator.js\";\nexport * from \"./loops/ConditionExpressionEvaluator.js\";\nexport * from \"./loops/GraphLoopExecutionContext.js\";\nexport * from \"./loops/ForeachGraphNodeExecutor.js\";\nexport * from \"./loops/WhileGraphNodeExecutor.js\";\nexport * from \"./loops/UntilGraphNodeExecutor.js\";\n// Pinning (TASK-217/218)\nexport * from \"./pinning/GraphPinningMetadata.js\";\nexport * from \"./pinning/GraphPinningPolicy.js\";\nexport * from \"./pinning/GraphPinningDependencyResolver.js\";\nexport * from \"./pinning/GraphPinningService.js\";\n// Snapshots (TASK-219)\nexport * from \"./snapshots/GraphExecutionSnapshotMapper.js\";\n//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/engine/loops/ConditionExpressionEvaluator.cjs

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionExpressionEvaluator = void 0;
+const GraphExecutionError_js_1 = require("./../errors/GraphExecutionError.cjs");
+/**
+ * Evaluates a {@link ConditionExpression} against the given state.
+ *
+ * `ExprValue` resolution:
+ * - `{ const: x }` → the literal value `x`.
+ * - `{ path: "a.b" }` → dotted-path lookup into `state`.
+ * - `{ step: "nodeId", path: "out" }` → cross-node reference; in v1 the state
+ *   is expected to contain a `nodes` map keyed by node id (reserved for future
+ *   multi-step evaluation; falls back to `state` lookup when absent).
+ */
+class ConditionExpressionEvaluator {
+    /**
+     * Evaluates a condition expression to a boolean.
+     *
+     * @param expr - The condition expression.
+     * @param state - The current evaluation state (loop state or execution values).
+     * @returns `true` when the expression evaluates to a truthy/positive result.
+     */
+    evaluate(expr, state) {
+        switch (expr.op) {
+            case "eq":
+                return this.resolveValue(expr.left, state) === this.resolveValue(expr.right, state);
+            case "neq":
+                return this.resolveValue(expr.left, state) !== this.resolveValue(expr.right, state);
+            case "gt":
+                return Number(this.resolveValue(expr.left, state)) > Number(this.resolveValue(expr.right, state));
+            case "gte":
+                return Number(this.resolveValue(expr.left, state)) >= Number(this.resolveValue(expr.right, state));
+            case "lt":
+                return Number(this.resolveValue(expr.left, state)) < Number(this.resolveValue(expr.right, state));
+            case "lte":
+                return Number(this.resolveValue(expr.left, state)) <= Number(this.resolveValue(expr.right, state));
+            case "and":
+                return expr.conditions.every((c) => this.evaluate(c, state));
+            case "or":
+                return expr.conditions.some((c) => this.evaluate(c, state));
+            case "not":
+                return !this.evaluate(expr.condition, state);
+            case "exists":
+                return this.resolveValue(expr.value, state) !== undefined && this.resolveValue(expr.value, state) !== null;
+            default:
+                throw new GraphExecutionError_js_1.GraphExecutionError(`Unknown ConditionExpression op '${expr.op}'`, "GRAPH_UNKNOWN_CONDITION_OP", { expr });
+        }
+    }
+    /**
+     * Resolves an {@link ExprValue} against the current state.
+     */
+    resolveValue(ref, state) {
+        if ("const" in ref) {
+            return ref.const;
+        }
+        if ("path" in ref && !("step" in ref)) {
+            return this.resolvePath(ref.path, state);
+        }
+        if ("step" in ref && "path" in ref) {
+            const nodes = state?.["nodes"];
+            if (nodes && typeof nodes === "object") {
+                const nodeState = nodes[ref.step];
+                return this.resolvePath(ref.path, nodeState);
+            }
+            return this.resolvePath(ref.path, state);
+        }
+        throw new GraphExecutionError_js_1.GraphExecutionError("Invalid ExprValue: must have `const`, `path`, or `step`+`path`", "GRAPH_INVALID_EXPR_VALUE", { ref });
+    }
+    /**
+     * Resolves a dotted path into a target object.
+     */
+    resolvePath(path, target) {
+        if (!path)
+            return target;
+        const parts = path.split(".");
+        let current = target;
+        for (const part of parts) {
+            if (current == null)
+                return undefined;
+            current = current[part];
+        }
+        return current;
+    }
+}
+exports.ConditionExpressionEvaluator = ConditionExpressionEvaluator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConditionExpressionEvaluator.js","sourceRoot":"","sources":["../../../../../src/graph/engine/loops/ConditionExpressionEvaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/loops/ConditionExpressionEvaluator\n * @summary Evaluator for the ALFRED-5 `ConditionExpression` DSL (DECAF-32 §22.3).\n * @description Evaluates declarative, serializable condition expressions with\n * `eq`/`neq`/`gt`/`gte`/`lt`/`lte`/`and`/`or`/`not`/`exists` operators and\n * `ExprValue` references (`{const}`, `{path}`, `{step, path}`).\n */\nimport type { ConditionExpression, ExprValue } from \"../../shared/types\";\nimport { GraphExecutionError } from \"../errors/GraphExecutionError\";\n\n/**\n * Evaluates a {@link ConditionExpression} against the given state.\n *\n * `ExprValue` resolution:\n * - `{ const: x }` → the literal value `x`.\n * - `{ path: \"a.b\" }` → dotted-path lookup into `state`.\n * - `{ step: \"nodeId\", path: \"out\" }` → cross-node reference; in v1 the state\n *   is expected to contain a `nodes` map keyed by node id (reserved for future\n *   multi-step evaluation; falls back to `state` lookup when absent).\n */\nexport class ConditionExpressionEvaluator {\n  /**\n   * Evaluates a condition expression to a boolean.\n   *\n   * @param expr - The condition expression.\n   * @param state - The current evaluation state (loop state or execution values).\n   * @returns `true` when the expression evaluates to a truthy/positive result.\n   */\n  evaluate(expr: ConditionExpression, state: unknown): boolean {\n    switch (expr.op) {\n      case \"eq\":\n        return this.resolveValue(expr.left, state) === this.resolveValue(expr.right, state);\n      case \"neq\":\n        return this.resolveValue(expr.left, state) !== this.resolveValue(expr.right, state);\n      case \"gt\":\n        return Number(this.resolveValue(expr.left, state)) > Number(this.resolveValue(expr.right, state));\n      case \"gte\":\n        return Number(this.resolveValue(expr.left, state)) >= Number(this.resolveValue(expr.right, state));\n      case \"lt\":\n        return Number(this.resolveValue(expr.left, state)) < Number(this.resolveValue(expr.right, state));\n      case \"lte\":\n        return Number(this.resolveValue(expr.left, state)) <= Number(this.resolveValue(expr.right, state));\n      case \"and\":\n        return expr.conditions.every((c) => this.evaluate(c, state));\n      case \"or\":\n        return expr.conditions.some((c) => this.evaluate(c, state));\n      case \"not\":\n        return !this.evaluate(expr.condition, state);\n      case \"exists\":\n        return this.resolveValue(expr.value, state) !== undefined && this.resolveValue(expr.value, state) !== null;\n      default:\n        throw new GraphExecutionError(\n          `Unknown ConditionExpression op '${(expr as { op: string }).op}'`,\n          \"GRAPH_UNKNOWN_CONDITION_OP\",\n          { expr }\n        );\n    }\n  }\n\n  /**\n   * Resolves an {@link ExprValue} against the current state.\n   */\n  private resolveValue(ref: ExprValue, state: unknown): unknown {\n    if (\"const\" in ref) {\n      return ref.const;\n    }\n    if (\"path\" in ref && !(\"step\" in ref)) {\n      return this.resolvePath(ref.path, state);\n    }\n    if (\"step\" in ref && \"path\" in ref) {\n      const nodes = (state as Record<string, unknown> | null)?.[\"nodes\"];\n      if (nodes && typeof nodes === \"object\") {\n        const nodeState = (nodes as Record<string, unknown>)[ref.step];\n        return this.resolvePath(ref.path, nodeState);\n      }\n      return this.resolvePath(ref.path, state);\n    }\n    throw new GraphExecutionError(\n      \"Invalid ExprValue: must have `const`, `path`, or `step`+`path`\",\n      \"GRAPH_INVALID_EXPR_VALUE\",\n      { ref }\n    );\n  }\n\n  /**\n   * Resolves a dotted path into a target object.\n   */\n  private resolvePath(path: string, target: unknown): unknown {\n    if (!path) return target;\n    const parts = path.split(\".\");\n    let current: unknown = target;\n    for (const part of parts) {\n      if (current == null) return undefined;\n      current = (current as Record<string, unknown>)[part];\n    }\n    return current;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConditionExpressionEvaluator.js","sourceRoot":"","sources":["ConditionExpressionEvaluator.js"],"names":[],"mappings":"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","sourcesContent":["import { GraphExecutionError } from \"./../errors/GraphExecutionError.js\";\n/**\n * Evaluates a {@link ConditionExpression} against the given state.\n *\n * `ExprValue` resolution:\n * - `{ const: x }` → the literal value `x`.\n * - `{ path: \"a.b\" }` → dotted-path lookup into `state`.\n * - `{ step: \"nodeId\", path: \"out\" }` → cross-node reference; in v1 the state\n *   is expected to contain a `nodes` map keyed by node id (reserved for future\n *   multi-step evaluation; falls back to `state` lookup when absent).\n */\nexport class ConditionExpressionEvaluator {\n    /**\n     * Evaluates a condition expression to a boolean.\n     *\n     * @param expr - The condition expression.\n     * @param state - The current evaluation state (loop state or execution values).\n     * @returns `true` when the expression evaluates to a truthy/positive result.\n     */\n    evaluate(expr, state) {\n        switch (expr.op) {\n            case \"eq\":\n                return this.resolveValue(expr.left, state) === this.resolveValue(expr.right, state);\n            case \"neq\":\n                return this.resolveValue(expr.left, state) !== this.resolveValue(expr.right, state);\n            case \"gt\":\n                return Number(this.resolveValue(expr.left, state)) > Number(this.resolveValue(expr.right, state));\n            case \"gte\":\n                return Number(this.resolveValue(expr.left, state)) >= Number(this.resolveValue(expr.right, state));\n            case \"lt\":\n                return Number(this.resolveValue(expr.left, state)) < Number(this.resolveValue(expr.right, state));\n            case \"lte\":\n                return Number(this.resolveValue(expr.left, state)) <= Number(this.resolveValue(expr.right, state));\n            case \"and\":\n                return expr.conditions.every((c) => this.evaluate(c, state));\n            case \"or\":\n                return expr.conditions.some((c) => this.evaluate(c, state));\n            case \"not\":\n                return !this.evaluate(expr.condition, state);\n            case \"exists\":\n                return this.resolveValue(expr.value, state) !== undefined && this.resolveValue(expr.value, state) !== null;\n            default:\n                throw new GraphExecutionError(`Unknown ConditionExpression op '${expr.op}'`, \"GRAPH_UNKNOWN_CONDITION_OP\", { expr });\n        }\n    }\n    /**\n     * Resolves an {@link ExprValue} against the current state.\n     */\n    resolveValue(ref, state) {\n        if (\"const\" in ref) {\n            return ref.const;\n        }\n        if (\"path\" in ref && !(\"step\" in ref)) {\n            return this.resolvePath(ref.path, state);\n        }\n        if (\"step\" in ref && \"path\" in ref) {\n            const nodes = state?.[\"nodes\"];\n            if (nodes && typeof nodes === \"object\") {\n                const nodeState = nodes[ref.step];\n                return this.resolvePath(ref.path, nodeState);\n            }\n            return this.resolvePath(ref.path, state);\n        }\n        throw new GraphExecutionError(\"Invalid ExprValue: must have `const`, `path`, or `step`+`path`\", \"GRAPH_INVALID_EXPR_VALUE\", { ref });\n    }\n    /**\n     * Resolves a dotted path into a target object.\n     */\n    resolvePath(path, target) {\n        if (!path)\n            return target;\n        const parts = path.split(\".\");\n        let current = target;\n        for (const part of parts) {\n            if (current == null)\n                return undefined;\n            current = current[part];\n        }\n        return current;\n    }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConditionExpressionEvaluator.js","sourceRoot":"","sources":["../../../../../src/graph/engine/loops/ConditionExpressionEvaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/loops/ConditionExpressionEvaluator\n * @summary Evaluator for the ALFRED-5 `ConditionExpression` DSL (DECAF-32 §22.3).\n * @description Evaluates declarative, serializable condition expressions with\n * `eq`/`neq`/`gt`/`gte`/`lt`/`lte`/`and`/`or`/`not`/`exists` operators and\n * `ExprValue` references (`{const}`, `{path}`, `{step, path}`).\n */\nimport type { ConditionExpression, ExprValue } from \"../../shared/types\";\nimport { GraphExecutionError } from \"../errors/GraphExecutionError\";\n\n/**\n * Evaluates a {@link ConditionExpression} against the given state.\n *\n * `ExprValue` resolution:\n * - `{ const: x }` → the literal value `x`.\n * - `{ path: \"a.b\" }` → dotted-path lookup into `state`.\n * - `{ step: \"nodeId\", path: \"out\" }` → cross-node reference; in v1 the state\n *   is expected to contain a `nodes` map keyed by node id (reserved for future\n *   multi-step evaluation; falls back to `state` lookup when absent).\n */\nexport class ConditionExpressionEvaluator {\n  /**\n   * Evaluates a condition expression to a boolean.\n   *\n   * @param expr - The condition expression.\n   * @param state - The current evaluation state (loop state or execution values).\n   * @returns `true` when the expression evaluates to a truthy/positive result.\n   */\n  evaluate(expr: ConditionExpression, state: unknown): boolean {\n    switch (expr.op) {\n      case \"eq\":\n        return this.resolveValue(expr.left, state) === this.resolveValue(expr.right, state);\n      case \"neq\":\n        return this.resolveValue(expr.left, state) !== this.resolveValue(expr.right, state);\n      case \"gt\":\n        return Number(this.resolveValue(expr.left, state)) > Number(this.resolveValue(expr.right, state));\n      case \"gte\":\n        return Number(this.resolveValue(expr.left, state)) >= Number(this.resolveValue(expr.right, state));\n      case \"lt\":\n        return Number(this.resolveValue(expr.left, state)) < Number(this.resolveValue(expr.right, state));\n      case \"lte\":\n        return Number(this.resolveValue(expr.left, state)) <= Number(this.resolveValue(expr.right, state));\n      case \"and\":\n        return expr.conditions.every((c) => this.evaluate(c, state));\n      case \"or\":\n        return expr.conditions.some((c) => this.evaluate(c, state));\n      case \"not\":\n        return !this.evaluate(expr.condition, state);\n      case \"exists\":\n        return this.resolveValue(expr.value, state) !== undefined && this.resolveValue(expr.value, state) !== null;\n      default:\n        throw new GraphExecutionError(\n          `Unknown ConditionExpression op '${(expr as { op: string }).op}'`,\n          \"GRAPH_UNKNOWN_CONDITION_OP\",\n          { expr }\n        );\n    }\n  }\n\n  /**\n   * Resolves an {@link ExprValue} against the current state.\n   */\n  private resolveValue(ref: ExprValue, state: unknown): unknown {\n    if (\"const\" in ref) {\n      return ref.const;\n    }\n    if (\"path\" in ref && !(\"step\" in ref)) {\n      return this.resolvePath(ref.path, state);\n    }\n    if (\"step\" in ref && \"path\" in ref) {\n      const nodes = (state as Record<string, unknown> | null)?.[\"nodes\"];\n      if (nodes && typeof nodes === \"object\") {\n        const nodeState = (nodes as Record<string, unknown>)[ref.step];\n        return this.resolvePath(ref.path, nodeState);\n      }\n      return this.resolvePath(ref.path, state);\n    }\n    throw new GraphExecutionError(\n      \"Invalid ExprValue: must have `const`, `path`, or `step`+`path`\",\n      \"GRAPH_INVALID_EXPR_VALUE\",\n      { ref }\n    );\n  }\n\n  /**\n   * Resolves a dotted path into a target object.\n   */\n  private resolvePath(path: string, target: unknown): unknown {\n    if (!path) return target;\n    const parts = path.split(\".\");\n    let current: unknown = target;\n    for (const part of parts) {\n      if (current == null) return undefined;\n      current = (current as Record<string, unknown>)[part];\n    }\n    return current;\n  }\n}\n"]}"]}