@decaf-ts/integrations 0.3.7 → 0.3.9

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeachGraphNodeExecutor = void 0;
+const constants_js_1 = require("./../constants.cjs");
+const constants_js_2 = require("./../../shared/constants.cjs");
+const GraphInputError_js_1 = require("./../errors/GraphInputError.cjs");
+const GraphLoopLimitError_js_1 = require("./../errors/GraphLoopLimitError.cjs");
+/**
+ * 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
+ */
+class ForeachGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+    }
+    async execute(input, context) {
+        const metadata = this.extractMetadata(context);
+        const items = input.items;
+        const maxIterations = metadata.maxIterations ?? constants_js_1.GRAPH_DEFAULT_MAX_FOREACH_ITERATIONS;
+        if (!Array.isArray(items)) {
+            throw new GraphInputError_js_1.GraphInputError("foreach input 'items' must be an array");
+        }
+        if (items.length > maxIterations) {
+            throw new GraphLoopLimitError_js_1.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: constants_js_2.GraphExecutionEventType.LOOP_STARTED });
+        for (let i = 0; i < items.length; i++) {
+            await context.emit({
+                type: constants_js_2.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: constants_js_2.GraphExecutionEventType.LOOP_ITERATION_COMPLETED,
+                iteration: i,
+            });
+        }
+        await context.emit({ type: constants_js_2.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_js_1.GraphInputError("foreach node is missing loop metadata");
+        }
+        return raw;
+    }
+}
+exports.ForeachGraphNodeExecutor = ForeachGraphNodeExecutor;
+//# 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ForeachGraphNodeExecutor.js","sourceRoot":"","sources":["ForeachGraphNodeExecutor.js"],"names":[],"mappings":"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","sourcesContent":["import { GRAPH_DEFAULT_MAX_FOREACH_ITERATIONS } from \"./../constants.js\";\nimport { GraphExecutionEventType } from \"./../../shared/constants.js\";\nimport { GraphInputError } from \"./../errors/GraphInputError.js\";\nimport { GraphLoopLimitError } from \"./../errors/GraphLoopLimitError.js\";\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 {\n    constructor(engine) {\n        this.engine = engine;\n    }\n    async execute(input, context) {\n        const metadata = this.extractMetadata(context);\n        const items = input.items;\n        const maxIterations = metadata.maxIterations ?? GRAPH_DEFAULT_MAX_FOREACH_ITERATIONS;\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(`foreach exceeded max iterations (${items.length} > ${maxIterations})`);\n        }\n        const itemPort = metadata.itemPort ?? \"item\";\n        const resultPort = metadata.resultPort ?? \"result\";\n        const statePort = metadata.statePort ?? \"state\";\n        const bodyWorkflow = metadata.body;\n        const results = [];\n        let state = input.state;\n        await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });\n        for (let i = 0; i < items.length; i++) {\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_ITERATION_STARTED,\n                iteration: i,\n            });\n            const childInputs = {\n                [itemPort]: items[i],\n                index: i,\n            };\n            if (state !== undefined)\n                childInputs[statePort] = state;\n            const childResult = await this.engine.execute(bodyWorkflow, childInputs, {\n                parentRunId: context.runId,\n                path: [...context.path, `iteration:${i}`],\n            });\n            results.push(childResult.outputs[resultPort]);\n            if (childResult.outputs[statePort] !== undefined) {\n                state = childResult.outputs[statePort];\n            }\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,\n                iteration: i,\n            });\n        }\n        await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });\n        const output = {\n            results,\n            iterations: items.length,\n        };\n        if (state !== undefined)\n            output[statePort] = state;\n        return output;\n    }\n    extractMetadata(context) {\n        const raw = context.node.graph?.metadata?.loop ??\n            context.metadata?.loop;\n        if (!raw) {\n            throw new GraphInputError(\"foreach node is missing loop metadata\");\n        }\n        return raw;\n    }\n}\n//# 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/cjs/graph/engine/loops/GraphConditionEvaluator.cjs

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphConditionEvaluator = void 0;
+const constants_js_1 = require("./../constants.cjs");
+const GraphExecutionError_js_1 = require("./../errors/GraphExecutionError.cjs");
+const ConditionExpressionEvaluator_js_1 = require("./ConditionExpressionEvaluator.cjs");
+/**
+ * Evaluates loop conditions using built-in comparison types or the
+ * `ConditionExpression` DSL.
+ */
+class GraphConditionEvaluator {
+    constructor() {
+        this.expressionEvaluator = new ConditionExpressionEvaluator_js_1.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 constants_js_1.GraphConditionType.TRUTHY:
+                return !!left;
+            case constants_js_1.GraphConditionType.FALSY:
+                return !left;
+            case constants_js_1.GraphConditionType.EQUALS:
+                return left === right;
+            case constants_js_1.GraphConditionType.NOT_EQUALS:
+                return left !== right;
+            case constants_js_1.GraphConditionType.GREATER_THAN:
+                return Number(left) > Number(right);
+            case constants_js_1.GraphConditionType.GREATER_THAN_OR_EQUAL:
+                return Number(left) >= Number(right);
+            case constants_js_1.GraphConditionType.LESS_THAN:
+                return Number(left) < Number(right);
+            case constants_js_1.GraphConditionType.LESS_THAN_OR_EQUAL:
+                return Number(left) <= Number(right);
+            case constants_js_1.GraphConditionType.EXISTS:
+                return left !== undefined && left !== null;
+            case constants_js_1.GraphConditionType.CUSTOM:
+                throw new GraphExecutionError_js_1.GraphExecutionError("Custom condition evaluators are not supported in v1", "GRAPH_CUSTOM_CONDITION_UNSUPPORTED");
+            default:
+                throw new GraphExecutionError_js_1.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";
+    }
+}
+exports.GraphConditionEvaluator = GraphConditionEvaluator;
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphConditionEvaluator.js","sourceRoot":"","sources":["GraphConditionEvaluator.js"],"names":[],"mappings":";;;AAAA,oDAAuD;AACvD,+EAAyE;AACzE,uFAAiF;AACjF;;;GAGG;AACH,MAAa,uBAAuB;IAChC;QACI,IAAI,CAAC,mBAAmB,GAAG,IAAI,8DAA4B,EAAE,CAAC;IAClE,CAAC;IACD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,KAAK;QACrB,IAAI,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,EAAE,CAAC;YACxC,OAAO,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC/D,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;QAC9B,QAAQ,SAAS,CAAC,IAAI,EAAE,CAAC;YACrB,KAAK,iCAAkB,CAAC,MAAM;gBAC1B,OAAO,CAAC,CAAC,IAAI,CAAC;YAClB,KAAK,iCAAkB,CAAC,KAAK;gBACzB,OAAO,CAAC,IAAI,CAAC;YACjB,KAAK,iCAAkB,CAAC,MAAM;gBAC1B,OAAO,IAAI,KAAK,KAAK,CAAC;YAC1B,KAAK,iCAAkB,CAAC,UAAU;gBAC9B,OAAO,IAAI,KAAK,KAAK,CAAC;YAC1B,KAAK,iCAAkB,CAAC,YAAY;gBAChC,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YACxC,KAAK,iCAAkB,CAAC,qBAAqB;gBACzC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;YACzC,KAAK,iCAAkB,CAAC,SAAS;gBAC7B,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YACxC,KAAK,iCAAkB,CAAC,kBAAkB;gBACtC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;YACzC,KAAK,iCAAkB,CAAC,MAAM;gBAC1B,OAAO,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,CAAC;YAC/C,KAAK,iCAAkB,CAAC,MAAM;gBAC1B,MAAM,IAAI,4CAAmB,CAAC,qDAAqD,EAAE,oCAAoC,CAAC,CAAC;YAC/H;gBACI,MAAM,IAAI,4CAAmB,CAAC,2BAA2B,SAAS,CAAC,IAAI,GAAG,EAAE,8BAA8B,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;QACnI,CAAC;IACL,CAAC;IACD;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,KAAK;QACpB,IAAI,CAAC,IAAI;YACL,OAAO,KAAK,CAAC;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACvB,IAAI,OAAO,IAAI,IAAI;gBACf,OAAO,SAAS,CAAC;YACrB,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;IACD;;;;;OAKG;IACH,qBAAqB,CAAC,SAAS;QAC3B,OAAO,OAAO,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC;IAC5C,CAAC;CACJ;AAvED,0DAuEC;AACD,82PAA82P","sourcesContent":["import { GraphConditionType } from \"./../constants.js\";\nimport { GraphExecutionError } from \"./../errors/GraphExecutionError.js\";\nimport { ConditionExpressionEvaluator } from \"./ConditionExpressionEvaluator.js\";\n/**\n * Evaluates loop conditions using built-in comparison types or the\n * `ConditionExpression` DSL.\n */\nexport class GraphConditionEvaluator {\n    constructor() {\n        this.expressionEvaluator = new ConditionExpressionEvaluator();\n    }\n    /**\n     * Evaluates a condition against the given state.\n     *\n     * When the condition object carries an `op` field, it is treated as a\n     * `ConditionExpression` (§22.3) and dispatched to the\n     * {@link ConditionExpressionEvaluator}. Otherwise the built-in `type`-based\n     * switch is used.\n     *\n     * @param condition - The condition definition.\n     * @param state - The current loop state.\n     * @returns `true` when the condition passes.\n     */\n    evaluate(condition, state) {\n        if (this.isConditionExpression(condition)) {\n            return this.expressionEvaluator.evaluate(condition, state);\n        }\n        const left = this.resolveValue(condition.left, state);\n        const right = condition.right;\n        switch (condition.type) {\n            case GraphConditionType.TRUTHY:\n                return !!left;\n            case GraphConditionType.FALSY:\n                return !left;\n            case GraphConditionType.EQUALS:\n                return left === right;\n            case GraphConditionType.NOT_EQUALS:\n                return left !== right;\n            case GraphConditionType.GREATER_THAN:\n                return Number(left) > Number(right);\n            case GraphConditionType.GREATER_THAN_OR_EQUAL:\n                return Number(left) >= Number(right);\n            case GraphConditionType.LESS_THAN:\n                return Number(left) < Number(right);\n            case GraphConditionType.LESS_THAN_OR_EQUAL:\n                return Number(left) <= Number(right);\n            case GraphConditionType.EXISTS:\n                return left !== undefined && left !== null;\n            case GraphConditionType.CUSTOM:\n                throw new GraphExecutionError(\"Custom condition evaluators are not supported in v1\", \"GRAPH_CUSTOM_CONDITION_UNSUPPORTED\");\n            default:\n                throw new GraphExecutionError(`Unknown condition type '${condition.type}'`, \"GRAPH_UNKNOWN_CONDITION_TYPE\", { condition });\n        }\n    }\n    /**\n     * Resolves a value that may be a dotted path into the state object.\n     */\n    resolveValue(path, state) {\n        if (!path)\n            return state;\n        const parts = path.split(\".\");\n        let current = state;\n        for (const part of parts) {\n            if (current == null)\n                return undefined;\n            current = current[part];\n        }\n        return current;\n    }\n    /**\n     * Detects whether a condition object is a `ConditionExpression` (§22.3) by\n     * checking for the presence of an `op` field. When true, the object is\n     * treated as a `ConditionExpression` and dispatched to the\n     * {@link ConditionExpressionEvaluator}.\n     */\n    isConditionExpression(condition) {\n        return typeof condition.op === \"string\";\n    }\n}\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhDb25kaXRpb25FdmFsdWF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2xvb3BzL0dyYXBoQ29uZGl0aW9uRXZhbHVhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSwwQkFBcUI7QUFDbEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLDJDQUFzQztBQUNwRSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsMENBQXVDO0FBRTlFOzs7R0FHRztBQUNILE1BQU0sT0FBTyx1QkFBdUI7SUFBcEM7UUFDbUIsd0JBQW1CLEdBQUcsSUFBSSw0QkFBNEIsRUFBRSxDQUFDO0lBOEU1RSxDQUFDO0lBNUVDOzs7Ozs7Ozs7OztPQVdHO0lBQ0gsUUFBUSxDQUFDLFNBQXlELEVBQUUsS0FBYztRQUNoRixJQUFJLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDO1lBQzFDLE9BQU8sSUFBSSxDQUFDLG1CQUFtQixDQUFDLFFBQVEsQ0FBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDN0QsQ0FBQztRQUVELE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztRQUN0RCxNQUFNLEtBQUssR0FBRyxTQUFTLENBQUMsS0FBSyxDQUFDO1FBRTlCLFFBQVEsU0FBUyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3ZCLEtBQUssa0JBQWtCLENBQUMsTUFBTTtnQkFDNUIsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDO1lBQ2hCLEtBQUssa0JBQWtCLENBQUMsS0FBSztnQkFDM0IsT0FBTyxDQUFDLElBQUksQ0FBQztZQUNmLEtBQUssa0JBQWtCLENBQUMsTUFBTTtnQkFDNUIsT0FBTyxJQUFJLEtBQUssS0FBSyxDQUFDO1lBQ3hCLEtBQUssa0JBQWtCLENBQUMsVUFBVTtnQkFDaEMsT0FBTyxJQUFJLEtBQUssS0FBSyxDQUFDO1lBQ3hCLEtBQUssa0JBQWtCLENBQUMsWUFBWTtnQkFDbEMsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3RDLEtBQUssa0JBQWtCLENBQUMscUJBQXFCO2dCQUMzQyxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDdkMsS0FBSyxrQkFBa0IsQ0FBQyxTQUFTO2dCQUMvQixPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDdEMsS0FBSyxrQkFBa0IsQ0FBQyxrQkFBa0I7Z0JBQ3hDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUN2QyxLQUFLLGtCQUFrQixDQUFDLE1BQU07Z0JBQzVCLE9BQU8sSUFBSSxLQUFLLFNBQVMsSUFBSSxJQUFJLEtBQUssSUFBSSxDQUFDO1lBQzdDLEtBQUssa0JBQWtCLENBQUMsTUFBTTtnQkFDNUIsTUFBTSxJQUFJLG1CQUFtQixDQUMzQixxREFBcUQsRUFDckQsb0NBQW9DLENBQ3JDLENBQUM7WUFDSjtnQkFDRSxNQUFNLElBQUksbUJBQW1CLENBQzNCLDJCQUEyQixTQUFTLENBQUMsSUFBSSxHQUFHLEVBQzVDLDhCQUE4QixFQUM5QixFQUFFLFNBQVMsRUFBRSxDQUNkLENBQUM7UUFDTixDQUFDO0lBQ0gsQ0FBQztJQUVEOztPQUVHO0lBQ0ssWUFBWSxDQUFDLElBQXdCLEVBQUUsS0FBYztRQUMzRCxJQUFJLENBQUMsSUFBSTtZQUFFLE9BQU8sS0FBSyxDQUFDO1FBQ3hCLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDOUIsSUFBSSxPQUFPLEdBQVksS0FBSyxDQUFDO1FBQzdCLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7WUFDekIsSUFBSSxPQUFPLElBQUksSUFBSTtnQkFBRSxPQUFPLFNBQVMsQ0FBQztZQUN0QyxPQUFPLEdBQUksT0FBbUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2RCxDQUFDO1FBQ0QsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0sscUJBQXFCLENBQUMsU0FBeUQ7UUFDckYsT0FBTyxPQUFRLFNBQXdDLENBQUMsRUFBRSxLQUFLLFFBQVEsQ0FBQztJQUMxRSxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL2xvb3BzL0dyYXBoQ29uZGl0aW9uRXZhbHVhdG9yXG4gKiBAc3VtbWFyeSBFdmFsdWF0b3IgZm9yIGJ1aWx0LWluIGxvb3AgY29uZGl0aW9uIHR5cGVzIGFuZCB0aGUgYENvbmRpdGlvbkV4cHJlc3Npb25gIERTTC5cbiAqIEBkZXNjcmlwdGlvbiBTdXBwb3J0cyBzYWZlLCBidWlsdC1pbiBjb25kaXRpb24gdHlwZXMgb25seS4gRG9lcyBOT1QgZXZhbHVhdGUgYXJiaXRyYXJ5IEphdmFTY3JpcHQgZXhwcmVzc2lvbnMuXG4gKiBXaGVuIHRoZSBjb25kaXRpb24gb2JqZWN0IGNhcnJpZXMgYW4gYG9wYCBmaWVsZCAoQUxGUkVELTUgwqc4IC8gREVDQUYtMzIgwqcyMi4zKSwgZGlzcGF0Y2hlcyB0byB0aGVcbiAqIHtAbGluayBDb25kaXRpb25FeHByZXNzaW9uRXZhbHVhdG9yfSBpbnN0ZWFkIG9mIHRoZSBidWlsdC1pbiBgdHlwZWAtYmFzZWQgc3dpdGNoLlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoQ29uZGl0aW9uRGVmaW5pdGlvbiB9IGZyb20gXCIuLi90eXBlc1wiO1xuaW1wb3J0IHR5cGUgeyBDb25kaXRpb25FeHByZXNzaW9uIH0gZnJvbSBcIi4uLy4uL3NoYXJlZC90eXBlc1wiO1xuaW1wb3J0IHsgR3JhcGhDb25kaXRpb25UeXBlIH0gZnJvbSBcIi4uL2NvbnN0YW50c1wiO1xuaW1wb3J0IHsgR3JhcGhFeGVjdXRpb25FcnJvciB9IGZyb20gXCIuLi9lcnJvcnMvR3JhcGhFeGVjdXRpb25FcnJvclwiO1xuaW1wb3J0IHsgQ29uZGl0aW9uRXhwcmVzc2lvbkV2YWx1YXRvciB9IGZyb20gXCIuL0NvbmRpdGlvbkV4cHJlc3Npb25FdmFsdWF0b3JcIjtcblxuLyoqXG4gKiBFdmFsdWF0ZXMgbG9vcCBjb25kaXRpb25zIHVzaW5nIGJ1aWx0LWluIGNvbXBhcmlzb24gdHlwZXMgb3IgdGhlXG4gKiBgQ29uZGl0aW9uRXhwcmVzc2lvbmAgRFNMLlxuICovXG5leHBvcnQgY2xhc3MgR3JhcGhDb25kaXRpb25FdmFsdWF0b3Ige1xuICBwcml2YXRlIHJlYWRvbmx5IGV4cHJlc3Npb25FdmFsdWF0b3IgPSBuZXcgQ29uZGl0aW9uRXhwcmVzc2lvbkV2YWx1YXRvcigpO1xuXG4gIC8qKlxuICAgKiBFdmFsdWF0ZXMgYSBjb25kaXRpb24gYWdhaW5zdCB0aGUgZ2l2ZW4gc3RhdGUuXG4gICAqXG4gICAqIFdoZW4gdGhlIGNvbmRpdGlvbiBvYmplY3QgY2FycmllcyBhbiBgb3BgIGZpZWxkLCBpdCBpcyB0cmVhdGVkIGFzIGFcbiAgICogYENvbmRpdGlvbkV4cHJlc3Npb25gICjCpzIyLjMpIGFuZCBkaXNwYXRjaGVkIHRvIHRoZVxuICAgKiB7QGxpbmsgQ29uZGl0aW9uRXhwcmVzc2lvbkV2YWx1YXRvcn0uIE90aGVyd2lzZSB0aGUgYnVpbHQtaW4gYHR5cGVgLWJhc2VkXG4gICAqIHN3aXRjaCBpcyB1c2VkLlxuICAgKlxuICAgKiBAcGFyYW0gY29uZGl0aW9uIC0gVGhlIGNvbmRpdGlvbiBkZWZpbml0aW9uLlxuICAgKiBAcGFyYW0gc3RhdGUgLSBUaGUgY3VycmVudCBsb29wIHN0YXRlLlxuICAgKiBAcmV0dXJucyBgdHJ1ZWAgd2hlbiB0aGUgY29uZGl0aW9uIHBhc3Nlcy5cbiAgICovXG4gIGV2YWx1YXRlKGNvbmRpdGlvbjogR3JhcGhDb25kaXRpb25EZWZpbml0aW9uIHwgQ29uZGl0aW9uRXhwcmVzc2lvbiwgc3RhdGU6IHVua25vd24pOiBib29sZWFuIHtcbiAgICBpZiAodGhpcy5pc0NvbmRpdGlvbkV4cHJlc3Npb24oY29uZGl0aW9uKSkge1xuICAgICAgcmV0dXJuIHRoaXMuZXhwcmVzc2lvbkV2YWx1YXRvci5ldmFsdWF0ZShjb25kaXRpb24sIHN0YXRlKTtcbiAgICB9XG5cbiAgICBjb25zdCBsZWZ0ID0gdGhpcy5yZXNvbHZlVmFsdWUoY29uZGl0aW9uLmxlZnQsIHN0YXRlKTtcbiAgICBjb25zdCByaWdodCA9IGNvbmRpdGlvbi5yaWdodDtcblxuICAgIHN3aXRjaCAoY29uZGl0aW9uLnR5cGUpIHtcbiAgICAgIGNhc2UgR3JhcGhDb25kaXRpb25UeXBlLlRSVVRIWTpcbiAgICAgICAgcmV0dXJuICEhbGVmdDtcbiAgICAgIGNhc2UgR3JhcGhDb25kaXRpb25UeXBlLkZBTFNZOlxuICAgICAgICByZXR1cm4gIWxlZnQ7XG4gICAgICBjYXNlIEdyYXBoQ29uZGl0aW9uVHlwZS5FUVVBTFM6XG4gICAgICAgIHJldHVybiBsZWZ0ID09PSByaWdodDtcbiAgICAgIGNhc2UgR3JhcGhDb25kaXRpb25UeXBlLk5PVF9FUVVBTFM6XG4gICAgICAgIHJldHVybiBsZWZ0ICE9PSByaWdodDtcbiAgICAgIGNhc2UgR3JhcGhDb25kaXRpb25UeXBlLkdSRUFURVJfVEhBTjpcbiAgICAgICAgcmV0dXJuIE51bWJlcihsZWZ0KSA+IE51bWJlcihyaWdodCk7XG4gICAgICBjYXNlIEdyYXBoQ29uZGl0aW9uVHlwZS5HUkVBVEVSX1RIQU5fT1JfRVFVQUw6XG4gICAgICAgIHJldHVybiBOdW1iZXIobGVmdCkgPj0gTnVtYmVyKHJpZ2h0KTtcbiAgICAgIGNhc2UgR3JhcGhDb25kaXRpb25UeXBlLkxFU1NfVEhBTjpcbiAgICAgICAgcmV0dXJuIE51bWJlcihsZWZ0KSA8IE51bWJlcihyaWdodCk7XG4gICAgICBjYXNlIEdyYXBoQ29uZGl0aW9uVHlwZS5MRVNTX1RIQU5fT1JfRVFVQUw6XG4gICAgICAgIHJldHVybiBOdW1iZXIobGVmdCkgPD0gTnVtYmVyKHJpZ2h0KTtcbiAgICAgIGNhc2UgR3JhcGhDb25kaXRpb25UeXBlLkVYSVNUUzpcbiAgICAgICAgcmV0dXJuIGxlZnQgIT09IHVuZGVmaW5lZCAmJiBsZWZ0ICE9PSBudWxsO1xuICAgICAgY2FzZSBHcmFwaENvbmRpdGlvblR5cGUuQ1VTVE9NOlxuICAgICAgICB0aHJvdyBuZXcgR3JhcGhFeGVjdXRpb25FcnJvcihcbiAgICAgICAgICBcIkN1c3RvbSBjb25kaXRpb24gZXZhbHVhdG9ycyBhcmUgbm90IHN1cHBvcnRlZCBpbiB2MVwiLFxuICAgICAgICAgIFwiR1JBUEhfQ1VTVE9NX0NPTkRJVElPTl9VTlNVUFBPUlRFRFwiXG4gICAgICAgICk7XG4gICAgICBkZWZhdWx0OlxuICAgICAgICB0aHJvdyBuZXcgR3JhcGhFeGVjdXRpb25FcnJvcihcbiAgICAgICAgICBgVW5rbm93biBjb25kaXRpb24gdHlwZSAnJHtjb25kaXRpb24udHlwZX0nYCxcbiAgICAgICAgICBcIkdSQVBIX1VOS05PV05fQ09ORElUSU9OX1RZUEVcIixcbiAgICAgICAgICB7IGNvbmRpdGlvbiB9XG4gICAgICAgICk7XG4gICAgfVxuICB9XG5cbiAgLyoqXG4gICAqIFJlc29sdmVzIGEgdmFsdWUgdGhhdCBtYXkgYmUgYSBkb3R0ZWQgcGF0aCBpbnRvIHRoZSBzdGF0ZSBvYmplY3QuXG4gICAqL1xuICBwcml2YXRlIHJlc29sdmVWYWx1ZShwYXRoOiBzdHJpbmcgfCB1bmRlZmluZWQsIHN0YXRlOiB1bmtub3duKTogdW5rbm93biB7XG4gICAgaWYgKCFwYXRoKSByZXR1cm4gc3RhdGU7XG4gICAgY29uc3QgcGFydHMgPSBwYXRoLnNwbGl0KFwiLlwiKTtcbiAgICBsZXQgY3VycmVudDogdW5rbm93biA9IHN0YXRlO1xuICAgIGZvciAoY29uc3QgcGFydCBvZiBwYXJ0cykge1xuICAgICAgaWYgKGN1cnJlbnQgPT0gbnVsbCkgcmV0dXJuIHVuZGVmaW5lZDtcbiAgICAgIGN1cnJlbnQgPSAoY3VycmVudCBhcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPilbcGFydF07XG4gICAgfVxuICAgIHJldHVybiBjdXJyZW50O1xuICB9XG5cbiAgLyoqXG4gICAqIERldGVjdHMgd2hldGhlciBhIGNvbmRpdGlvbiBvYmplY3QgaXMgYSBgQ29uZGl0aW9uRXhwcmVzc2lvbmAgKMKnMjIuMykgYnlcbiAgICogY2hlY2tpbmcgZm9yIHRoZSBwcmVzZW5jZSBvZiBhbiBgb3BgIGZpZWxkLiBXaGVuIHRydWUsIHRoZSBvYmplY3QgaXNcbiAgICogdHJlYXRlZCBhcyBhIGBDb25kaXRpb25FeHByZXNzaW9uYCBhbmQgZGlzcGF0Y2hlZCB0byB0aGVcbiAgICoge0BsaW5rIENvbmRpdGlvbkV4cHJlc3Npb25FdmFsdWF0b3J9LlxuICAgKi9cbiAgcHJpdmF0ZSBpc0NvbmRpdGlvbkV4cHJlc3Npb24oY29uZGl0aW9uOiBHcmFwaENvbmRpdGlvbkRlZmluaXRpb24gfCBDb25kaXRpb25FeHByZXNzaW9uKTogY29uZGl0aW9uIGlzIENvbmRpdGlvbkV4cHJlc3Npb24ge1xuICAgIHJldHVybiB0eXBlb2YgKGNvbmRpdGlvbiBhcyB1bmtub3duIGFzIHsgb3A/OiBzdHJpbmcgfSkub3AgPT09IFwic3RyaW5nXCI7XG4gIH1cbn1cbiJdfQ=="]}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphLoopExecutionContext = void 0;
+/**
+ * Context for a single loop execution, carrying the loop metadata and
+ * current iteration index.
+ */
+class GraphLoopExecutionContext {
+    constructor(iteration, metadata) {
+        this.iteration = iteration;
+        this.metadata = metadata;
+    }
+}
+exports.GraphLoopExecutionContext = GraphLoopExecutionContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhMb29wRXhlY3V0aW9uQ29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvbG9vcHMvR3JhcGhMb29wRXhlY3V0aW9uQ29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFPQTs7O0dBR0c7QUFDSCxNQUFNLE9BQU8seUJBQXlCO0lBSXBDLFlBQVksU0FBaUIsRUFBRSxRQUEyQjtRQUN4RCxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztRQUMzQixJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztJQUMzQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL2xvb3BzL0dyYXBoTG9vcEV4ZWN1dGlvbkNvbnRleHRcbiAqIEBzdW1tYXJ5IENvbnRleHQgZm9yIGxvb3Agbm9kZSBleGVjdXRpb24uXG4gKiBAZGVzY3JpcHRpb24gQ2FycmllcyBsb29wLXNwZWNpZmljIG1ldGFkYXRhIGFuZCBpdGVyYXRpb24gc3RhdGUgZHVyaW5nIGxvb3AgZXhlY3V0aW9uLlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoTG9vcE1ldGFkYXRhIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5cbi8qKlxuICogQ29udGV4dCBmb3IgYSBzaW5nbGUgbG9vcCBleGVjdXRpb24sIGNhcnJ5aW5nIHRoZSBsb29wIG1ldGFkYXRhIGFuZFxuICogY3VycmVudCBpdGVyYXRpb24gaW5kZXguXG4gKi9cbmV4cG9ydCBjbGFzcyBHcmFwaExvb3BFeGVjdXRpb25Db250ZXh0IHtcbiAgcmVhZG9ubHkgaXRlcmF0aW9uOiBudW1iZXI7XG4gIHJlYWRvbmx5IG1ldGFkYXRhOiBHcmFwaExvb3BNZXRhZGF0YTtcblxuICBjb25zdHJ1Y3RvcihpdGVyYXRpb246IG51bWJlciwgbWV0YWRhdGE6IEdyYXBoTG9vcE1ldGFkYXRhKSB7XG4gICAgdGhpcy5pdGVyYXRpb24gPSBpdGVyYXRpb247XG4gICAgdGhpcy5tZXRhZGF0YSA9IG1ldGFkYXRhO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UntilGraphNodeExecutor = void 0;
+const constants_js_1 = require("./../constants.cjs");
+const constants_js_2 = require("./../../shared/constants.cjs");
+const GraphInputError_js_1 = require("./../errors/GraphInputError.cjs");
+const GraphLoopLimitError_js_1 = require("./../errors/GraphLoopLimitError.cjs");
+const GraphConditionEvaluator_js_1 = require("./GraphConditionEvaluator.cjs");
+/**
+ * Executor for `core.loop.until` nodes.
+ *
+ * Executes the body at least once, then checks the condition. Repeats until
+ * the condition evaluates to true.
+ */
+class UntilGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+        this.evaluator = new GraphConditionEvaluator_js_1.GraphConditionEvaluator();
+    }
+    async execute(input, context) {
+        const metadata = this.extractMetadata(context);
+        const maxIterations = metadata.maxIterations ?? constants_js_1.GRAPH_DEFAULT_MAX_LOOP_ITERATIONS;
+        const condition = metadata.condition;
+        if (!condition) {
+            throw new GraphInputError_js_1.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: constants_js_2.GraphExecutionEventType.LOOP_STARTED });
+        let shouldStop = false;
+        do {
+            if (iteration >= maxIterations) {
+                await context.emit({
+                    type: constants_js_2.GraphExecutionEventType.LOOP_LIMIT_REACHED,
+                    iteration,
+                });
+                throw new GraphLoopLimitError_js_1.GraphLoopLimitError(`until loop exceeded max iterations (${maxIterations})`);
+            }
+            await context.emit({
+                type: constants_js_2.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: constants_js_2.GraphExecutionEventType.LOOP_ITERATION_COMPLETED,
+                iteration,
+            });
+            const conditionResult = this.evaluator.evaluate(condition, state);
+            await context.emit({
+                type: constants_js_2.GraphExecutionEventType.LOOP_CONDITION_EVALUATED,
+                iteration,
+                payload: { result: conditionResult },
+            });
+            iteration++;
+            shouldStop = conditionResult;
+        } while (!shouldStop);
+        await context.emit({ type: constants_js_2.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_js_1.GraphInputError("until node is missing loop metadata");
+        }
+        return raw;
+    }
+}
+exports.UntilGraphNodeExecutor = UntilGraphNodeExecutor;
+//# 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UntilGraphNodeExecutor.js","sourceRoot":"","sources":["UntilGraphNodeExecutor.js"],"names":[],"mappings":"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","sourcesContent":["import { GRAPH_DEFAULT_MAX_LOOP_ITERATIONS } from \"./../constants.js\";\nimport { GraphExecutionEventType } from \"./../../shared/constants.js\";\nimport { GraphInputError } from \"./../errors/GraphInputError.js\";\nimport { GraphLoopLimitError } from \"./../errors/GraphLoopLimitError.js\";\nimport { GraphConditionEvaluator } from \"./GraphConditionEvaluator.js\";\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 {\n    constructor(engine) {\n        this.engine = engine;\n        this.evaluator = new GraphConditionEvaluator();\n    }\n    async execute(input, context) {\n        const metadata = this.extractMetadata(context);\n        const maxIterations = 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;\n        let state = input.state;\n        let iteration = 0;\n        await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });\n        let shouldStop = false;\n        do {\n            if (iteration >= maxIterations) {\n                await context.emit({\n                    type: GraphExecutionEventType.LOOP_LIMIT_REACHED,\n                    iteration,\n                });\n                throw new GraphLoopLimitError(`until loop exceeded max iterations (${maxIterations})`);\n            }\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_ITERATION_STARTED,\n                iteration,\n            });\n            const childResult = await this.engine.execute(bodyWorkflow, { [statePort]: state, iteration }, {\n                parentRunId: context.runId,\n                path: [...context.path, `iteration:${iteration}`],\n            });\n            state = childResult.outputs[statePort];\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,\n                iteration,\n            });\n            const conditionResult = this.evaluator.evaluate(condition, state);\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_CONDITION_EVALUATED,\n                iteration,\n                payload: { result: conditionResult },\n            });\n            iteration++;\n            shouldStop = conditionResult;\n        } while (!shouldStop);\n        await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });\n        return { [statePort]: state, iterations: iteration };\n    }\n    extractMetadata(context) {\n        const raw = context.node.graph?.metadata?.loop ??\n            context.metadata?.loop;\n        if (!raw) {\n            throw new GraphInputError(\"until node is missing loop metadata\");\n        }\n        return raw;\n    }\n}\n//# 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"]}"]}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhileGraphNodeExecutor = void 0;
+const constants_js_1 = require("./../constants.cjs");
+const constants_js_2 = require("./../../shared/constants.cjs");
+const GraphInputError_js_1 = require("./../errors/GraphInputError.cjs");
+const GraphLoopLimitError_js_1 = require("./../errors/GraphLoopLimitError.cjs");
+const GraphConditionEvaluator_js_1 = require("./GraphConditionEvaluator.cjs");
+/**
+ * Executor for `core.loop.while` nodes.
+ *
+ * Expects input:
+ * - `state`: initial state
+ *
+ * Produces output:
+ * - `state`: final state
+ * - `iterations`: number of iterations executed
+ */
+class WhileGraphNodeExecutor {
+    constructor(engine) {
+        this.engine = engine;
+        this.evaluator = new GraphConditionEvaluator_js_1.GraphConditionEvaluator();
+    }
+    async execute(input, context) {
+        const metadata = this.extractMetadata(context);
+        const maxIterations = metadata.maxIterations ?? constants_js_1.GRAPH_DEFAULT_MAX_LOOP_ITERATIONS;
+        const condition = metadata.condition;
+        if (!condition) {
+            throw new GraphInputError_js_1.GraphInputError("while 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: constants_js_2.GraphExecutionEventType.LOOP_STARTED });
+        while (this.evaluator.evaluate(condition, state)) {
+            if (iteration >= maxIterations) {
+                await context.emit({
+                    type: constants_js_2.GraphExecutionEventType.LOOP_LIMIT_REACHED,
+                    iteration,
+                });
+                throw new GraphLoopLimitError_js_1.GraphLoopLimitError(`while loop exceeded max iterations (${maxIterations})`);
+            }
+            await context.emit({
+                type: constants_js_2.GraphExecutionEventType.LOOP_CONDITION_EVALUATED,
+                iteration,
+                payload: { result: true },
+            });
+            await context.emit({
+                type: constants_js_2.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: constants_js_2.GraphExecutionEventType.LOOP_ITERATION_COMPLETED,
+                iteration,
+            });
+            iteration++;
+        }
+        await context.emit({ type: constants_js_2.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_js_1.GraphInputError("while node is missing loop metadata");
+        }
+        return raw;
+    }
+}
+exports.WhileGraphNodeExecutor = WhileGraphNodeExecutor;
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WhileGraphNodeExecutor.js","sourceRoot":"","sources":["WhileGraphNodeExecutor.js"],"names":[],"mappings":"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","sourcesContent":["import { GRAPH_DEFAULT_MAX_LOOP_ITERATIONS } from \"./../constants.js\";\nimport { GraphExecutionEventType } from \"./../../shared/constants.js\";\nimport { GraphInputError } from \"./../errors/GraphInputError.js\";\nimport { GraphLoopLimitError } from \"./../errors/GraphLoopLimitError.js\";\nimport { GraphConditionEvaluator } from \"./GraphConditionEvaluator.js\";\n/**\n * Executor for `core.loop.while` nodes.\n *\n * Expects input:\n * - `state`: initial state\n *\n * Produces output:\n * - `state`: final state\n * - `iterations`: number of iterations executed\n */\nexport class WhileGraphNodeExecutor {\n    constructor(engine) {\n        this.engine = engine;\n        this.evaluator = new GraphConditionEvaluator();\n    }\n    async execute(input, context) {\n        const metadata = this.extractMetadata(context);\n        const maxIterations = metadata.maxIterations ?? GRAPH_DEFAULT_MAX_LOOP_ITERATIONS;\n        const condition = metadata.condition;\n        if (!condition) {\n            throw new GraphInputError(\"while node is missing a condition\");\n        }\n        const statePort = metadata.statePort ?? \"state\";\n        const bodyWorkflow = metadata.body;\n        let state = input.state;\n        let iteration = 0;\n        await context.emit({ type: GraphExecutionEventType.LOOP_STARTED });\n        while (this.evaluator.evaluate(condition, state)) {\n            if (iteration >= maxIterations) {\n                await context.emit({\n                    type: GraphExecutionEventType.LOOP_LIMIT_REACHED,\n                    iteration,\n                });\n                throw new GraphLoopLimitError(`while loop exceeded max iterations (${maxIterations})`);\n            }\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_CONDITION_EVALUATED,\n                iteration,\n                payload: { result: true },\n            });\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_ITERATION_STARTED,\n                iteration,\n            });\n            const childResult = await this.engine.execute(bodyWorkflow, { [statePort]: state, iteration }, {\n                parentRunId: context.runId,\n                path: [...context.path, `iteration:${iteration}`],\n            });\n            state = childResult.outputs[statePort];\n            await context.emit({\n                type: GraphExecutionEventType.LOOP_ITERATION_COMPLETED,\n                iteration,\n            });\n            iteration++;\n        }\n        await context.emit({ type: GraphExecutionEventType.LOOP_COMPLETED });\n        return { [statePort]: state, iterations: iteration };\n    }\n    extractMetadata(context) {\n        const raw = context.node.graph?.metadata?.loop ??\n            context.metadata?.loop;\n        if (!raw) {\n            throw new GraphInputError(\"while node is missing loop metadata\");\n        }\n        return raw;\n    }\n}\n//# sourceMappingURL=data:application/json;base64,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"]}

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

@@ -25,5 +25,5 @@ __exportStar(require("./GraphLoopExecutionContext.cjs"), exports);
 __exportStar(require("./ForeachGraphNodeExecutor.cjs"), exports);
 __exportStar(require("./WhileGraphNodeExecutor.cjs"), exports);
 __exportStar(require("./UntilGraphNodeExecutor.cjs"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ3JhcGgvbG9vcHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILDZDQUEwQztBQUMxQyxrREFBK0M7QUFDL0MsK0NBQTRDO0FBQzVDLDhDQUEyQztBQUMzQyw0Q0FBeUM7QUFDekMsNENBQXlDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9sb29wc1xuICogQHN1bW1hcnkgU3RydWN0dXJlZCBsb29wIGV4ZWN1dG9ycy5cbiAqIEBkZXNjcmlwdGlvbiBSZS1leHBvcnRzIHRoZSBjb25kaXRpb24gZXZhbHVhdG9yLCBsb29wIGV4ZWN1dGlvbiBjb250ZXh0LCBhbmQgZm9yZWFjaC93aGlsZS91bnRpbCBleGVjdXRvcnMuXG4gKi9cbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoQ29uZGl0aW9uRXZhbHVhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Db25kaXRpb25FeHByZXNzaW9uRXZhbHVhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaExvb3BFeGVjdXRpb25Db250ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Gb3JlYWNoR3JhcGhOb2RlRXhlY3V0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1doaWxlR3JhcGhOb2RlRXhlY3V0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1VudGlsR3JhcGhOb2RlRXhlY3V0b3JcIjtcbiJdfQ==
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL2xvb3BzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCw2Q0FBMEM7QUFDMUMsa0RBQStDO0FBQy9DLCtDQUE0QztBQUM1Qyw4Q0FBMkM7QUFDM0MsNENBQXlDO0FBQ3pDLDRDQUF5QyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvbG9vcHNcbiAqIEBzdW1tYXJ5IFN0cnVjdHVyZWQgbG9vcCBleGVjdXRvcnMuXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgY29uZGl0aW9uIGV2YWx1YXRvciwgbG9vcCBleGVjdXRpb24gY29udGV4dCwgYW5kIGZvcmVhY2gvd2hpbGUvdW50aWwgZXhlY3V0b3JzLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaENvbmRpdGlvbkV2YWx1YXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ29uZGl0aW9uRXhwcmVzc2lvbkV2YWx1YXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhMb29wRXhlY3V0aW9uQ29udGV4dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vRm9yZWFjaEdyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9XaGlsZUdyYXBoTm9kZUV4ZWN1dG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9VbnRpbEdyYXBoTm9kZUV4ZWN1dG9yXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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