@decaf-ts/integrations 0.3.7 → 0.3.9

package/lib/esm/graph/shared/nodes/flow-control.js

@@ -0,0 +1,455 @@
+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.
+ */
+import { Model, model, required } from "@decaf-ts/decorator-validation";
+import { uielement } from "@decaf-ts/ui-decorators";
+import { graphDefinitionOf, input, node, output, PortDirection, } from "@decaf-ts/ui-decorators/graph";
+import { GraphNode } from "./base.js";
+/**
+ * If — conditional branch. Evaluates a `ConditionExpression` (§22.3) and
+ * routes the input to the `then` or `else` output.
+ */
+let IfFlowNode = class IfFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to evaluate" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Then", placeholder: "Output when condition is true" }),
+    output({ handle: "then" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "then", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Else", placeholder: "Output when condition is false" }),
+    output({ handle: "else" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "else", void 0);
+IfFlowNode = __decorate([
+    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 } },
+        },
+    }),
+    model()
+], IfFlowNode);
+export { 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 GraphNode {
+    /**
+     * Computes the node's ports, size, and data patch from the given switch
+     * metadata. Each case gets its own output port on the right side; the
+     * node grows in height as cases are added.
+     */
+    static applyMetadata(meta) {
+        const definition = graphDefinitionOf(this);
+        const basePorts = definition.ports.filter((p) => !meta.cases.some((c) => c.outputPort === p.property));
+        const casePorts = meta.cases.map((c) => ({
+            property: c.outputPort,
+            name: c.label,
+            direction: PortDirection.OUTPUT,
+            label: c.label,
+            required: false,
+            hidden: false,
+            path: c.outputPort,
+        }));
+        const caseCount = meta.cases.length;
+        return {
+            ports: [...basePorts, ...casePorts],
+            size: {
+                width: definition.width ?? 120,
+                height: caseCount > 0 ? 140 + caseCount * 24 : definition.height ?? 140,
+            },
+            dataPatch: { switchMetadata: meta },
+        };
+    }
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to switch on" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], SwitchFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Default", placeholder: "Default output when no case matches" }),
+    output({ handle: "default" }),
+    __metadata("design:type", Object)
+], SwitchFlowNode.prototype, "default", void 0);
+SwitchFlowNode = __decorate([
+    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",
+            },
+        },
+    }),
+    model()
+], SwitchFlowNode);
+export { SwitchFlowNode };
+/**
+ * Parallel — splits execution into concurrent branches.
+ */
+let ParallelFlowNode = class ParallelFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to fan out" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], ParallelFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Branches", placeholder: "Collected branch outputs" }),
+    output({ handle: "branches" }),
+    __metadata("design:type", Array)
+], ParallelFlowNode.prototype, "branches", void 0);
+ParallelFlowNode = __decorate([
+    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,
+        },
+    }),
+    model()
+], ParallelFlowNode);
+export { ParallelFlowNode };
+/**
+ * Merge — normalises branch/parallel outputs into a single output.
+ */
+let MergeFlowNode = class MergeFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Branch outputs", placeholder: "Outputs to merge" }),
+    input({ handle: "values" }),
+    __metadata("design:type", Array)
+], MergeFlowNode.prototype, "values", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Merged output", placeholder: "Merged result" }),
+    output({ handle: "merged" }),
+    __metadata("design:type", Object)
+], MergeFlowNode.prototype, "merged", void 0);
+MergeFlowNode = __decorate([
+    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",
+        },
+    }),
+    model()
+], MergeFlowNode);
+export { MergeFlowNode };
+/**
+ * Map — transforms the current input into a new output object.
+ */
+let MapFlowNode = class MapFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to transform" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], MapFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Transformed output", placeholder: "Mapped result" }),
+    output({ handle: "result" }),
+    __metadata("design:type", Object)
+], MapFlowNode.prototype, "result", void 0);
+MapFlowNode = __decorate([
+    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: {},
+        },
+    }),
+    model()
+], MapFlowNode);
+export { MapFlowNode };
+/**
+ * Delay — pauses execution for a configured duration.
+ */
+let DelayFlowNode = class DelayFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to forward after delay" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], DelayFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Output value", placeholder: "Forwarded value" }),
+    output({ handle: "value" }),
+    __metadata("design:type", Object)
+], DelayFlowNode.prototype, "valueOut", void 0);
+DelayFlowNode = __decorate([
+    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,
+        },
+    }),
+    model()
+], DelayFlowNode);
+export { DelayFlowNode };
+/**
+ * Error boundary — try/catch/finally workflow behaviour.
+ */
+let ErrorBoundaryFlowNode = class ErrorBoundaryFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to guard" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Result", placeholder: "Output on success" }),
+    output({ handle: "result" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "result", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Error", placeholder: "Output on failure" }),
+    output({ handle: "error" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "error", void 0);
+ErrorBoundaryFlowNode = __decorate([
+    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,
+        },
+    }),
+    model()
+], ErrorBoundaryFlowNode);
+export { ErrorBoundaryFlowNode };
+/**
+ * Human approval — suspends execution until a human approves or rejects.
+ */
+let HumanApprovalFlowNode = class HumanApprovalFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value pending approval" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Approved", placeholder: "Output when approved" }),
+    output({ handle: "approved" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "approved", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Rejected", placeholder: "Output when rejected" }),
+    output({ handle: "rejected" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "rejected", void 0);
+HumanApprovalFlowNode = __decorate([
+    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,
+        },
+    }),
+    model()
+], HumanApprovalFlowNode);
+export { HumanApprovalFlowNode };
+/**
+ * Return — defines and normalises the final workflow output.
+ */
+let ReturnFlowNode = class ReturnFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to normalise" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], ReturnFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Returned output", placeholder: "Normalised output" }),
+    output({ handle: "result" }),
+    __metadata("design:type", Object)
+], ReturnFlowNode.prototype, "result", void 0);
+ReturnFlowNode = __decorate([
+    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: {},
+        },
+    }),
+    model()
+], ReturnFlowNode);
+export { 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 Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input", placeholder: "Input object (accessible as $input)" }),
+    input({ handle: "input" }),
+    __metadata("design:type", Object)
+], CodeFlowNode.prototype, "input", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Result", placeholder: "Code execution result" }),
+    output({ handle: "result" }),
+    __metadata("design:type", Object)
+], CodeFlowNode.prototype, "result", void 0);
+CodeFlowNode = __decorate([
+    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",
+        },
+    }),
+    model()
+], CodeFlowNode);
+export { CodeFlowNode };
+/**
+ * All built-in flow-control node constructors.
+ */
+export const 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/shared/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,EACL,iBAAiB,EACjB,KAAK,EACL,IAAI,EACJ,MAAM,EACN,aAAa,GAEd,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,kBAAe;AAEnC;;;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,SAAS;IAW3C;;;;OAIG;IACH,MAAM,CAAU,aAAa,CAAC,IAAwB;QACpD,MAAM,UAAU,GAAG,iBAAiB,CAAC,IAAa,CAAC,CAAC;QACpD,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,MAAM,CACvC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,QAAQ,CAAC,CAC5D,CAAC;QACF,MAAM,SAAS,GAA0B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC9D,QAAQ,EAAE,CAAC,CAAC,UAAU;YACtB,IAAI,EAAE,CAAC,CAAC,KAAK;YACb,SAAS,EAAE,aAAa,CAAC,MAAM;YAC/B,KAAK,EAAE,CAAC,CAAC,KAAK;YACd,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,CAAC,CAAC,UAAU;SACnB,CAAC,CAAC,CAAC;QACJ,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QACpC,OAAO;YACL,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,GAAG,SAAS,CAAC;YACnC,IAAI,EAAE;gBACJ,KAAK,EAAE,UAAU,CAAC,KAAK,IAAI,GAAG;gBAC9B,MAAM,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,IAAI,GAAG;aACxE;YACD,SAAS,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE;SACpC,CAAC;IACJ,CAAC;CACF,CAAA;AApCC;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,CAwC1B;;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 {\n  graphDefinitionOf,\n  input,\n  node,\n  output,\n  PortDirection,\n  type GraphPortDefinition,\n} from \"@decaf-ts/ui-decorators/graph\";\nimport type { NodeMetadataChange, SwitchNodeMetadata } from \"../types\";\nimport { GraphNode } from \"./base\";\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 GraphNode {\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   * Computes the node's ports, size, and data patch from the given switch\n   * metadata. Each case gets its own output port on the right side; the\n   * node grows in height as cases are added.\n   */\n  static override applyMetadata(meta: SwitchNodeMetadata): NodeMetadataChange {\n    const definition = graphDefinitionOf(this as never);\n    const basePorts = definition.ports.filter(\n      (p) => !meta.cases.some((c) => c.outputPort === p.property)\n    );\n    const casePorts: GraphPortDefinition[] = meta.cases.map((c) => ({\n      property: c.outputPort,\n      name: c.label,\n      direction: PortDirection.OUTPUT,\n      label: c.label,\n      required: false,\n      hidden: false,\n      path: c.outputPort,\n    }));\n    const caseCount = meta.cases.length;\n    return {\n      ports: [...basePorts, ...casePorts],\n      size: {\n        width: definition.width ?? 120,\n        height: caseCount > 0 ? 140 + caseCount * 24 : definition.height ?? 140,\n      },\n      dataPatch: { switchMetadata: meta },\n    };\n  }\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"]}

package/lib/esm/graph/shared/nodes/index.js

@@ -0,0 +1,18 @@
+/**
+ * @module integrations/graph/nodes
+ * @summary Production node kind declarations (DECAF-32 §22.2).
+ * @description Canonical `@node`-decorated classes for the ALFRED-5 node kind
+ * taxonomy. These are the framework's built-in node definitions — triggers
+ * (§22.2.1), flow-control/utility nodes (§22.2.2–22.2.3), and the Agent node
+ * (§21.3). The three loop kinds (`core.loop.foreach/while/until`) already have
+ * built-in executors (§5.9) and are not redeclared here.
+ *
+ * Consumers (for-angular, ALFRED, etc.) import these declarations to populate
+ * node palettes, registries, and reference snapshots.
+ */
+export * from "./base.js";
+export * from "./category-styles.js";
+export * from "./triggers.js";
+export * from "./flow-control.js";
+export * from "./agent.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvc2hhcmVkL25vZGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsMEJBQXVCO0FBQ3ZCLHFDQUFrQztBQUNsQyw4QkFBMkI7QUFDM0Isa0NBQStCO0FBQy9CLDJCQUF3QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvZ3JhcGgvbm9kZXNcbiAqIEBzdW1tYXJ5IFByb2R1Y3Rpb24gbm9kZSBraW5kIGRlY2xhcmF0aW9ucyAoREVDQUYtMzIgwqcyMi4yKS5cbiAqIEBkZXNjcmlwdGlvbiBDYW5vbmljYWwgYEBub2RlYC1kZWNvcmF0ZWQgY2xhc3NlcyBmb3IgdGhlIEFMRlJFRC01IG5vZGUga2luZFxuICogdGF4b25vbXkuIFRoZXNlIGFyZSB0aGUgZnJhbWV3b3JrJ3MgYnVpbHQtaW4gbm9kZSBkZWZpbml0aW9ucyDigJQgdHJpZ2dlcnNcbiAqICjCpzIyLjIuMSksIGZsb3ctY29udHJvbC91dGlsaXR5IG5vZGVzICjCpzIyLjIuMuKAkzIyLjIuMyksIGFuZCB0aGUgQWdlbnQgbm9kZVxuICogKMKnMjEuMykuIFRoZSB0aHJlZSBsb29wIGtpbmRzIChgY29yZS5sb29wLmZvcmVhY2gvd2hpbGUvdW50aWxgKSBhbHJlYWR5IGhhdmVcbiAqIGJ1aWx0LWluIGV4ZWN1dG9ycyAowqc1LjkpIGFuZCBhcmUgbm90IHJlZGVjbGFyZWQgaGVyZS5cbiAqXG4gKiBDb25zdW1lcnMgKGZvci1hbmd1bGFyLCBBTEZSRUQsIGV0Yy4pIGltcG9ydCB0aGVzZSBkZWNsYXJhdGlvbnMgdG8gcG9wdWxhdGVcbiAqIG5vZGUgcGFsZXR0ZXMsIHJlZ2lzdHJpZXMsIGFuZCByZWZlcmVuY2Ugc25hcHNob3RzLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jYXRlZ29yeS1zdHlsZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RyaWdnZXJzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9mbG93LWNvbnRyb2xcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2FnZW50XCI7XG4iXX0=