@decaf-ts/integrations 0.3.8 → 0.3.9

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

@@ -0,0 +1,98 @@
+import { GraphExecutionError } from "./../errors/GraphExecutionError.js";
+import { ConditionExpressionEvaluator } from "./../loops/ConditionExpressionEvaluator.js";
+/**
+ * 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.
+ */
+export class SwitchGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+        this.expressionEvaluator = new 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("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("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;
+    }
+}
+//# 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/esm/graph/engine/execution/index.js

@@ -0,0 +1,13 @@
+/**
+ * @module integrations/graph/execution
+ * @summary Graph execution context and executor interface.
+ * @description Re-exports the graph execution context and node executor interface.
+ */
+export * from "./GraphExecutionContext.js";
+export * from "./GraphNodeExecutor.js";
+export * from "./GraphExecutionResult.js";
+export * from "./GraphExecutionFrame.js";
+export * from "./GraphExecutionEngine.js";
+export * from "./CodeSandboxEvaluator.js";
+export * from "./SwitchGraphNodeExecutor.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2V4ZWN1dGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsMkNBQXdDO0FBQ3hDLHVDQUFvQztBQUNwQywwQ0FBdUM7QUFDdkMseUNBQXNDO0FBQ3RDLDBDQUF1QztBQUN2QywwQ0FBdUM7QUFDdkMsNkNBQTBDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9leGVjdXRpb25cbiAqIEBzdW1tYXJ5IEdyYXBoIGV4ZWN1dGlvbiBjb250ZXh0IGFuZCBleGVjdXRvciBpbnRlcmZhY2UuXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgZ3JhcGggZXhlY3V0aW9uIGNvbnRleHQgYW5kIG5vZGUgZXhlY3V0b3IgaW50ZXJmYWNlLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvbkNvbnRleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblJlc3VsdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25GcmFtZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25FbmdpbmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0NvZGVTYW5kYm94RXZhbHVhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Td2l0Y2hHcmFwaE5vZGVFeGVjdXRvclwiO1xuIl19

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

@@ -0,0 +1,67 @@
+/**
+ * @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.
+export * from "./../shared/index.js";
+export * from "./constants.js";
+export * from "./types.js";
+export * from "./decorators.js";
+export * from "./errors/GraphExecutionError.js";
+export * from "./errors/GraphCycleError.js";
+export * from "./errors/GraphInputError.js";
+export * from "./errors/GraphLoopLimitError.js";
+export * from "./errors/GraphPinningError.js";
+export * from "./errors/GraphPortError.js";
+export * from "./errors/GraphStoreError.js";
+export * from "./errors/GraphTopologyError.js";
+export * from "./events/GraphExecutionEvent.js";
+export * from "./events/GraphExecutionObserver.js";
+export * from "./events/GraphExecutionEventEmitter.js";
+export * from "./events/GraphExecutionEventFactory.js";
+export * from "./execution/GraphExecutionContext.js";
+export * from "./execution/GraphNodeExecutor.js";
+export * from "./execution/GraphExecutionFrame.js";
+export * from "./execution/GraphExecutionResult.js";
+export * from "./execution/GraphExecutionEngine.js";
+export * from "./execution/CodeSandboxEvaluator.js";
+export * from "./execution/SwitchGraphNodeExecutor.js";
+export * from "./registry/GraphNodeExecutorRegistry.js";
+export * from "./registry/GraphNodeExecutorResolver.js";
+export * from "./store/GraphValueKey.js";
+export * from "./store/GraphCachedValue.js";
+export * from "./store/GraphValueStoreAdapter.js";
+export * from "./store/InMemoryGraphValueStoreAdapter.js";
+export * from "./store/GraphValueStore.js";
+export * from "./planning/GraphExecutionPlanNode.js";
+export * from "./planning/GraphExecutionPlanEdge.js";
+export * from "./planning/GraphExecutionPlanLayer.js";
+export * from "./planning/GraphExecutionPlan.js";
+export * from "./planning/GraphRelationResolver.js";
+export * from "./planning/GraphExecutionPlanner.js";
+export * from "./planning/GraphTopology.js";
+// Validation (TASK-215)
+export * from "./validation/GraphDefinitionValidator.js";
+export * from "./validation/GraphPortSchemaResolver.js";
+export * from "./validation/GraphValueValidator.js";
+// Loops (TASK-216)
+export * from "./loops/GraphConditionEvaluator.js";
+export * from "./loops/ConditionExpressionEvaluator.js";
+export * from "./loops/GraphLoopExecutionContext.js";
+export * from "./loops/ForeachGraphNodeExecutor.js";
+export * from "./loops/WhileGraphNodeExecutor.js";
+export * from "./loops/UntilGraphNodeExecutor.js";
+// Pinning (TASK-217/218)
+export * from "./pinning/GraphPinningMetadata.js";
+export * from "./pinning/GraphPinningPolicy.js";
+export * from "./pinning/GraphPinningDependencyResolver.js";
+export * from "./pinning/GraphPinningService.js";
+// Snapshots (TASK-219)
+export * from "./snapshots/GraphExecutionSnapshotMapper.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/loops/ConditionExpressionEvaluator.js

@@ -0,0 +1,82 @@
+import { GraphExecutionError } from "./../errors/GraphExecutionError.js";
+/**
+ * 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).
+ */
+export 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(`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("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;
+    }
+}
+//# 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"]}

package/lib/esm/graph/engine/loops/ForeachGraphNodeExecutor.js

@@ -0,0 +1,80 @@
+import { GRAPH_DEFAULT_MAX_FOREACH_ITERATIONS } from "./../constants.js";
+import { GraphExecutionEventType } from "./../../shared/constants.js";
+import { GraphInputError } from "./../errors/GraphInputError.js";
+import { GraphLoopLimitError } from "./../errors/GraphLoopLimitError.js";
+/**
+ * Executor for `core.loop.foreach` nodes.
+ *
+ * Expects input:
+ * - `items`: array of values to iterate over
+ * - `state?`: optional initial state
+ *
+ * Produces output:
+ * - `results`: array of body outputs (in item order)
+ * - `state?`: final state
+ * - `iterations`: number of iterations executed
+ */
+export class ForeachGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async execute(input, context) {
+        const metadata = this.extractMetadata(context);
+        const items = input.items;
+        const maxIterations = metadata.maxIterations ?? GRAPH_DEFAULT_MAX_FOREACH_ITERATIONS;
+        if (!Array.isArray(items)) {
+            throw new GraphInputError("foreach input 'items' must be an array");
+        }
+        if (items.length > maxIterations) {
+            throw new GraphLoopLimitError(`foreach exceeded max iterations (${items.length} > ${maxIterations})`);
+        }
+        const itemPort = metadata.itemPort ?? "item";
+        const resultPort = metadata.resultPort ?? "result";
+        const statePort = metadata.statePort ?? "state";
+        const bodyWorkflow = metadata.body;
+        const results = [];
+        let state = input.state;
+        await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });
+        for (let i = 0; i < items.length; i++) {
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_ITERATION_STARTED,
+                iteration: i,
+            });
+            const childInputs = {
+                [itemPort]: items[i],
+                index: i,
+            };
+            if (state !== undefined)
+                childInputs[statePort] = state;
+            const childResult = await this.engine.execute(bodyWorkflow, childInputs, {
+                parentRunId: context.runId,
+                path: [...context.path, `iteration:${i}`],
+            });
+            results.push(childResult.outputs[resultPort]);
+            if (childResult.outputs[statePort] !== undefined) {
+                state = childResult.outputs[statePort];
+            }
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,
+                iteration: i,
+            });
+        }
+        await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });
+        const output = {
+            results,
+            iterations: items.length,
+        };
+        if (state !== undefined)
+            output[statePort] = state;
+        return output;
+    }
+    extractMetadata(context) {
+        const raw = context.node.graph?.metadata?.loop ??
+            context.metadata?.loop;
+        if (!raw) {
+            throw new GraphInputError("foreach node is missing loop metadata");
+        }
+        return raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ForeachGraphNodeExecutor.js","sourceRoot":"","sources":["../../../../../src/graph/engine/loops/ForeachGraphNodeExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/loops/ForeachGraphNodeExecutor\n * @summary Foreach loop node executor.\n * @description Executes a body workflow once per item in the input array, collecting results in order.\n */\nimport type { GraphNodeExecutor } from \"../execution/GraphNodeExecutor\";\nimport type { GraphExecutionContext } from \"../execution/GraphExecutionContext\";\nimport type { GraphExecutionEngine } from \"../execution/GraphExecutionEngine\";\nimport type { GraphExecutionValues, GraphLoopMetadata } from \"../types\";\nimport type { GraphWorkflowDefinition } from \"@decaf-ts/ui-decorators/graph\";\n\nimport { GRAPH_DEFAULT_MAX_FOREACH_ITERATIONS } from \"../constants\";\nimport { GraphExecutionEventType } from \"../../shared/constants\";\nimport { GraphInputError } from \"../errors/GraphInputError\";\nimport { GraphLoopLimitError } from \"../errors/GraphLoopLimitError\";\n\n/**\n * Executor for `core.loop.foreach` nodes.\n *\n * Expects input:\n * - `items`: array of values to iterate over\n * - `state?`: optional initial state\n *\n * Produces output:\n * - `results`: array of body outputs (in item order)\n * - `state?`: final state\n * - `iterations`: number of iterations executed\n */\nexport class ForeachGraphNodeExecutor implements GraphNodeExecutor {\n  constructor(private readonly engine: GraphExecutionEngine) {}\n\n  async execute(\n    input: GraphExecutionValues,\n    context: GraphExecutionContext\n  ): Promise<GraphExecutionValues> {\n    const metadata = this.extractMetadata(context);\n    const items = input.items;\n    const maxIterations =\n      metadata.maxIterations ?? GRAPH_DEFAULT_MAX_FOREACH_ITERATIONS;\n\n    if (!Array.isArray(items)) {\n      throw new GraphInputError(\"foreach input 'items' must be an array\");\n    }\n    if (items.length > maxIterations) {\n      throw new GraphLoopLimitError(\n        `foreach exceeded max iterations (${items.length} > ${maxIterations})`\n      );\n    }\n\n    const itemPort = metadata.itemPort ?? \"item\";\n    const resultPort = metadata.resultPort ?? \"result\";\n    const statePort = metadata.statePort ?? \"state\";\n    const bodyWorkflow = metadata.body as GraphWorkflowDefinition;\n\n    const results: unknown[] = [];\n    let state = input.state;\n\n    await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });\n\n    for (let i = 0; i < items.length; i++) {\n      await context.emit({\n        type: GraphExecutionEventType.LOOP_ITERATION_STARTED,\n        iteration: i,\n      });\n\n      const childInputs: GraphExecutionValues = {\n        [itemPort]: items[i],\n        index: i,\n      };\n      if (state !== undefined) childInputs[statePort] = state;\n\n      const childResult = await this.engine.execute(\n        bodyWorkflow,\n        childInputs,\n        {\n          parentRunId: context.runId,\n          path: [...context.path, `iteration:${i}`],\n        }\n      );\n\n      results.push(childResult.outputs[resultPort]);\n      if (childResult.outputs[statePort] !== undefined) {\n        state = childResult.outputs[statePort];\n      }\n\n      await context.emit({\n        type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,\n        iteration: i,\n      });\n    }\n\n    await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });\n\n    const output: GraphExecutionValues = {\n      results,\n      iterations: items.length,\n    };\n    if (state !== undefined) output[statePort] = state;\n    return output;\n  }\n\n  private extractMetadata(context: GraphExecutionContext): GraphLoopMetadata {\n    const raw = (context.node as any).graph?.metadata?.loop ??\n      (context.metadata as any)?.loop;\n    if (!raw) {\n      throw new GraphInputError(\"foreach node is missing loop metadata\");\n    }\n    return raw as GraphLoopMetadata;\n  }\n}\n"]}

package/lib/esm/graph/engine/loops/GraphConditionEvaluator.js

@@ -0,0 +1,80 @@
+import { GraphConditionType } from "./../constants.js";
+import { GraphExecutionError } from "./../errors/GraphExecutionError.js";
+import { ConditionExpressionEvaluator } from "./ConditionExpressionEvaluator.js";
+/**
+ * Evaluates loop conditions using built-in comparison types or the
+ * `ConditionExpression` DSL.
+ */
+export class GraphConditionEvaluator {
+    constructor() {
+        this.expressionEvaluator = new ConditionExpressionEvaluator();
+    }
+    /**
+     * Evaluates a condition against the given state.
+     *
+     * When the condition object carries an `op` field, it is treated as a
+     * `ConditionExpression` (§22.3) and dispatched to the
+     * {@link ConditionExpressionEvaluator}. Otherwise the built-in `type`-based
+     * switch is used.
+     *
+     * @param condition - The condition definition.
+     * @param state - The current loop state.
+     * @returns `true` when the condition passes.
+     */
+    evaluate(condition, state) {
+        if (this.isConditionExpression(condition)) {
+            return this.expressionEvaluator.evaluate(condition, state);
+        }
+        const left = this.resolveValue(condition.left, state);
+        const right = condition.right;
+        switch (condition.type) {
+            case GraphConditionType.TRUTHY:
+                return !!left;
+            case GraphConditionType.FALSY:
+                return !left;
+            case GraphConditionType.EQUALS:
+                return left === right;
+            case GraphConditionType.NOT_EQUALS:
+                return left !== right;
+            case GraphConditionType.GREATER_THAN:
+                return Number(left) > Number(right);
+            case GraphConditionType.GREATER_THAN_OR_EQUAL:
+                return Number(left) >= Number(right);
+            case GraphConditionType.LESS_THAN:
+                return Number(left) < Number(right);
+            case GraphConditionType.LESS_THAN_OR_EQUAL:
+                return Number(left) <= Number(right);
+            case GraphConditionType.EXISTS:
+                return left !== undefined && left !== null;
+            case GraphConditionType.CUSTOM:
+                throw new GraphExecutionError("Custom condition evaluators are not supported in v1", "GRAPH_CUSTOM_CONDITION_UNSUPPORTED");
+            default:
+                throw new GraphExecutionError(`Unknown condition type '${condition.type}'`, "GRAPH_UNKNOWN_CONDITION_TYPE", { condition });
+        }
+    }
+    /**
+     * Resolves a value that may be a dotted path into the state object.
+     */
+    resolveValue(path, state) {
+        if (!path)
+            return state;
+        const parts = path.split(".");
+        let current = state;
+        for (const part of parts) {
+            if (current == null)
+                return undefined;
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Detects whether a condition object is a `ConditionExpression` (§22.3) by
+     * checking for the presence of an `op` field. When true, the object is
+     * treated as a `ConditionExpression` and dispatched to the
+     * {@link ConditionExpressionEvaluator}.
+     */
+    isConditionExpression(condition) {
+        return typeof condition.op === "string";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/loops/GraphLoopExecutionContext.js

@@ -0,0 +1,11 @@
+/**
+ * Context for a single loop execution, carrying the loop metadata and
+ * current iteration index.
+ */
+export class GraphLoopExecutionContext {
+    constructor(iteration, metadata) {
+        this.iteration = iteration;
+        this.metadata = metadata;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhMb29wRXhlY3V0aW9uQ29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvbG9vcHMvR3JhcGhMb29wRXhlY3V0aW9uQ29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFPQTs7O0dBR0c7QUFDSCxNQUFNLE9BQU8seUJBQXlCO0lBSXBDLFlBQVksU0FBaUIsRUFBRSxRQUEyQjtRQUN4RCxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztRQUMzQixJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztJQUMzQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL2xvb3BzL0dyYXBoTG9vcEV4ZWN1dGlvbkNvbnRleHRcbiAqIEBzdW1tYXJ5IENvbnRleHQgZm9yIGxvb3Agbm9kZSBleGVjdXRpb24uXG4gKiBAZGVzY3JpcHRpb24gQ2FycmllcyBsb29wLXNwZWNpZmljIG1ldGFkYXRhIGFuZCBpdGVyYXRpb24gc3RhdGUgZHVyaW5nIGxvb3AgZXhlY3V0aW9uLlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoTG9vcE1ldGFkYXRhIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5cbi8qKlxuICogQ29udGV4dCBmb3IgYSBzaW5nbGUgbG9vcCBleGVjdXRpb24sIGNhcnJ5aW5nIHRoZSBsb29wIG1ldGFkYXRhIGFuZFxuICogY3VycmVudCBpdGVyYXRpb24gaW5kZXguXG4gKi9cbmV4cG9ydCBjbGFzcyBHcmFwaExvb3BFeGVjdXRpb25Db250ZXh0IHtcbiAgcmVhZG9ubHkgaXRlcmF0aW9uOiBudW1iZXI7XG4gIHJlYWRvbmx5IG1ldGFkYXRhOiBHcmFwaExvb3BNZXRhZGF0YTtcblxuICBjb25zdHJ1Y3RvcihpdGVyYXRpb246IG51bWJlciwgbWV0YWRhdGE6IEdyYXBoTG9vcE1ldGFkYXRhKSB7XG4gICAgdGhpcy5pdGVyYXRpb24gPSBpdGVyYXRpb247XG4gICAgdGhpcy5tZXRhZGF0YSA9IG1ldGFkYXRhO1xuICB9XG59XG4iXX0=

package/lib/esm/graph/engine/loops/UntilGraphNodeExecutor.js

@@ -0,0 +1,72 @@
+import { GRAPH_DEFAULT_MAX_LOOP_ITERATIONS } from "./../constants.js";
+import { GraphExecutionEventType } from "./../../shared/constants.js";
+import { GraphInputError } from "./../errors/GraphInputError.js";
+import { GraphLoopLimitError } from "./../errors/GraphLoopLimitError.js";
+import { GraphConditionEvaluator } from "./GraphConditionEvaluator.js";
+/**
+ * Executor for `core.loop.until` nodes.
+ *
+ * Executes the body at least once, then checks the condition. Repeats until
+ * the condition evaluates to true.
+ */
+export class UntilGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+        this.evaluator = new GraphConditionEvaluator();
+    }
+    async execute(input, context) {
+        const metadata = this.extractMetadata(context);
+        const maxIterations = metadata.maxIterations ?? GRAPH_DEFAULT_MAX_LOOP_ITERATIONS;
+        const condition = metadata.condition;
+        if (!condition) {
+            throw new GraphInputError("until node is missing a condition");
+        }
+        const statePort = metadata.statePort ?? "state";
+        const bodyWorkflow = metadata.body;
+        let state = input.state;
+        let iteration = 0;
+        await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });
+        let shouldStop = false;
+        do {
+            if (iteration >= maxIterations) {
+                await context.emit({
+                    type: GraphExecutionEventType.LOOP_LIMIT_REACHED,
+                    iteration,
+                });
+                throw new GraphLoopLimitError(`until loop exceeded max iterations (${maxIterations})`);
+            }
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_ITERATION_STARTED,
+                iteration,
+            });
+            const childResult = await this.engine.execute(bodyWorkflow, { [statePort]: state, iteration }, {
+                parentRunId: context.runId,
+                path: [...context.path, `iteration:${iteration}`],
+            });
+            state = childResult.outputs[statePort];
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,
+                iteration,
+            });
+            const conditionResult = this.evaluator.evaluate(condition, state);
+            await context.emit({
+                type: GraphExecutionEventType.LOOP_CONDITION_EVALUATED,
+                iteration,
+                payload: { result: conditionResult },
+            });
+            iteration++;
+            shouldStop = conditionResult;
+        } while (!shouldStop);
+        await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });
+        return { [statePort]: state, iterations: iteration };
+    }
+    extractMetadata(context) {
+        const raw = context.node.graph?.metadata?.loop ??
+            context.metadata?.loop;
+        if (!raw) {
+            throw new GraphInputError("until node is missing loop metadata");
+        }
+        return raw;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UntilGraphNodeExecutor.js","sourceRoot":"","sources":["../../../../../src/graph/engine/loops/UntilGraphNodeExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/loops/UntilGraphNodeExecutor\n * @summary Until loop node executor.\n * @description Executes a body workflow at least once and repeats until a condition is true.\n */\nimport type { GraphNodeExecutor } from \"../execution/GraphNodeExecutor\";\nimport type { GraphExecutionContext } from \"../execution/GraphExecutionContext\";\nimport type { GraphExecutionEngine } from \"../execution/GraphExecutionEngine\";\nimport type { GraphExecutionValues, GraphLoopMetadata } from \"../types\";\nimport type { GraphWorkflowDefinition } from \"@decaf-ts/ui-decorators/graph\";\n\nimport { GRAPH_DEFAULT_MAX_LOOP_ITERATIONS } from \"../constants\";\nimport { GraphExecutionEventType } from \"../../shared/constants\";\nimport { GraphInputError } from \"../errors/GraphInputError\";\nimport { GraphLoopLimitError } from \"../errors/GraphLoopLimitError\";\nimport { GraphConditionEvaluator } from \"./GraphConditionEvaluator\";\n\n/**\n * Executor for `core.loop.until` nodes.\n *\n * Executes the body at least once, then checks the condition. Repeats until\n * the condition evaluates to true.\n */\nexport class UntilGraphNodeExecutor implements GraphNodeExecutor {\n  private readonly evaluator = new GraphConditionEvaluator();\n\n  constructor(private readonly engine: GraphExecutionEngine) {}\n\n  async execute(\n    input: GraphExecutionValues,\n    context: GraphExecutionContext\n  ): Promise<GraphExecutionValues> {\n    const metadata = this.extractMetadata(context);\n    const maxIterations =\n      metadata.maxIterations ?? GRAPH_DEFAULT_MAX_LOOP_ITERATIONS;\n    const condition = metadata.condition;\n    if (!condition) {\n      throw new GraphInputError(\"until node is missing a condition\");\n    }\n    const statePort = metadata.statePort ?? \"state\";\n    const bodyWorkflow = metadata.body as GraphWorkflowDefinition;\n\n    let state = input.state;\n    let iteration = 0;\n\n    await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });\n\n    let shouldStop = false;\n\n    do {\n      if (iteration >= maxIterations) {\n        await context.emit({\n          type: GraphExecutionEventType.LOOP_LIMIT_REACHED,\n          iteration,\n        });\n        throw new GraphLoopLimitError(\n          `until loop exceeded max iterations (${maxIterations})`\n        );\n      }\n\n      await context.emit({\n        type: GraphExecutionEventType.LOOP_ITERATION_STARTED,\n        iteration,\n      });\n\n      const childResult = await this.engine.execute(\n        bodyWorkflow,\n        { [statePort]: state, iteration },\n        {\n          parentRunId: context.runId,\n          path: [...context.path, `iteration:${iteration}`],\n        }\n      );\n\n      state = childResult.outputs[statePort];\n\n      await context.emit({\n        type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,\n        iteration,\n      });\n\n      const conditionResult = this.evaluator.evaluate(condition, state);\n\n      await context.emit({\n        type: GraphExecutionEventType.LOOP_CONDITION_EVALUATED,\n        iteration,\n        payload: { result: conditionResult },\n      });\n\n      iteration++;\n      shouldStop = conditionResult;\n    } while (!shouldStop);\n\n    await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });\n\n    return { [statePort]: state, iterations: iteration };\n  }\n\n  private extractMetadata(context: GraphExecutionContext): GraphLoopMetadata {\n    const raw = (context.node as any).graph?.metadata?.loop ??\n      (context.metadata as any)?.loop;\n    if (!raw) {\n      throw new GraphInputError(\"until node is missing loop metadata\");\n    }\n    return raw as GraphLoopMetadata;\n  }\n}\n"]}