@decaf-ts/integrations 0.3.3 → 0.3.5

package/lib/cjs/graph/nodes/flow-control.cjs

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPH_FLOW_CONTROL_NODES = exports.CodeFlowNode = exports.ReturnFlowNode = exports.HumanApprovalFlowNode = exports.ErrorBoundaryFlowNode = exports.DelayFlowNode = exports.MapFlowNode = exports.MergeFlowNode = exports.ParallelFlowNode = exports.SwitchFlowNode = exports.IfFlowNode = void 0;
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+        return Reflect.metadata(k, v);
+};
+/**
+ * @module integrations/graph/nodes/flow-control
+ * @summary Production flow-control node kind declarations (DECAF-32 §22.2.2).
+ * @description Canonical `@node`-decorated classes for the ten ALFRED-5
+ * flow-control kinds. These are graph-level macros: the engine's planner
+ * recognises them as ordinary executable nodes (§5.7) but they have no
+ * built-in executors — downstream projects (e.g. ALFRED) register custom
+ * executors or compile them into Mastra composition APIs (§22.2.2).
+ *
+ * The three loop kinds (`core.loop.foreach/while/until`) already have built-in
+ * executors (§5.9) and are NOT redeclared here.
+ */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const ui_decorators_1 = require("@decaf-ts/ui-decorators");
+const graph_1 = require("@decaf-ts/ui-decorators/graph");
+/**
+ * If — conditional branch. Evaluates a `ConditionExpression` (§22.3) and
+ * routes the input to the `then` or `else` output.
+ */
+let IfFlowNode = class IfFlowNode extends decorator_validation_1.Model {
+};
+exports.IfFlowNode = IfFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value to evaluate" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Then", placeholder: "Output when condition is true" }),
+    (0, graph_1.output)({ handle: "then" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "then", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Else", placeholder: "Output when condition is false" }),
+    (0, graph_1.output)({ handle: "else" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "else", void 0);
+exports.IfFlowNode = IfFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.if", {
+        kind: "core.flow.if",
+        category: "Flow Control",
+        color: "#f59e0b",
+        icon: "ti-arrows-split-2",
+        width: 96,
+        height: 96,
+        labels: ["flow", "conditional", "branch"],
+        metadata: {
+            title: "If",
+            description: "Conditional branch. Evaluates the configured condition and routes the input to the matching output.",
+            condition: { op: "eq", left: { const: true }, right: { const: true } },
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], IfFlowNode);
+/**
+ * Switch — multi-branch. Routes the input to one of the case output ports
+ * or `default` based on matching conditions. Each case defines a
+ * {@link SwitchCaseCondition} (graphical or code mode) and a dedicated
+ * output port. Cases are stored in `metadata.switch.cases` and the
+ * renderer creates dynamic output ports from them (DECAF-32 §22.2.2).
+ *
+ * The node grows in height as cases are added. Each case gets its own
+ * output port on the right side, labeled with the case label.
+ */
+let SwitchFlowNode = class SwitchFlowNode extends decorator_validation_1.Model {
+};
+exports.SwitchFlowNode = SwitchFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value to switch on" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], SwitchFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Default", placeholder: "Default output when no case matches" }),
+    (0, graph_1.output)({ handle: "default" }),
+    __metadata("design:type", Object)
+], SwitchFlowNode.prototype, "default", void 0);
+exports.SwitchFlowNode = SwitchFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.switch", {
+        kind: "core.flow.switch",
+        category: "Flow Control",
+        color: "#f97316",
+        icon: "ti-arrows-shuffle",
+        width: 120,
+        height: 140,
+        labels: ["flow", "switch", "multi-branch"],
+        metadata: {
+            title: "Switch",
+            description: "Multi-branch switch. Routes the input to the first matching case output, or the default output.",
+            switch: {
+                cases: [],
+                defaultPort: "default",
+            },
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], SwitchFlowNode);
+/**
+ * Parallel — splits execution into concurrent branches.
+ */
+let ParallelFlowNode = class ParallelFlowNode extends decorator_validation_1.Model {
+};
+exports.ParallelFlowNode = ParallelFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value to fan out" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], ParallelFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Branches", placeholder: "Collected branch outputs" }),
+    (0, graph_1.output)({ handle: "branches" }),
+    __metadata("design:type", Array)
+], ParallelFlowNode.prototype, "branches", void 0);
+exports.ParallelFlowNode = ParallelFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.parallel", {
+        kind: "core.flow.parallel",
+        category: "Flow Control",
+        color: "#06b6d4",
+        icon: "ti-arrows-vertical",
+        width: 96,
+        height: 96,
+        labels: ["flow", "parallel", "concurrent"],
+        metadata: {
+            title: "Parallel",
+            description: "Splits execution into concurrent branches. All branches run in parallel and outputs are collected.",
+            branchCount: 2,
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], ParallelFlowNode);
+/**
+ * Merge — normalises branch/parallel outputs into a single output.
+ */
+let MergeFlowNode = class MergeFlowNode extends decorator_validation_1.Model {
+};
+exports.MergeFlowNode = MergeFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Branch outputs", placeholder: "Outputs to merge" }),
+    (0, graph_1.input)({ handle: "values" }),
+    __metadata("design:type", Array)
+], MergeFlowNode.prototype, "values", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Merged output", placeholder: "Merged result" }),
+    (0, graph_1.output)({ handle: "merged" }),
+    __metadata("design:type", Object)
+], MergeFlowNode.prototype, "merged", void 0);
+exports.MergeFlowNode = MergeFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.merge", {
+        kind: "core.flow.merge",
+        category: "Utility",
+        color: "#0d9488",
+        icon: "ti-arrows-merge",
+        width: 96,
+        height: 96,
+        labels: ["flow", "merge", "join"],
+        metadata: {
+            title: "Merge",
+            description: "Merges multiple branch outputs into a single normalised output object.",
+            strategy: "concat",
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], MergeFlowNode);
+/**
+ * Map — transforms the current input into a new output object.
+ */
+let MapFlowNode = class MapFlowNode extends decorator_validation_1.Model {
+};
+exports.MapFlowNode = MapFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value to transform" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], MapFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Transformed output", placeholder: "Mapped result" }),
+    (0, graph_1.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], MapFlowNode.prototype, "result", void 0);
+exports.MapFlowNode = MapFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.map", {
+        kind: "core.flow.map",
+        category: "Utility",
+        color: "#84cc16",
+        icon: "ti-arrows-right-left",
+        width: 96,
+        height: 96,
+        labels: ["flow", "map", "transform"],
+        metadata: {
+            title: "Map",
+            description: "Transforms the current input into a new output object using the configured mapper.",
+            mapper: {},
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], MapFlowNode);
+/**
+ * Delay — pauses execution for a configured duration.
+ */
+let DelayFlowNode = class DelayFlowNode extends decorator_validation_1.Model {
+};
+exports.DelayFlowNode = DelayFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value to forward after delay" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], DelayFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Output value", placeholder: "Forwarded value" }),
+    (0, graph_1.output)({ handle: "value" }),
+    __metadata("design:type", Object)
+], DelayFlowNode.prototype, "valueOut", void 0);
+exports.DelayFlowNode = DelayFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.delay", {
+        kind: "core.flow.delay",
+        category: "Utility",
+        color: "#a3a3a3",
+        icon: "ti-clock-hour-4",
+        width: 96,
+        height: 96,
+        labels: ["flow", "delay", "wait"],
+        metadata: {
+            title: "Delay",
+            description: "Pauses execution for the configured duration (in milliseconds), then forwards the input unchanged.",
+            durationMs: 1000,
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], DelayFlowNode);
+/**
+ * Error boundary — try/catch/finally workflow behaviour.
+ */
+let ErrorBoundaryFlowNode = class ErrorBoundaryFlowNode extends decorator_validation_1.Model {
+};
+exports.ErrorBoundaryFlowNode = ErrorBoundaryFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value to guard" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Result", placeholder: "Output on success" }),
+    (0, graph_1.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "result", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Error", placeholder: "Output on failure" }),
+    (0, graph_1.output)({ handle: "error" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "error", void 0);
+exports.ErrorBoundaryFlowNode = ErrorBoundaryFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.errorBoundary", {
+        kind: "core.flow.errorBoundary",
+        category: "Flow Control",
+        color: "#ef4444",
+        icon: "ti-shield-check",
+        width: 96,
+        height: 96,
+        labels: ["flow", "error", "try-catch"],
+        metadata: {
+            title: "Error boundary",
+            description: "Wraps the input in a try/catch/finally. Emits the result on success, or the error on failure.",
+            finally: false,
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], ErrorBoundaryFlowNode);
+/**
+ * Human approval — suspends execution until a human approves or rejects.
+ */
+let HumanApprovalFlowNode = class HumanApprovalFlowNode extends decorator_validation_1.Model {
+};
+exports.HumanApprovalFlowNode = HumanApprovalFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value pending approval" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Approved", placeholder: "Output when approved" }),
+    (0, graph_1.output)({ handle: "approved" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "approved", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Rejected", placeholder: "Output when rejected" }),
+    (0, graph_1.output)({ handle: "rejected" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "rejected", void 0);
+exports.HumanApprovalFlowNode = HumanApprovalFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.humanApproval", {
+        kind: "core.flow.humanApproval",
+        category: "Flow Control",
+        color: "#d946ef",
+        icon: "ti-user-check",
+        width: 96,
+        height: 96,
+        labels: ["flow", "approval", "suspend"],
+        metadata: {
+            title: "Human approval",
+            description: "Suspends execution until a human approves or rejects. Emits the approved value or a rejection.",
+            approvers: [],
+            timeoutMs: 86400000,
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], HumanApprovalFlowNode);
+/**
+ * Return — defines and normalises the final workflow output.
+ */
+let ReturnFlowNode = class ReturnFlowNode extends decorator_validation_1.Model {
+};
+exports.ReturnFlowNode = ReturnFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input value", placeholder: "Value to normalise" }),
+    (0, graph_1.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], ReturnFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Returned output", placeholder: "Normalised output" }),
+    (0, graph_1.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], ReturnFlowNode.prototype, "result", void 0);
+exports.ReturnFlowNode = ReturnFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.return", {
+        kind: "core.flow.return",
+        category: "Utility",
+        color: "#22c55e",
+        icon: "ti-arrow-back-up",
+        width: 96,
+        height: 96,
+        labels: ["flow", "return", "output"],
+        metadata: {
+            title: "Return",
+            description: "Normalises the input into the final workflow output object.",
+            outputSchema: {},
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], ReturnFlowNode);
+/**
+ * Code — sandboxed JS/TS code execution (ALFRED-5 §7).
+ *
+ * The engine does not implement the sandbox directly (§22.4). A future
+ * executor may wrap the `CodeSandbox` contract (ALFRED-5 §7.17) as a
+ * pluggable executor. The placeholder syntax (`{{ $input }}`, `{{ $item }}`,
+ * `{{ $index }}`, `{{ $vars }}`, `{{ $node["Name"].output }}`) is Mastra-
+ * agnostic and lives in the downstream project's `modules/core` (ALFRED-6).
+ */
+let CodeFlowNode = class CodeFlowNode extends decorator_validation_1.Model {
+};
+exports.CodeFlowNode = CodeFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("textarea", { label: "Input", placeholder: "Input object (accessible as $input)" }),
+    (0, graph_1.input)({ handle: "input" }),
+    __metadata("design:type", Object)
+], CodeFlowNode.prototype, "input", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, ui_decorators_1.uielement)("input", { label: "Result", placeholder: "Code execution result" }),
+    (0, graph_1.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], CodeFlowNode.prototype, "result", void 0);
+exports.CodeFlowNode = CodeFlowNode = __decorate([
+    (0, graph_1.node)("core.flow.code", {
+        kind: "core.flow.code",
+        category: "Utility",
+        color: "#7c3aed",
+        icon: "ti-code",
+        width: 96,
+        height: 96,
+        labels: ["flow", "code", "sandbox", "transform"],
+        metadata: {
+            title: "Code",
+            description: "Runs user-authored JS/TS in a restricted VM sandbox. Supports placeholder syntax for workflow data references.",
+            code: "",
+            language: "javascript",
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], CodeFlowNode);
+/**
+ * All built-in flow-control node constructors.
+ */
+exports.GRAPH_FLOW_CONTROL_NODES = [
+    IfFlowNode,
+    SwitchFlowNode,
+    ParallelFlowNode,
+    MergeFlowNode,
+    MapFlowNode,
+    DelayFlowNode,
+    ErrorBoundaryFlowNode,
+    HumanApprovalFlowNode,
+    ReturnFlowNode,
+    CodeFlowNode,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-control.js","sourceRoot":"","sources":["../../../../src/graph/nodes/flow-control.ts"],"names":[],"mappings":";;;;;;;;;AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAEpE;;;GAGG;AAgBI,IAAM,UAAU,GAAhB,MAAM,UAAW,SAAQ,KAAK;CAepC,CAAA;AAXC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACjF,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;yCACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,+BAA+B,EAAE,CAAC;IACnF,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;;wCACZ;AAKf;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,gCAAgC,EAAE,CAAC;IACpF,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;;wCACZ;AAdJ,UAAU;IAftB,IAAI,CAAC,cAAc,EAAE;QACpB,IAAI,EAAE,cAAc;QACpB,QAAQ,EAAE,cAAc;QACxB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,mBAAmB;QACzB,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC;QACzC,QAAQ,EAAE;YACR,KAAK,EAAE,IAAI;YACX,WAAW,EAAE,qGAAqG;YAClH,SAAS,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;SACvE;KACF,CAAC;IACD,KAAK,EAAE;GACK,UAAU,CAetB;;AAED;;;;;;;;;GASG;AAmBI,IAAM,cAAc,GAApB,MAAM,cAAe,SAAQ,KAAK;CAUxC,CAAA;AANC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAClF,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;6CACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,qCAAqC,EAAE,CAAC;IAC5F,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;;+CACZ;AATP,cAAc;IAlB1B,IAAI,CAAC,kBAAkB,EAAE;QACxB,IAAI,EAAE,kBAAkB;QACxB,QAAQ,EAAE,cAAc;QACxB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,mBAAmB;QACzB,KAAK,EAAE,GAAG;QACV,MAAM,EAAE,GAAG;QACX,MAAM,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC;QAC1C,QAAQ,EAAE;YACR,KAAK,EAAE,QAAQ;YACf,WAAW,EAAE,iGAAiG;YAC9G,MAAM,EAAE;gBACN,KAAK,EAAE,EAAE;gBACT,WAAW,EAAE,SAAS;aACvB;SACF;KACF,CAAC;IACD,KAAK,EAAE;GACK,cAAc,CAU1B;;AAED;;GAEG;AAgBI,IAAM,gBAAgB,GAAtB,MAAM,gBAAiB,SAAQ,KAAK;CAU1C,CAAA;AANC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAChF,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;+CACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,0BAA0B,EAAE,CAAC;IAClF,MAAM,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;;kDACV;AATV,gBAAgB;IAf5B,IAAI,CAAC,oBAAoB,EAAE;QAC1B,IAAI,EAAE,oBAAoB;QAC1B,QAAQ,EAAE,cAAc;QACxB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,oBAAoB;QAC1B,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,YAAY,CAAC;QAC1C,QAAQ,EAAE;YACR,KAAK,EAAE,UAAU;YACjB,WAAW,EAAE,oGAAoG;YACjH,WAAW,EAAE,CAAC;SACf;KACF,CAAC;IACD,KAAK,EAAE;GACK,gBAAgB,CAU5B;;AAED;;GAEG;AAgBI,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,KAAK;CAUvC,CAAA;AANC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;IACnF,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;;6CACT;AAKnB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,eAAe,EAAE,CAAC;IAC5E,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;;6CACZ;AATN,aAAa;IAfzB,IAAI,CAAC,iBAAiB,EAAE;QACvB,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,SAAS;QACnB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,iBAAiB;QACvB,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC;QACjC,QAAQ,EAAE;YACR,KAAK,EAAE,OAAO;YACd,WAAW,EAAE,wEAAwE;YACrF,QAAQ,EAAE,QAAQ;SACnB;KACF,CAAC;IACD,KAAK,EAAE;GACK,aAAa,CAUzB;;AAED;;GAEG;AAgBI,IAAM,WAAW,GAAjB,MAAM,WAAY,SAAQ,KAAK;CAUrC,CAAA;AANC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAClF,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;0CACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,eAAe,EAAE,CAAC;IACjF,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;;2CACZ;AATN,WAAW;IAfvB,IAAI,CAAC,eAAe,EAAE;QACrB,IAAI,EAAE,eAAe;QACrB,QAAQ,EAAE,SAAS;QACnB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,sBAAsB;QAC5B,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC;QACpC,QAAQ,EAAE;YACR,KAAK,EAAE,KAAK;YACZ,WAAW,EAAE,oFAAoF;YACjG,MAAM,EAAE,EAAE;SACX;KACF,CAAC;IACD,KAAK,EAAE;GACK,WAAW,CAUvB;;AAED;;GAEG;AAgBI,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,KAAK;CAUvC,CAAA;AANC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,8BAA8B,EAAE,CAAC;IAC5F,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;4CACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,iBAAiB,EAAE,CAAC;IAC7E,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;+CACT;AATR,aAAa;IAfzB,IAAI,CAAC,iBAAiB,EAAE;QACvB,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,SAAS;QACnB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,iBAAiB;QACvB,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC;QACjC,QAAQ,EAAE;YACR,KAAK,EAAE,OAAO;YACd,WAAW,EAAE,oGAAoG;YACjH,UAAU,EAAE,IAAI;SACjB;KACF,CAAC;IACD,KAAK,EAAE;GACK,aAAa,CAUzB;;AAED;;GAEG;AAgBI,IAAM,qBAAqB,GAA3B,MAAM,qBAAsB,SAAQ,KAAK;CAe/C,CAAA;AAXC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAC9E,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;oDACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACzE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;;qDACZ;AAKjB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACxE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;oDACZ;AAdL,qBAAqB;IAfjC,IAAI,CAAC,yBAAyB,EAAE;QAC/B,IAAI,EAAE,yBAAyB;QAC/B,QAAQ,EAAE,cAAc;QACxB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,iBAAiB;QACvB,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC;QACtC,QAAQ,EAAE;YACR,KAAK,EAAE,gBAAgB;YACvB,WAAW,EAAE,+FAA+F;YAC5G,OAAO,EAAE,KAAK;SACf;KACF,CAAC;IACD,KAAK,EAAE;GACK,qBAAqB,CAejC;;AAED;;GAEG;AAiBI,IAAM,qBAAqB,GAA3B,MAAM,qBAAsB,SAAQ,KAAK;CAe/C,CAAA;AAXC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,wBAAwB,EAAE,CAAC;IACtF,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;oDACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE,CAAC;IAC9E,MAAM,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;;uDACZ;AAKnB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE,CAAC;IAC9E,MAAM,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;;uDACZ;AAdR,qBAAqB;IAhBjC,IAAI,CAAC,yBAAyB,EAAE;QAC/B,IAAI,EAAE,yBAAyB;QAC/B,QAAQ,EAAE,cAAc;QACxB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,eAAe;QACrB,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC;QACvC,QAAQ,EAAE;YACR,KAAK,EAAE,gBAAgB;YACvB,WAAW,EAAE,gGAAgG;YAC7G,SAAS,EAAE,EAAE;YACb,SAAS,EAAE,QAAQ;SACpB;KACF,CAAC;IACD,KAAK,EAAE;GACK,qBAAqB,CAejC;;AAED;;GAEG;AAgBI,IAAM,cAAc,GAApB,MAAM,cAAe,SAAQ,KAAK;CAUxC,CAAA;AANC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAClF,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;6CACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAC;IAClF,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;;8CACZ;AATN,cAAc;IAf1B,IAAI,CAAC,kBAAkB,EAAE;QACxB,IAAI,EAAE,kBAAkB;QACxB,QAAQ,EAAE,SAAS;QACnB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,kBAAkB;QACxB,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC;QACpC,QAAQ,EAAE;YACR,KAAK,EAAE,QAAQ;YACf,WAAW,EAAE,6DAA6D;YAC1E,YAAY,EAAE,EAAE;SACjB;KACF,CAAC;IACD,KAAK,EAAE;GACK,cAAc,CAU1B;;AAED;;;;;;;;GAQG;AAiBI,IAAM,YAAY,GAAlB,MAAM,YAAa,SAAQ,KAAK;CAUtC,CAAA;AANC;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,qCAAqC,EAAE,CAAC;IAC7F,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;;2CACX;AAKhB;IAHC,QAAQ,EAAE;IACV,SAAS,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,uBAAuB,EAAE,CAAC;IAC7E,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;;4CACZ;AATN,YAAY;IAhBxB,IAAI,CAAC,gBAAgB,EAAE;QACtB,IAAI,EAAE,gBAAgB;QACtB,QAAQ,EAAE,SAAS;QACnB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,SAAS;QACf,KAAK,EAAE,EAAE;QACT,MAAM,EAAE,EAAE;QACV,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,CAAC;QAChD,QAAQ,EAAE;YACR,KAAK,EAAE,MAAM;YACb,WAAW,EAAE,gHAAgH;YAC7H,IAAI,EAAE,EAAE;YACR,QAAQ,EAAE,YAAY;SACvB;KACF,CAAC;IACD,KAAK,EAAE;GACK,YAAY,CAUxB;;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,UAAU;IACV,cAAc;IACd,gBAAgB;IAChB,aAAa;IACb,WAAW;IACX,aAAa;IACb,qBAAqB;IACrB,qBAAqB;IACrB,cAAc;IACd,YAAY;CACJ,CAAC","sourcesContent":["/**\n * @module integrations/graph/nodes/flow-control\n * @summary Production flow-control node kind declarations (DECAF-32 §22.2.2).\n * @description Canonical `@node`-decorated classes for the ten ALFRED-5\n * flow-control kinds. These are graph-level macros: the engine's planner\n * recognises them as ordinary executable nodes (§5.7) but they have no\n * built-in executors — downstream projects (e.g. ALFRED) register custom\n * executors or compile them into Mastra composition APIs (§22.2.2).\n *\n * The three loop kinds (`core.loop.foreach/while/until`) already have built-in\n * executors (§5.9) and are NOT redeclared here.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"@decaf-ts/ui-decorators\";\nimport { input, node, output } from \"@decaf-ts/ui-decorators/graph\";\n\n/**\n * If — conditional branch. Evaluates a `ConditionExpression` (§22.3) and\n * routes the input to the `then` or `else` output.\n */\n@node(\"core.flow.if\", {\n  kind: \"core.flow.if\",\n  category: \"Flow Control\",\n  color: \"#f59e0b\",\n  icon: \"ti-arrows-split-2\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"conditional\", \"branch\"],\n  metadata: {\n    title: \"If\",\n    description: \"Conditional branch. Evaluates the configured condition and routes the input to the matching output.\",\n    condition: { op: \"eq\", left: { const: true }, right: { const: true } },\n  },\n})\n@model()\nexport class IfFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to evaluate\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Then\", placeholder: \"Output when condition is true\" })\n  @output({ handle: \"then\" })\n  then!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Else\", placeholder: \"Output when condition is false\" })\n  @output({ handle: \"else\" })\n  else!: unknown;\n}\n\n/**\n * Switch — multi-branch. Routes the input to one of the case output ports\n * or `default` based on matching conditions. Each case defines a\n * {@link SwitchCaseCondition} (graphical or code mode) and a dedicated\n * output port. Cases are stored in `metadata.switch.cases` and the\n * renderer creates dynamic output ports from them (DECAF-32 §22.2.2).\n *\n * The node grows in height as cases are added. Each case gets its own\n * output port on the right side, labeled with the case label.\n */\n@node(\"core.flow.switch\", {\n  kind: \"core.flow.switch\",\n  category: \"Flow Control\",\n  color: \"#f97316\",\n  icon: \"ti-arrows-shuffle\",\n  width: 120,\n  height: 140,\n  labels: [\"flow\", \"switch\", \"multi-branch\"],\n  metadata: {\n    title: \"Switch\",\n    description: \"Multi-branch switch. Routes the input to the first matching case output, or the default output.\",\n    switch: {\n      cases: [],\n      defaultPort: \"default\",\n    },\n  },\n})\n@model()\nexport class SwitchFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to switch on\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Default\", placeholder: \"Default output when no case matches\" })\n  @output({ handle: \"default\" })\n  default!: unknown;\n}\n\n/**\n * Parallel — splits execution into concurrent branches.\n */\n@node(\"core.flow.parallel\", {\n  kind: \"core.flow.parallel\",\n  category: \"Flow Control\",\n  color: \"#06b6d4\",\n  icon: \"ti-arrows-vertical\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"parallel\", \"concurrent\"],\n  metadata: {\n    title: \"Parallel\",\n    description: \"Splits execution into concurrent branches. All branches run in parallel and outputs are collected.\",\n    branchCount: 2,\n  },\n})\n@model()\nexport class ParallelFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to fan out\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Branches\", placeholder: \"Collected branch outputs\" })\n  @output({ handle: \"branches\" })\n  branches!: unknown[];\n}\n\n/**\n * Merge — normalises branch/parallel outputs into a single output.\n */\n@node(\"core.flow.merge\", {\n  kind: \"core.flow.merge\",\n  category: \"Utility\",\n  color: \"#0d9488\",\n  icon: \"ti-arrows-merge\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"merge\", \"join\"],\n  metadata: {\n    title: \"Merge\",\n    description: \"Merges multiple branch outputs into a single normalised output object.\",\n    strategy: \"concat\",\n  },\n})\n@model()\nexport class MergeFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Branch outputs\", placeholder: \"Outputs to merge\" })\n  @input({ handle: \"values\" })\n  values!: unknown[];\n\n  @required()\n  @uielement(\"input\", { label: \"Merged output\", placeholder: \"Merged result\" })\n  @output({ handle: \"merged\" })\n  merged!: unknown;\n}\n\n/**\n * Map — transforms the current input into a new output object.\n */\n@node(\"core.flow.map\", {\n  kind: \"core.flow.map\",\n  category: \"Utility\",\n  color: \"#84cc16\",\n  icon: \"ti-arrows-right-left\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"map\", \"transform\"],\n  metadata: {\n    title: \"Map\",\n    description: \"Transforms the current input into a new output object using the configured mapper.\",\n    mapper: {},\n  },\n})\n@model()\nexport class MapFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to transform\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Transformed output\", placeholder: \"Mapped result\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n}\n\n/**\n * Delay — pauses execution for a configured duration.\n */\n@node(\"core.flow.delay\", {\n  kind: \"core.flow.delay\",\n  category: \"Utility\",\n  color: \"#a3a3a3\",\n  icon: \"ti-clock-hour-4\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"delay\", \"wait\"],\n  metadata: {\n    title: \"Delay\",\n    description: \"Pauses execution for the configured duration (in milliseconds), then forwards the input unchanged.\",\n    durationMs: 1000,\n  },\n})\n@model()\nexport class DelayFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to forward after delay\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Output value\", placeholder: \"Forwarded value\" })\n  @output({ handle: \"value\" })\n  valueOut!: unknown;\n}\n\n/**\n * Error boundary — try/catch/finally workflow behaviour.\n */\n@node(\"core.flow.errorBoundary\", {\n  kind: \"core.flow.errorBoundary\",\n  category: \"Flow Control\",\n  color: \"#ef4444\",\n  icon: \"ti-shield-check\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"error\", \"try-catch\"],\n  metadata: {\n    title: \"Error boundary\",\n    description: \"Wraps the input in a try/catch/finally. Emits the result on success, or the error on failure.\",\n    finally: false,\n  },\n})\n@model()\nexport class ErrorBoundaryFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to guard\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Result\", placeholder: \"Output on success\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Error\", placeholder: \"Output on failure\" })\n  @output({ handle: \"error\" })\n  error!: unknown;\n}\n\n/**\n * Human approval — suspends execution until a human approves or rejects.\n */\n@node(\"core.flow.humanApproval\", {\n  kind: \"core.flow.humanApproval\",\n  category: \"Flow Control\",\n  color: \"#d946ef\",\n  icon: \"ti-user-check\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"approval\", \"suspend\"],\n  metadata: {\n    title: \"Human approval\",\n    description: \"Suspends execution until a human approves or rejects. Emits the approved value or a rejection.\",\n    approvers: [],\n    timeoutMs: 86400000,\n  },\n})\n@model()\nexport class HumanApprovalFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value pending approval\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Approved\", placeholder: \"Output when approved\" })\n  @output({ handle: \"approved\" })\n  approved!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Rejected\", placeholder: \"Output when rejected\" })\n  @output({ handle: \"rejected\" })\n  rejected!: unknown;\n}\n\n/**\n * Return — defines and normalises the final workflow output.\n */\n@node(\"core.flow.return\", {\n  kind: \"core.flow.return\",\n  category: \"Utility\",\n  color: \"#22c55e\",\n  icon: \"ti-arrow-back-up\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"return\", \"output\"],\n  metadata: {\n    title: \"Return\",\n    description: \"Normalises the input into the final workflow output object.\",\n    outputSchema: {},\n  },\n})\n@model()\nexport class ReturnFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to normalise\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Returned output\", placeholder: \"Normalised output\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n}\n\n/**\n * Code — sandboxed JS/TS code execution (ALFRED-5 §7).\n *\n * The engine does not implement the sandbox directly (§22.4). A future\n * executor may wrap the `CodeSandbox` contract (ALFRED-5 §7.17) as a\n * pluggable executor. The placeholder syntax (`{{ $input }}`, `{{ $item }}`,\n * `{{ $index }}`, `{{ $vars }}`, `{{ $node[\"Name\"].output }}`) is Mastra-\n * agnostic and lives in the downstream project's `modules/core` (ALFRED-6).\n */\n@node(\"core.flow.code\", {\n  kind: \"core.flow.code\",\n  category: \"Utility\",\n  color: \"#7c3aed\",\n  icon: \"ti-code\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"code\", \"sandbox\", \"transform\"],\n  metadata: {\n    title: \"Code\",\n    description: \"Runs user-authored JS/TS in a restricted VM sandbox. Supports placeholder syntax for workflow data references.\",\n    code: \"\",\n    language: \"javascript\",\n  },\n})\n@model()\nexport class CodeFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input\", placeholder: \"Input object (accessible as $input)\" })\n  @input({ handle: \"input\" })\n  input!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Result\", placeholder: \"Code execution result\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n}\n\n/**\n * All built-in flow-control node constructors.\n */\nexport const GRAPH_FLOW_CONTROL_NODES = [\n  IfFlowNode,\n  SwitchFlowNode,\n  ParallelFlowNode,\n  MergeFlowNode,\n  MapFlowNode,\n  DelayFlowNode,\n  ErrorBoundaryFlowNode,\n  HumanApprovalFlowNode,\n  ReturnFlowNode,\n  CodeFlowNode,\n] as const;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-control.js","sourceRoot":"","sources":["flow-control.js"],"names":[],"mappings":"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","sourcesContent":["var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\n/**\n * @module integrations/graph/nodes/flow-control\n * @summary Production flow-control node kind declarations (DECAF-32 §22.2.2).\n * @description Canonical `@node`-decorated classes for the ten ALFRED-5\n * flow-control kinds. These are graph-level macros: the engine's planner\n * recognises them as ordinary executable nodes (§5.7) but they have no\n * built-in executors — downstream projects (e.g. ALFRED) register custom\n * executors or compile them into Mastra composition APIs (§22.2.2).\n *\n * The three loop kinds (`core.loop.foreach/while/until`) already have built-in\n * executors (§5.9) and are NOT redeclared here.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"@decaf-ts/ui-decorators\";\nimport { input, node, output } from \"@decaf-ts/ui-decorators/graph\";\n/**\n * If — conditional branch. Evaluates a `ConditionExpression` (§22.3) and\n * routes the input to the `then` or `else` output.\n */\nlet IfFlowNode = class IfFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to evaluate\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], IfFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Then\", placeholder: \"Output when condition is true\" }),\n    output({ handle: \"then\" }),\n    __metadata(\"design:type\", Object)\n], IfFlowNode.prototype, \"then\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Else\", placeholder: \"Output when condition is false\" }),\n    output({ handle: \"else\" }),\n    __metadata(\"design:type\", Object)\n], IfFlowNode.prototype, \"else\", void 0);\nIfFlowNode = __decorate([\n    node(\"core.flow.if\", {\n        kind: \"core.flow.if\",\n        category: \"Flow Control\",\n        color: \"#f59e0b\",\n        icon: \"ti-arrows-split-2\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"conditional\", \"branch\"],\n        metadata: {\n            title: \"If\",\n            description: \"Conditional branch. Evaluates the configured condition and routes the input to the matching output.\",\n            condition: { op: \"eq\", left: { const: true }, right: { const: true } },\n        },\n    }),\n    model()\n], IfFlowNode);\nexport { IfFlowNode };\n/**\n * Switch — multi-branch. Routes the input to one of the case output ports\n * or `default` based on matching conditions. Each case defines a\n * {@link SwitchCaseCondition} (graphical or code mode) and a dedicated\n * output port. Cases are stored in `metadata.switch.cases` and the\n * renderer creates dynamic output ports from them (DECAF-32 §22.2.2).\n *\n * The node grows in height as cases are added. Each case gets its own\n * output port on the right side, labeled with the case label.\n */\nlet SwitchFlowNode = class SwitchFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to switch on\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], SwitchFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Default\", placeholder: \"Default output when no case matches\" }),\n    output({ handle: \"default\" }),\n    __metadata(\"design:type\", Object)\n], SwitchFlowNode.prototype, \"default\", void 0);\nSwitchFlowNode = __decorate([\n    node(\"core.flow.switch\", {\n        kind: \"core.flow.switch\",\n        category: \"Flow Control\",\n        color: \"#f97316\",\n        icon: \"ti-arrows-shuffle\",\n        width: 120,\n        height: 140,\n        labels: [\"flow\", \"switch\", \"multi-branch\"],\n        metadata: {\n            title: \"Switch\",\n            description: \"Multi-branch switch. Routes the input to the first matching case output, or the default output.\",\n            switch: {\n                cases: [],\n                defaultPort: \"default\",\n            },\n        },\n    }),\n    model()\n], SwitchFlowNode);\nexport { SwitchFlowNode };\n/**\n * Parallel — splits execution into concurrent branches.\n */\nlet ParallelFlowNode = class ParallelFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to fan out\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], ParallelFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Branches\", placeholder: \"Collected branch outputs\" }),\n    output({ handle: \"branches\" }),\n    __metadata(\"design:type\", Array)\n], ParallelFlowNode.prototype, \"branches\", void 0);\nParallelFlowNode = __decorate([\n    node(\"core.flow.parallel\", {\n        kind: \"core.flow.parallel\",\n        category: \"Flow Control\",\n        color: \"#06b6d4\",\n        icon: \"ti-arrows-vertical\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"parallel\", \"concurrent\"],\n        metadata: {\n            title: \"Parallel\",\n            description: \"Splits execution into concurrent branches. All branches run in parallel and outputs are collected.\",\n            branchCount: 2,\n        },\n    }),\n    model()\n], ParallelFlowNode);\nexport { ParallelFlowNode };\n/**\n * Merge — normalises branch/parallel outputs into a single output.\n */\nlet MergeFlowNode = class MergeFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Branch outputs\", placeholder: \"Outputs to merge\" }),\n    input({ handle: \"values\" }),\n    __metadata(\"design:type\", Array)\n], MergeFlowNode.prototype, \"values\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Merged output\", placeholder: \"Merged result\" }),\n    output({ handle: \"merged\" }),\n    __metadata(\"design:type\", Object)\n], MergeFlowNode.prototype, \"merged\", void 0);\nMergeFlowNode = __decorate([\n    node(\"core.flow.merge\", {\n        kind: \"core.flow.merge\",\n        category: \"Utility\",\n        color: \"#0d9488\",\n        icon: \"ti-arrows-merge\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"merge\", \"join\"],\n        metadata: {\n            title: \"Merge\",\n            description: \"Merges multiple branch outputs into a single normalised output object.\",\n            strategy: \"concat\",\n        },\n    }),\n    model()\n], MergeFlowNode);\nexport { MergeFlowNode };\n/**\n * Map — transforms the current input into a new output object.\n */\nlet MapFlowNode = class MapFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to transform\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], MapFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Transformed output\", placeholder: \"Mapped result\" }),\n    output({ handle: \"result\" }),\n    __metadata(\"design:type\", Object)\n], MapFlowNode.prototype, \"result\", void 0);\nMapFlowNode = __decorate([\n    node(\"core.flow.map\", {\n        kind: \"core.flow.map\",\n        category: \"Utility\",\n        color: \"#84cc16\",\n        icon: \"ti-arrows-right-left\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"map\", \"transform\"],\n        metadata: {\n            title: \"Map\",\n            description: \"Transforms the current input into a new output object using the configured mapper.\",\n            mapper: {},\n        },\n    }),\n    model()\n], MapFlowNode);\nexport { MapFlowNode };\n/**\n * Delay — pauses execution for a configured duration.\n */\nlet DelayFlowNode = class DelayFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to forward after delay\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], DelayFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Output value\", placeholder: \"Forwarded value\" }),\n    output({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], DelayFlowNode.prototype, \"valueOut\", void 0);\nDelayFlowNode = __decorate([\n    node(\"core.flow.delay\", {\n        kind: \"core.flow.delay\",\n        category: \"Utility\",\n        color: \"#a3a3a3\",\n        icon: \"ti-clock-hour-4\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"delay\", \"wait\"],\n        metadata: {\n            title: \"Delay\",\n            description: \"Pauses execution for the configured duration (in milliseconds), then forwards the input unchanged.\",\n            durationMs: 1000,\n        },\n    }),\n    model()\n], DelayFlowNode);\nexport { DelayFlowNode };\n/**\n * Error boundary — try/catch/finally workflow behaviour.\n */\nlet ErrorBoundaryFlowNode = class ErrorBoundaryFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to guard\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], ErrorBoundaryFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Result\", placeholder: \"Output on success\" }),\n    output({ handle: \"result\" }),\n    __metadata(\"design:type\", Object)\n], ErrorBoundaryFlowNode.prototype, \"result\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Error\", placeholder: \"Output on failure\" }),\n    output({ handle: \"error\" }),\n    __metadata(\"design:type\", Object)\n], ErrorBoundaryFlowNode.prototype, \"error\", void 0);\nErrorBoundaryFlowNode = __decorate([\n    node(\"core.flow.errorBoundary\", {\n        kind: \"core.flow.errorBoundary\",\n        category: \"Flow Control\",\n        color: \"#ef4444\",\n        icon: \"ti-shield-check\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"error\", \"try-catch\"],\n        metadata: {\n            title: \"Error boundary\",\n            description: \"Wraps the input in a try/catch/finally. Emits the result on success, or the error on failure.\",\n            finally: false,\n        },\n    }),\n    model()\n], ErrorBoundaryFlowNode);\nexport { ErrorBoundaryFlowNode };\n/**\n * Human approval — suspends execution until a human approves or rejects.\n */\nlet HumanApprovalFlowNode = class HumanApprovalFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value pending approval\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], HumanApprovalFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Approved\", placeholder: \"Output when approved\" }),\n    output({ handle: \"approved\" }),\n    __metadata(\"design:type\", Object)\n], HumanApprovalFlowNode.prototype, \"approved\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Rejected\", placeholder: \"Output when rejected\" }),\n    output({ handle: \"rejected\" }),\n    __metadata(\"design:type\", Object)\n], HumanApprovalFlowNode.prototype, \"rejected\", void 0);\nHumanApprovalFlowNode = __decorate([\n    node(\"core.flow.humanApproval\", {\n        kind: \"core.flow.humanApproval\",\n        category: \"Flow Control\",\n        color: \"#d946ef\",\n        icon: \"ti-user-check\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"approval\", \"suspend\"],\n        metadata: {\n            title: \"Human approval\",\n            description: \"Suspends execution until a human approves or rejects. Emits the approved value or a rejection.\",\n            approvers: [],\n            timeoutMs: 86400000,\n        },\n    }),\n    model()\n], HumanApprovalFlowNode);\nexport { HumanApprovalFlowNode };\n/**\n * Return — defines and normalises the final workflow output.\n */\nlet ReturnFlowNode = class ReturnFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to normalise\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], ReturnFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Returned output\", placeholder: \"Normalised output\" }),\n    output({ handle: \"result\" }),\n    __metadata(\"design:type\", Object)\n], ReturnFlowNode.prototype, \"result\", void 0);\nReturnFlowNode = __decorate([\n    node(\"core.flow.return\", {\n        kind: \"core.flow.return\",\n        category: \"Utility\",\n        color: \"#22c55e\",\n        icon: \"ti-arrow-back-up\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"return\", \"output\"],\n        metadata: {\n            title: \"Return\",\n            description: \"Normalises the input into the final workflow output object.\",\n            outputSchema: {},\n        },\n    }),\n    model()\n], ReturnFlowNode);\nexport { ReturnFlowNode };\n/**\n * Code — sandboxed JS/TS code execution (ALFRED-5 §7).\n *\n * The engine does not implement the sandbox directly (§22.4). A future\n * executor may wrap the `CodeSandbox` contract (ALFRED-5 §7.17) as a\n * pluggable executor. The placeholder syntax (`{{ $input }}`, `{{ $item }}`,\n * `{{ $index }}`, `{{ $vars }}`, `{{ $node[\"Name\"].output }}`) is Mastra-\n * agnostic and lives in the downstream project's `modules/core` (ALFRED-6).\n */\nlet CodeFlowNode = class CodeFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input\", placeholder: \"Input object (accessible as $input)\" }),\n    input({ handle: \"input\" }),\n    __metadata(\"design:type\", Object)\n], CodeFlowNode.prototype, \"input\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Result\", placeholder: \"Code execution result\" }),\n    output({ handle: \"result\" }),\n    __metadata(\"design:type\", Object)\n], CodeFlowNode.prototype, \"result\", void 0);\nCodeFlowNode = __decorate([\n    node(\"core.flow.code\", {\n        kind: \"core.flow.code\",\n        category: \"Utility\",\n        color: \"#7c3aed\",\n        icon: \"ti-code\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"code\", \"sandbox\", \"transform\"],\n        metadata: {\n            title: \"Code\",\n            description: \"Runs user-authored JS/TS in a restricted VM sandbox. Supports placeholder syntax for workflow data references.\",\n            code: \"\",\n            language: \"javascript\",\n        },\n    }),\n    model()\n], CodeFlowNode);\nexport { CodeFlowNode };\n/**\n * All built-in flow-control node constructors.\n */\nexport const GRAPH_FLOW_CONTROL_NODES = [\n    IfFlowNode,\n    SwitchFlowNode,\n    ParallelFlowNode,\n    MergeFlowNode,\n    MapFlowNode,\n    DelayFlowNode,\n    ErrorBoundaryFlowNode,\n    HumanApprovalFlowNode,\n    ReturnFlowNode,\n    CodeFlowNode,\n];\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-control.js","sourceRoot":"","sources":["../../../../src/graph/nodes/flow-control.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/graph/nodes/flow-control\n * @summary Production flow-control node kind declarations (DECAF-32 §22.2.2).\n * @description Canonical `@node`-decorated classes for the ten ALFRED-5\n * flow-control kinds. These are graph-level macros: the engine's planner\n * recognises them as ordinary executable nodes (§5.7) but they have no\n * built-in executors — downstream projects (e.g. ALFRED) register custom\n * executors or compile them into Mastra composition APIs (§22.2.2).\n *\n * The three loop kinds (`core.loop.foreach/while/until`) already have built-in\n * executors (§5.9) and are NOT redeclared here.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"@decaf-ts/ui-decorators\";\nimport { input, node, output } from \"@decaf-ts/ui-decorators/graph\";\n\n/**\n * If — conditional branch. Evaluates a `ConditionExpression` (§22.3) and\n * routes the input to the `then` or `else` output.\n */\n@node(\"core.flow.if\", {\n  kind: \"core.flow.if\",\n  category: \"Flow Control\",\n  color: \"#f59e0b\",\n  icon: \"ti-arrows-split-2\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"conditional\", \"branch\"],\n  metadata: {\n    title: \"If\",\n    description: \"Conditional branch. Evaluates the configured condition and routes the input to the matching output.\",\n    condition: { op: \"eq\", left: { const: true }, right: { const: true } },\n  },\n})\n@model()\nexport class IfFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to evaluate\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Then\", placeholder: \"Output when condition is true\" })\n  @output({ handle: \"then\" })\n  then!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Else\", placeholder: \"Output when condition is false\" })\n  @output({ handle: \"else\" })\n  else!: unknown;\n}\n\n/**\n * Switch — multi-branch. Routes the input to one of the case output ports\n * or `default` based on matching conditions. Each case defines a\n * {@link SwitchCaseCondition} (graphical or code mode) and a dedicated\n * output port. Cases are stored in `metadata.switch.cases` and the\n * renderer creates dynamic output ports from them (DECAF-32 §22.2.2).\n *\n * The node grows in height as cases are added. Each case gets its own\n * output port on the right side, labeled with the case label.\n */\n@node(\"core.flow.switch\", {\n  kind: \"core.flow.switch\",\n  category: \"Flow Control\",\n  color: \"#f97316\",\n  icon: \"ti-arrows-shuffle\",\n  width: 120,\n  height: 140,\n  labels: [\"flow\", \"switch\", \"multi-branch\"],\n  metadata: {\n    title: \"Switch\",\n    description: \"Multi-branch switch. Routes the input to the first matching case output, or the default output.\",\n    switch: {\n      cases: [],\n      defaultPort: \"default\",\n    },\n  },\n})\n@model()\nexport class SwitchFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to switch on\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Default\", placeholder: \"Default output when no case matches\" })\n  @output({ handle: \"default\" })\n  default!: unknown;\n}\n\n/**\n * Parallel — splits execution into concurrent branches.\n */\n@node(\"core.flow.parallel\", {\n  kind: \"core.flow.parallel\",\n  category: \"Flow Control\",\n  color: \"#06b6d4\",\n  icon: \"ti-arrows-vertical\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"parallel\", \"concurrent\"],\n  metadata: {\n    title: \"Parallel\",\n    description: \"Splits execution into concurrent branches. All branches run in parallel and outputs are collected.\",\n    branchCount: 2,\n  },\n})\n@model()\nexport class ParallelFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to fan out\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Branches\", placeholder: \"Collected branch outputs\" })\n  @output({ handle: \"branches\" })\n  branches!: unknown[];\n}\n\n/**\n * Merge — normalises branch/parallel outputs into a single output.\n */\n@node(\"core.flow.merge\", {\n  kind: \"core.flow.merge\",\n  category: \"Utility\",\n  color: \"#0d9488\",\n  icon: \"ti-arrows-merge\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"merge\", \"join\"],\n  metadata: {\n    title: \"Merge\",\n    description: \"Merges multiple branch outputs into a single normalised output object.\",\n    strategy: \"concat\",\n  },\n})\n@model()\nexport class MergeFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Branch outputs\", placeholder: \"Outputs to merge\" })\n  @input({ handle: \"values\" })\n  values!: unknown[];\n\n  @required()\n  @uielement(\"input\", { label: \"Merged output\", placeholder: \"Merged result\" })\n  @output({ handle: \"merged\" })\n  merged!: unknown;\n}\n\n/**\n * Map — transforms the current input into a new output object.\n */\n@node(\"core.flow.map\", {\n  kind: \"core.flow.map\",\n  category: \"Utility\",\n  color: \"#84cc16\",\n  icon: \"ti-arrows-right-left\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"map\", \"transform\"],\n  metadata: {\n    title: \"Map\",\n    description: \"Transforms the current input into a new output object using the configured mapper.\",\n    mapper: {},\n  },\n})\n@model()\nexport class MapFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to transform\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Transformed output\", placeholder: \"Mapped result\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n}\n\n/**\n * Delay — pauses execution for a configured duration.\n */\n@node(\"core.flow.delay\", {\n  kind: \"core.flow.delay\",\n  category: \"Utility\",\n  color: \"#a3a3a3\",\n  icon: \"ti-clock-hour-4\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"delay\", \"wait\"],\n  metadata: {\n    title: \"Delay\",\n    description: \"Pauses execution for the configured duration (in milliseconds), then forwards the input unchanged.\",\n    durationMs: 1000,\n  },\n})\n@model()\nexport class DelayFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to forward after delay\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Output value\", placeholder: \"Forwarded value\" })\n  @output({ handle: \"value\" })\n  valueOut!: unknown;\n}\n\n/**\n * Error boundary — try/catch/finally workflow behaviour.\n */\n@node(\"core.flow.errorBoundary\", {\n  kind: \"core.flow.errorBoundary\",\n  category: \"Flow Control\",\n  color: \"#ef4444\",\n  icon: \"ti-shield-check\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"error\", \"try-catch\"],\n  metadata: {\n    title: \"Error boundary\",\n    description: \"Wraps the input in a try/catch/finally. Emits the result on success, or the error on failure.\",\n    finally: false,\n  },\n})\n@model()\nexport class ErrorBoundaryFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to guard\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Result\", placeholder: \"Output on success\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Error\", placeholder: \"Output on failure\" })\n  @output({ handle: \"error\" })\n  error!: unknown;\n}\n\n/**\n * Human approval — suspends execution until a human approves or rejects.\n */\n@node(\"core.flow.humanApproval\", {\n  kind: \"core.flow.humanApproval\",\n  category: \"Flow Control\",\n  color: \"#d946ef\",\n  icon: \"ti-user-check\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"approval\", \"suspend\"],\n  metadata: {\n    title: \"Human approval\",\n    description: \"Suspends execution until a human approves or rejects. Emits the approved value or a rejection.\",\n    approvers: [],\n    timeoutMs: 86400000,\n  },\n})\n@model()\nexport class HumanApprovalFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value pending approval\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Approved\", placeholder: \"Output when approved\" })\n  @output({ handle: \"approved\" })\n  approved!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Rejected\", placeholder: \"Output when rejected\" })\n  @output({ handle: \"rejected\" })\n  rejected!: unknown;\n}\n\n/**\n * Return — defines and normalises the final workflow output.\n */\n@node(\"core.flow.return\", {\n  kind: \"core.flow.return\",\n  category: \"Utility\",\n  color: \"#22c55e\",\n  icon: \"ti-arrow-back-up\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"return\", \"output\"],\n  metadata: {\n    title: \"Return\",\n    description: \"Normalises the input into the final workflow output object.\",\n    outputSchema: {},\n  },\n})\n@model()\nexport class ReturnFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to normalise\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Returned output\", placeholder: \"Normalised output\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n}\n\n/**\n * Code — sandboxed JS/TS code execution (ALFRED-5 §7).\n *\n * The engine does not implement the sandbox directly (§22.4). A future\n * executor may wrap the `CodeSandbox` contract (ALFRED-5 §7.17) as a\n * pluggable executor. The placeholder syntax (`{{ $input }}`, `{{ $item }}`,\n * `{{ $index }}`, `{{ $vars }}`, `{{ $node[\"Name\"].output }}`) is Mastra-\n * agnostic and lives in the downstream project's `modules/core` (ALFRED-6).\n */\n@node(\"core.flow.code\", {\n  kind: \"core.flow.code\",\n  category: \"Utility\",\n  color: \"#7c3aed\",\n  icon: \"ti-code\",\n  width: 96,\n  height: 96,\n  labels: [\"flow\", \"code\", \"sandbox\", \"transform\"],\n  metadata: {\n    title: \"Code\",\n    description: \"Runs user-authored JS/TS in a restricted VM sandbox. Supports placeholder syntax for workflow data references.\",\n    code: \"\",\n    language: \"javascript\",\n  },\n})\n@model()\nexport class CodeFlowNode extends Model {\n  @required()\n  @uielement(\"textarea\", { label: \"Input\", placeholder: \"Input object (accessible as $input)\" })\n  @input({ handle: \"input\" })\n  input!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Result\", placeholder: \"Code execution result\" })\n  @output({ handle: \"result\" })\n  result!: unknown;\n}\n\n/**\n * All built-in flow-control node constructors.\n */\nexport const GRAPH_FLOW_CONTROL_NODES = [\n  IfFlowNode,\n  SwitchFlowNode,\n  ParallelFlowNode,\n  MergeFlowNode,\n  MapFlowNode,\n  DelayFlowNode,\n  ErrorBoundaryFlowNode,\n  HumanApprovalFlowNode,\n  ReturnFlowNode,\n  CodeFlowNode,\n] as const;\n"]}"]}