@decaf-ts/ui-decorators 0.20.4 → 0.20.7

package/lib/cjs/graph/nodes/agents/agent.cjs

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPH_AGENT_NODES = exports.AgentNode = 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 ui-decorators/graph/nodes/agents/agent
+ * @summary Production Agent node declaration.
+ * @description The Agent node is the primary AI agent entrypoint. It is a
+ * rectangular node with `@connection()` ports for its structural
+ * dependencies: `model` (the LLM), `memory` (the memory store), and
+ * `workspace` (the workspace/context). Connections are rendered on the
+ * bottom side of the node (DECAF-32 §21.3). Each connection category has a
+ * distinct color defined in the category style registry.
+ *
+ * The single `prompt` input accepts placeholder expressions (§22.4) such as
+ * `{{ $input.brief }}` or `{{ $node["Research"].output.summary }}` that are
+ * resolved at execution time by the placeholder compiler.
+ */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const decorators_js_1 = require("./../../../ui/decorators.cjs");
+const decorators_js_2 = require("./../../decorators.cjs");
+// Ensure category styles are registered (idempotent).
+require("./../category-styles.cjs");
+/**
+ * Agent node — an AI agent that orchestrates a model, memory, and workspace.
+ *
+ * The agent has:
+ * - `@input` port on the **left**: `prompt` (the task prompt; supports
+ *   placeholder expressions like `{{ $input.something }}` per §22.4).
+ * - `@output` ports on the **right**: `response` (the agent's output), `actions`
+ *   (any actions the agent decided to take).
+ * - `@connection` ports on the **bottom**: `model` (LLM), `memory` (memory
+ *   store), `workspace` (workspace/context). Each connection has a distinct
+ *   category color.
+ *
+ * The node is rectangular (not rounded) to visually distinguish it from
+ * regular processing nodes. The `color` and `icon` are omitted from `@node()`
+ * so they are resolved from the `"Agent"` category style.
+ */
+let AgentNode = class AgentNode extends decorator_validation_1.Model {
+};
+exports.AgentNode = AgentNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", {
+        label: "Prompt",
+        placeholder: "Enter task prompt. Supports placeholders like {{ $input.brief }} or {{ $node[\"Research\"].output.summary }}",
+    }),
+    (0, decorators_js_2.input)({ handle: "prompt" }),
+    __metadata("design:type", String)
+], AgentNode.prototype, "prompt", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Response", placeholder: "Agent response" }),
+    (0, decorators_js_2.output)({ handle: "response" }),
+    __metadata("design:type", String)
+], AgentNode.prototype, "response", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Actions", placeholder: "Actions taken by the agent" }),
+    (0, decorators_js_2.output)({ handle: "actions" }),
+    __metadata("design:type", Array)
+], AgentNode.prototype, "actions", void 0);
+__decorate([
+    (0, decorators_js_2.connection)({ category: "model", handle: "model" }),
+    __metadata("design:type", Object)
+], AgentNode.prototype, "model", void 0);
+__decorate([
+    (0, decorators_js_2.connection)({ category: "memory", handle: "memory" }),
+    __metadata("design:type", Object)
+], AgentNode.prototype, "memory", void 0);
+__decorate([
+    (0, decorators_js_2.connection)({ category: "workspace", handle: "workspace" }),
+    __metadata("design:type", Object)
+], AgentNode.prototype, "workspace", void 0);
+exports.AgentNode = AgentNode = __decorate([
+    (0, decorators_js_2.node)("core.agent", {
+        kind: "core.agent",
+        category: "Agent",
+        // color and icon omitted — resolved from the "Agent" category style
+        width: 120,
+        height: 140,
+        labels: ["agent", "ai", "orchestrator"],
+        metadata: {
+            title: "Agent",
+            description: "AI agent that orchestrates a model, memory, and workspace to complete a task.",
+            shape: "rectangle",
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], AgentNode);
+/**
+ * All built-in agent node constructors.
+ */
+exports.GRAPH_AGENT_NODES = [AgentNode];
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent.js","sourceRoot":"","sources":["agent.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 ui-decorators/graph/nodes/agents/agent\n * @summary Production Agent node declaration.\n * @description The Agent node is the primary AI agent entrypoint. It is a\n * rectangular node with `@connection()` ports for its structural\n * dependencies: `model` (the LLM), `memory` (the memory store), and\n * `workspace` (the workspace/context). Connections are rendered on the\n * bottom side of the node (DECAF-32 §21.3). Each connection category has a\n * distinct color defined in the category style registry.\n *\n * The single `prompt` input accepts placeholder expressions (§22.4) such as\n * `{{ $input.brief }}` or `{{ $node[\"Research\"].output.summary }}` that are\n * resolved at execution time by the placeholder compiler.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"./../../../ui/decorators.js\";\nimport { connection, input, node, output } from \"./../../decorators.js\";\n// Ensure category styles are registered (idempotent).\nimport \"./../category-styles.js\";\n/**\n * Agent node — an AI agent that orchestrates a model, memory, and workspace.\n *\n * The agent has:\n * - `@input` port on the **left**: `prompt` (the task prompt; supports\n *   placeholder expressions like `{{ $input.something }}` per §22.4).\n * - `@output` ports on the **right**: `response` (the agent's output), `actions`\n *   (any actions the agent decided to take).\n * - `@connection` ports on the **bottom**: `model` (LLM), `memory` (memory\n *   store), `workspace` (workspace/context). Each connection has a distinct\n *   category color.\n *\n * The node is rectangular (not rounded) to visually distinguish it from\n * regular processing nodes. The `color` and `icon` are omitted from `@node()`\n * so they are resolved from the `\"Agent\"` category style.\n */\nlet AgentNode = class AgentNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", {\n        label: \"Prompt\",\n        placeholder: \"Enter task prompt. Supports placeholders like {{ $input.brief }} or {{ $node[\\\"Research\\\"].output.summary }}\",\n    }),\n    input({ handle: \"prompt\" }),\n    __metadata(\"design:type\", String)\n], AgentNode.prototype, \"prompt\", void 0);\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Response\", placeholder: \"Agent response\" }),\n    output({ handle: \"response\" }),\n    __metadata(\"design:type\", String)\n], AgentNode.prototype, \"response\", void 0);\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Actions\", placeholder: \"Actions taken by the agent\" }),\n    output({ handle: \"actions\" }),\n    __metadata(\"design:type\", Array)\n], AgentNode.prototype, \"actions\", void 0);\n__decorate([\n    connection({ category: \"model\", handle: \"model\" }),\n    __metadata(\"design:type\", Object)\n], AgentNode.prototype, \"model\", void 0);\n__decorate([\n    connection({ category: \"memory\", handle: \"memory\" }),\n    __metadata(\"design:type\", Object)\n], AgentNode.prototype, \"memory\", void 0);\n__decorate([\n    connection({ category: \"workspace\", handle: \"workspace\" }),\n    __metadata(\"design:type\", Object)\n], AgentNode.prototype, \"workspace\", void 0);\nAgentNode = __decorate([\n    node(\"core.agent\", {\n        kind: \"core.agent\",\n        category: \"Agent\",\n        // color and icon omitted — resolved from the \"Agent\" category style\n        width: 120,\n        height: 140,\n        labels: [\"agent\", \"ai\", \"orchestrator\"],\n        metadata: {\n            title: \"Agent\",\n            description: \"AI agent that orchestrates a model, memory, and workspace to complete a task.\",\n            shape: \"rectangle\",\n        },\n    }),\n    model()\n], AgentNode);\nexport { AgentNode };\n/**\n * All built-in agent node constructors.\n */\nexport const GRAPH_AGENT_NODES = [AgentNode];\n//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/nodes/base.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphNode = void 0;
+/**
+ * @module ui-decorators/graph/nodes/base
+ * @summary Base class for shared graph node declarations.
+ * @description `GraphNode` extends `Model` with an overridable
+ * `applyMetadata` static method. Concrete node kinds that support dynamic
+ * metadata changes (e.g. `SwitchFlowNode` adding case output ports) override
+ * this method to compute their own ports, size, and data patches — the node
+ * is exclusively responsible for itself in every way.
+ */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+class GraphNode extends decorator_validation_1.Model {
+    /**
+     * Applies a metadata patch to this node class, returning the resulting
+     * ports, size, and data patches.
+     *
+     * The default implementation returns `null` (no changes). Concrete node
+     * kinds that support dynamic metadata override this to compute their own
+     * ports and size from the metadata — the caller (renderer) simply relays
+     * the result to the diagram model.
+     *
+     * @param _meta - The metadata patch (node-kind-specific, e.g.
+     *   `SwitchNodeMetadata`).
+     * @returns The computed change, or `null` when the node kind does not
+     *   support dynamic metadata.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static applyMetadata(_meta) {
+        return null;
+    }
+}
+exports.GraphNode = GraphNode;
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cjs/graph/nodes/boundary/input-value.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphInputValueNode = 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 ui-decorators/graph/nodes/boundary/input-value
+ * @summary Workflow input value boundary node declaration.
+ * @description Shared canvas node representing a workflow input value
+ * (decorator id `graph-input-value-node`), moved from the for-angular
+ * boundary nodes so both sides share the declaration. Reusable value node
+ * whose single `value` output may feed multiple targets.
+ */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const decorators_js_1 = require("./../../decorators.cjs");
+// Ensure category styles are registered (idempotent).
+require("./../category-styles.cjs");
+let GraphInputValueNode = class GraphInputValueNode extends decorator_validation_1.Model {
+};
+exports.GraphInputValueNode = GraphInputValueNode;
+__decorate([
+    (0, decorators_js_1.output)({
+        handle: 'value',
+        connectionRules: {
+            allowMultiple: true,
+        },
+    }),
+    __metadata("design:type", Object)
+], GraphInputValueNode.prototype, "value", void 0);
+exports.GraphInputValueNode = GraphInputValueNode = __decorate([
+    (0, decorators_js_1.node)('graph-input-value-node', {
+        kind: 'value',
+        category: 'Boundary',
+        color: '#0f766e',
+        icon: 'ti-circle-plus',
+        labels: ['workflow', 'input', 'value'],
+        metadata: {
+            title: 'Workflow input value',
+            description: 'Reusable canvas value node representing a workflow input.',
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], GraphInputValueNode);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtdmFsdWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvbm9kZXMvYm91bmRhcnkvaW5wdXQtdmFsdWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUE7Ozs7Ozs7R0FPRztBQUNILE9BQU8sRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDOUQsT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsOEJBQXlCO0FBRWhELHNEQUFzRDtBQUN0RCxpQ0FBNEI7QUFjckIsSUFBTSxtQkFBbUIsR0FBekIsTUFBTSxtQkFBb0IsU0FBUSxLQUFLO0NBUTdDLENBQUE7QUFEQztJQU5DLE1BQU0sQ0FBQztRQUNOLE1BQU0sRUFBRSxPQUFPO1FBQ2YsZUFBZSxFQUFFO1lBQ2YsYUFBYSxFQUFFLElBQUk7U0FDcEI7S0FDRixDQUFDOztrREFDYztBQVBMLG1CQUFtQjtJQVovQixJQUFJLENBQUMsd0JBQXdCLEVBQUU7UUFDOUIsSUFBSSxFQUFFLE9BQU87UUFDYixRQUFRLEVBQUUsVUFBVTtRQUNwQixLQUFLLEVBQUUsU0FBUztRQUNoQixJQUFJLEVBQUUsZ0JBQWdCO1FBQ3RCLE1BQU0sRUFBRSxDQUFDLFVBQVUsRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDO1FBQ3RDLFFBQVEsRUFBRTtZQUNSLEtBQUssRUFBRSxzQkFBc0I7WUFDN0IsV0FBVyxFQUFFLDJEQUEyRDtTQUN6RTtLQUNGLENBQUM7SUFDRCxLQUFLLEVBQUU7R0FDSyxtQkFBbUIsQ0FRL0IiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgdWktZGVjb3JhdG9ycy9ncmFwaC9ub2Rlcy9ib3VuZGFyeS9pbnB1dC12YWx1ZVxuICogQHN1bW1hcnkgV29ya2Zsb3cgaW5wdXQgdmFsdWUgYm91bmRhcnkgbm9kZSBkZWNsYXJhdGlvbi5cbiAqIEBkZXNjcmlwdGlvbiBTaGFyZWQgY2FudmFzIG5vZGUgcmVwcmVzZW50aW5nIGEgd29ya2Zsb3cgaW5wdXQgdmFsdWVcbiAqIChkZWNvcmF0b3IgaWQgYGdyYXBoLWlucHV0LXZhbHVlLW5vZGVgKSwgbW92ZWQgZnJvbSB0aGUgZm9yLWFuZ3VsYXJcbiAqIGJvdW5kYXJ5IG5vZGVzIHNvIGJvdGggc2lkZXMgc2hhcmUgdGhlIGRlY2xhcmF0aW9uLiBSZXVzYWJsZSB2YWx1ZSBub2RlXG4gKiB3aG9zZSBzaW5nbGUgYHZhbHVlYCBvdXRwdXQgbWF5IGZlZWQgbXVsdGlwbGUgdGFyZ2V0cy5cbiAqL1xuaW1wb3J0IHsgTW9kZWwsIG1vZGVsIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuaW1wb3J0IHsgb3V0cHV0LCBub2RlIH0gZnJvbSBcIi4uLy4uL2RlY29yYXRvcnNcIjtcblxuLy8gRW5zdXJlIGNhdGVnb3J5IHN0eWxlcyBhcmUgcmVnaXN0ZXJlZCAoaWRlbXBvdGVudCkuXG5pbXBvcnQgXCIuLi9jYXRlZ29yeS1zdHlsZXNcIjtcblxuQG5vZGUoJ2dyYXBoLWlucHV0LXZhbHVlLW5vZGUnLCB7XG4gIGtpbmQ6ICd2YWx1ZScsXG4gIGNhdGVnb3J5OiAnQm91bmRhcnknLFxuICBjb2xvcjogJyMwZjc2NmUnLFxuICBpY29uOiAndGktY2lyY2xlLXBsdXMnLFxuICBsYWJlbHM6IFsnd29ya2Zsb3cnLCAnaW5wdXQnLCAndmFsdWUnXSxcbiAgbWV0YWRhdGE6IHtcbiAgICB0aXRsZTogJ1dvcmtmbG93IGlucHV0IHZhbHVlJyxcbiAgICBkZXNjcmlwdGlvbjogJ1JldXNhYmxlIGNhbnZhcyB2YWx1ZSBub2RlIHJlcHJlc2VudGluZyBhIHdvcmtmbG93IGlucHV0LicsXG4gIH0sXG59KVxuQG1vZGVsKClcbmV4cG9ydCBjbGFzcyBHcmFwaElucHV0VmFsdWVOb2RlIGV4dGVuZHMgTW9kZWwge1xuICBAb3V0cHV0KHtcbiAgICBoYW5kbGU6ICd2YWx1ZScsXG4gICAgY29ubmVjdGlvblJ1bGVzOiB7XG4gICAgICBhbGxvd011bHRpcGxlOiB0cnVlLFxuICAgIH0sXG4gIH0pXG4gIHZhbHVlITogdW5rbm93bjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-value.js","sourceRoot":"","sources":["input-value.js"],"names":[],"mappings":";;;AAAA,IAAI,UAAU,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,UAAU,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI;IACjF,IAAI,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7H,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU;QAAE,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;;QAC1H,KAAK,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;YAAE,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;gBAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;IAClJ,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AAClE,CAAC,CAAC;AACF,IAAI,UAAU,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,EAAE,CAAC;IACxD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU;QAAE,OAAO,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC7G,CAAC,CAAC;AACF;;;;;;;GAOG;AACH,yEAA8D;AAC9D,yDAAqD;AACrD,sDAAsD;AACtD,mCAAiC;AACjC,IAAI,mBAAmB,GAAG,MAAM,mBAAoB,SAAQ,4BAAK;CAChE,CAAC;AAwBO,kDAAmB;AAvB5B,UAAU,CAAC;IACP,IAAA,sBAAM,EAAC;QACH,MAAM,EAAE,OAAO;QACf,eAAe,EAAE;YACb,aAAa,EAAE,IAAI;SACtB;KACJ,CAAC;IACF,UAAU,CAAC,aAAa,EAAE,MAAM,CAAC;CACpC,EAAE,mBAAmB,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;AACnD,8BAAA,mBAAmB,GAAG,UAAU,CAAC;IAC7B,IAAA,oBAAI,EAAC,wBAAwB,EAAE;QAC3B,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,UAAU;QACpB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,gBAAgB;QACtB,MAAM,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC;QACtC,QAAQ,EAAE;YACN,KAAK,EAAE,sBAAsB;YAC7B,WAAW,EAAE,2DAA2D;SAC3E;KACJ,CAAC;IACF,IAAA,4BAAK,GAAE;CACV,EAAE,mBAAmB,CAAC,CAAC;AAExB,8+EAA8+E","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 ui-decorators/graph/nodes/boundary/input-value\n * @summary Workflow input value boundary node declaration.\n * @description Shared canvas node representing a workflow input value\n * (decorator id `graph-input-value-node`), moved from the for-angular\n * boundary nodes so both sides share the declaration. Reusable value node\n * whose single `value` output may feed multiple targets.\n */\nimport { Model, model } from \"@decaf-ts/decorator-validation\";\nimport { output, node } from \"./../../decorators.js\";\n// Ensure category styles are registered (idempotent).\nimport \"./../category-styles.js\";\nlet GraphInputValueNode = class GraphInputValueNode extends Model {\n};\n__decorate([\n    output({\n        handle: 'value',\n        connectionRules: {\n            allowMultiple: true,\n        },\n    }),\n    __metadata(\"design:type\", Object)\n], GraphInputValueNode.prototype, \"value\", void 0);\nGraphInputValueNode = __decorate([\n    node('graph-input-value-node', {\n        kind: 'value',\n        category: 'Boundary',\n        color: '#0f766e',\n        icon: 'ti-circle-plus',\n        labels: ['workflow', 'input', 'value'],\n        metadata: {\n            title: 'Workflow input value',\n            description: 'Reusable canvas value node representing a workflow input.',\n        },\n    }),\n    model()\n], GraphInputValueNode);\nexport { GraphInputValueNode };\n//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/nodes/category-styles.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBuiltinCategoryStyles = registerBuiltinCategoryStyles;
+/**
+ * @module ui-decorators/graph/nodes/category-styles
+ * @summary Built-in node/connection category style registrations.
+ * @description Registers default colors and icons for the built-in node and
+ * connection categories (DECAF-32 §21.2). The `color` / `icon` on a node's
+ * `@node()` metadata are optional overrides — when omitted, the effective
+ * style is resolved from the category registry.
+ */
+const constants_js_1 = require("./../constants.cjs");
+/**
+ * Registers all built-in category styles. Called once at module init.
+ *
+ * Categories define the default visual style for nodes and connection ports.
+ * A node's explicit `color` / `icon` (on `@node()`) overrides the category
+ * style; when omitted, the category style is used.
+ */
+function registerBuiltinCategoryStyles() {
+    // Node categories
+    (0, constants_js_1.registerGraphCategoryStyle)("Trigger", { color: "#3b82f6", icon: "ti-bolt" });
+    (0, constants_js_1.registerGraphCategoryStyle)("Flow Control", { color: "#f59e0b", icon: "ti-arrows-split-2" });
+    (0, constants_js_1.registerGraphCategoryStyle)("Utility", { color: "#0d9488", icon: "ti-tool" });
+    (0, constants_js_1.registerGraphCategoryStyle)("Loop", { color: "#eab308", icon: "ti-repeat" });
+    (0, constants_js_1.registerGraphCategoryStyle)("Workflow", { color: "#f97316", icon: "ti-sitemap" });
+    (0, constants_js_1.registerGraphCategoryStyle)("Pipeline", { color: "#0ea5e9", icon: "ti-git-merge" });
+    (0, constants_js_1.registerGraphCategoryStyle)("Node", { color: "#8b5cf6", icon: "ti-point-filled" });
+    (0, constants_js_1.registerGraphCategoryStyle)("Agent", { color: "#7c3aed", icon: "ti-robot" });
+    // Connection categories (for @connection() ports)
+    (0, constants_js_1.registerGraphCategoryStyle)("model", { color: "#3b82f6", icon: "ti-cpu" });
+    (0, constants_js_1.registerGraphCategoryStyle)("memory", { color: "#10b981", icon: "ti-database" });
+    (0, constants_js_1.registerGraphCategoryStyle)("workspace", { color: "#f59e0b", icon: "ti-folder" });
+}
+// Register at module load so the styles are available immediately.
+registerBuiltinCategoryStyles();
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-styles.js","sourceRoot":"","sources":["category-styles.js"],"names":[],"mappings":";;AAgBA,sEAcC;AA9BD;;;;;;;GAOG;AACH,oDAA+D;AAC/D;;;;;;GAMG;AACH,SAAgB,6BAA6B;IACzC,kBAAkB;IAClB,IAAA,yCAA0B,EAAC,SAAS,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IAC7E,IAAA,yCAA0B,EAAC,cAAc,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,CAAC;IAC5F,IAAA,yCAA0B,EAAC,SAAS,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IAC7E,IAAA,yCAA0B,EAAC,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IAC5E,IAAA,yCAA0B,EAAC,UAAU,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;IACjF,IAAA,yCAA0B,EAAC,UAAU,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;IACnF,IAAA,yCAA0B,EAAC,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAClF,IAAA,yCAA0B,EAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;IAC5E,kDAAkD;IAClD,IAAA,yCAA0B,EAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1E,IAAA,yCAA0B,EAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;IAChF,IAAA,yCAA0B,EAAC,WAAW,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;AACrF,CAAC;AACD,mEAAmE;AACnE,6BAA6B,EAAE,CAAC;AAChC,8xIAA8xI","sourcesContent":["/**\n * @module ui-decorators/graph/nodes/category-styles\n * @summary Built-in node/connection category style registrations.\n * @description Registers default colors and icons for the built-in node and\n * connection categories (DECAF-32 §21.2). The `color` / `icon` on a node's\n * `@node()` metadata are optional overrides — when omitted, the effective\n * style is resolved from the category registry.\n */\nimport { registerGraphCategoryStyle } from \"./../constants.js\";\n/**\n * Registers all built-in category styles. Called once at module init.\n *\n * Categories define the default visual style for nodes and connection ports.\n * A node's explicit `color` / `icon` (on `@node()`) overrides the category\n * style; when omitted, the category style is used.\n */\nexport function registerBuiltinCategoryStyles() {\n    // Node categories\n    registerGraphCategoryStyle(\"Trigger\", { color: \"#3b82f6\", icon: \"ti-bolt\" });\n    registerGraphCategoryStyle(\"Flow Control\", { color: \"#f59e0b\", icon: \"ti-arrows-split-2\" });\n    registerGraphCategoryStyle(\"Utility\", { color: \"#0d9488\", icon: \"ti-tool\" });\n    registerGraphCategoryStyle(\"Loop\", { color: \"#eab308\", icon: \"ti-repeat\" });\n    registerGraphCategoryStyle(\"Workflow\", { color: \"#f97316\", icon: \"ti-sitemap\" });\n    registerGraphCategoryStyle(\"Pipeline\", { color: \"#0ea5e9\", icon: \"ti-git-merge\" });\n    registerGraphCategoryStyle(\"Node\", { color: \"#8b5cf6\", icon: \"ti-point-filled\" });\n    registerGraphCategoryStyle(\"Agent\", { color: \"#7c3aed\", icon: \"ti-robot\" });\n    // Connection categories (for @connection() ports)\n    registerGraphCategoryStyle(\"model\", { color: \"#3b82f6\", icon: \"ti-cpu\" });\n    registerGraphCategoryStyle(\"memory\", { color: \"#10b981\", icon: \"ti-database\" });\n    registerGraphCategoryStyle(\"workspace\", { color: \"#f59e0b\", icon: \"ti-folder\" });\n}\n// Register at module load so the styles are available immediately.\nregisterBuiltinCategoryStyles();\n//# sourceMappingURL=data:application/json;base64,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"]}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreakFlowNode = 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 ui-decorators/graph/nodes/flow-control/break
+ * @summary Break flow-control node declaration (DECAF-32 §22.2.2).
+ * @description Break — breaks out of the enclosing loop (foreach/while/until).
+ * When executed inside a loop body, the loop terminates early and the loop's
+ * `completed`/`state` output carries the results collected so far. The Break
+ * node executor throws a `GraphBreakSignal` that the enclosing loop executor
+ * catches.
+ */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const decorators_js_1 = require("./../../../ui/decorators.cjs");
+const decorators_js_2 = require("./../../decorators.cjs");
+// Ensure category styles are registered (idempotent).
+require("./../category-styles.cjs");
+let BreakFlowNode = class BreakFlowNode extends decorator_validation_1.Model {
+};
+exports.BreakFlowNode = BreakFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Value", placeholder: "Value to forward (collected as the last partial result)" }),
+    (0, decorators_js_2.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], BreakFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_2.output)({ handle: "broken" }),
+    __metadata("design:type", Object)
+], BreakFlowNode.prototype, "broken", void 0);
+exports.BreakFlowNode = BreakFlowNode = __decorate([
+    (0, decorators_js_2.node)("core.flow.break", {
+        kind: "core.flow.break",
+        category: "Flow Control",
+        color: "#ef4444",
+        icon: "ti-square-arrow-right",
+        width: 96,
+        height: 96,
+        labels: ["flow", "break", "loop", "control"],
+        metadata: {
+            title: "Break",
+            description: "Breaks out of the enclosing loop. The loop terminates early and returns the results collected so far.",
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], BreakFlowNode);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"break.js","sourceRoot":"","sources":["break.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 ui-decorators/graph/nodes/flow-control/break\n * @summary Break flow-control node declaration (DECAF-32 §22.2.2).\n * @description Break — breaks out of the enclosing loop (foreach/while/until).\n * When executed inside a loop body, the loop terminates early and the loop's\n * `completed`/`state` output carries the results collected so far. The Break\n * node executor throws a `GraphBreakSignal` that the enclosing loop executor\n * catches.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"./../../../ui/decorators.js\";\nimport { input, node, output } from \"./../../decorators.js\";\n// Ensure category styles are registered (idempotent).\nimport \"./../category-styles.js\";\nlet BreakFlowNode = class BreakFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Value\", placeholder: \"Value to forward (collected as the last partial result)\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], BreakFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    output({ handle: \"broken\" }),\n    __metadata(\"design:type\", Object)\n], BreakFlowNode.prototype, \"broken\", void 0);\nBreakFlowNode = __decorate([\n    node(\"core.flow.break\", {\n        kind: \"core.flow.break\",\n        category: \"Flow Control\",\n        color: \"#ef4444\",\n        icon: \"ti-square-arrow-right\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"break\", \"loop\", \"control\"],\n        metadata: {\n            title: \"Break\",\n            description: \"Breaks out of the enclosing loop. The loop terminates early and returns the results collected so far.\",\n        },\n    }),\n    model()\n], BreakFlowNode);\nexport { BreakFlowNode };\n//# sourceMappingURL=data:application/json;base64,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"]}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorBoundaryFlowNode = 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 ui-decorators/graph/nodes/flow-control/error-boundary
+ * @summary Error-boundary flow-control node declaration (DECAF-32 §22.2.2).
+ * @description Error boundary — try/catch/finally workflow behaviour.
+ */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const decorators_js_1 = require("./../../../ui/decorators.cjs");
+const decorators_js_2 = require("./../../decorators.cjs");
+// Ensure category styles are registered (idempotent).
+require("./../category-styles.cjs");
+let ErrorBoundaryFlowNode = class ErrorBoundaryFlowNode extends decorator_validation_1.Model {
+};
+exports.ErrorBoundaryFlowNode = ErrorBoundaryFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Input value", placeholder: "Value to guard" }),
+    (0, decorators_js_2.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("input", { label: "Result", placeholder: "Output on success" }),
+    (0, decorators_js_2.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "result", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("input", { label: "Error", placeholder: "Output on failure" }),
+    (0, decorators_js_2.output)({ handle: "error" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "error", void 0);
+exports.ErrorBoundaryFlowNode = ErrorBoundaryFlowNode = __decorate([
+    (0, decorators_js_2.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);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-boundary.js","sourceRoot":"","sources":["error-boundary.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 ui-decorators/graph/nodes/flow-control/error-boundary\n * @summary Error-boundary flow-control node declaration (DECAF-32 §22.2.2).\n * @description Error boundary — try/catch/finally workflow behaviour.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"./../../../ui/decorators.js\";\nimport { input, node, output } from \"./../../decorators.js\";\n// Ensure category styles are registered (idempotent).\nimport \"./../category-styles.js\";\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//# sourceMappingURL=data:application/json;base64,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"]}