@decaf-ts/ui-decorators 0.20.4 → 0.20.7

package/lib/cjs/graph/nodes/utility/code.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeFlowNode = exports.CodeInputSchema = 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/utility/code
+ * @summary Code utility node declaration (ALFRED-5 §7, DECAF-32 §22.4).
+ * @description Code — sandboxed JS/TS code execution. The engine's
+ * `CodeGraphNodeExecutor` delegates to the pluggable `CodeSandboxEvaluator`.
+ * The default `IsolatedVmCodeSandboxEvaluator` (backed by `isolated-vm`)
+ * enforces the Code Node restrictions: no imports, no requires, pure
+ * functions only. The sandbox context exposes `$input`, `$vars`, `$item`,
+ * `$index`, `$node`, and `$output` as data variables. TypeScript is
+ * supported via transpilation.
+ *
+ * The `@input` on `CodeFlowNode.input` is a schema group — the nested
+ * model's `@input` ports are spliced into the parent unprefixed. `code` has
+ * `@input` + `@uielement("code-editor")`, so it appears as a port AND in the
+ * CRUD modal (the only visible field). `data` has `@input` + `@hidden()` but
+ * no `@uielement`, so it is a canvas-only port (for edge connections from
+ * workflow input badges) but never appears in the CRUD modal. `language` has
+ * no `@input` and no `@uielement`, so it is neither a port nor rendered — it
+ * defaults to `"javascript"`.
+ */
+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 CodeInputSchema = class CodeInputSchema extends decorator_validation_1.Model {
+    constructor() {
+        super(...arguments);
+        this.language = "javascript";
+    }
+};
+exports.CodeInputSchema = CodeInputSchema;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    __metadata("design:type", String)
+], CodeInputSchema.prototype, "language", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("code-editor", { label: "Code", placeholder: "// User-authored JS code" }),
+    (0, decorators_js_2.input)({ handle: "code" }),
+    __metadata("design:type", String)
+], CodeInputSchema.prototype, "code", void 0);
+__decorate([
+    (0, decorators_js_1.hidden)(),
+    (0, decorators_js_2.input)({ handle: "data" }),
+    __metadata("design:type", Object)
+], CodeInputSchema.prototype, "data", void 0);
+exports.CodeInputSchema = CodeInputSchema = __decorate([
+    (0, decorator_validation_1.model)()
+], CodeInputSchema);
+let CodeFlowNode = class CodeFlowNode extends decorator_validation_1.Model {
+};
+exports.CodeFlowNode = CodeFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_2.input)({ handle: "input", model: CodeInputSchema }),
+    __metadata("design:type", CodeInputSchema)
+], CodeFlowNode.prototype, "input", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_2.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], CodeFlowNode.prototype, "result", void 0);
+exports.CodeFlowNode = CodeFlowNode = __decorate([
+    (0, decorators_js_2.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.",
+            timeoutMs: 1000,
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], CodeFlowNode);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code.js","sourceRoot":"","sources":["code.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/utility/code\n * @summary Code utility node declaration (ALFRED-5 §7, DECAF-32 §22.4).\n * @description Code — sandboxed JS/TS code execution. The engine's\n * `CodeGraphNodeExecutor` delegates to the pluggable `CodeSandboxEvaluator`.\n * The default `IsolatedVmCodeSandboxEvaluator` (backed by `isolated-vm`)\n * enforces the Code Node restrictions: no imports, no requires, pure\n * functions only. The sandbox context exposes `$input`, `$vars`, `$item`,\n * `$index`, `$node`, and `$output` as data variables. TypeScript is\n * supported via transpilation.\n *\n * The `@input` on `CodeFlowNode.input` is a schema group — the nested\n * model's `@input` ports are spliced into the parent unprefixed. `code` has\n * `@input` + `@uielement(\"code-editor\")`, so it appears as a port AND in the\n * CRUD modal (the only visible field). `data` has `@input` + `@hidden()` but\n * no `@uielement`, so it is a canvas-only port (for edge connections from\n * workflow input badges) but never appears in the CRUD modal. `language` has\n * no `@input` and no `@uielement`, so it is neither a port nor rendered — it\n * defaults to `\"javascript\"`.\n */\nimport { Model, model, required } from \"@decaf-ts/decorator-validation\";\nimport { hidden, uielement } from \"./../../../ui/decorators.js\";\nimport { input, node, output } from \"./../../decorators.js\";\n// Ensure category styles are registered (idempotent).\nimport \"./../category-styles.js\";\nlet CodeInputSchema = class CodeInputSchema extends Model {\n    constructor() {\n        super(...arguments);\n        this.language = \"javascript\";\n    }\n};\n__decorate([\n    required(),\n    __metadata(\"design:type\", String)\n], CodeInputSchema.prototype, \"language\", void 0);\n__decorate([\n    required(),\n    uielement(\"code-editor\", { label: \"Code\", placeholder: \"// User-authored JS code\" }),\n    input({ handle: \"code\" }),\n    __metadata(\"design:type\", String)\n], CodeInputSchema.prototype, \"code\", void 0);\n__decorate([\n    hidden(),\n    input({ handle: \"data\" }),\n    __metadata(\"design:type\", Object)\n], CodeInputSchema.prototype, \"data\", void 0);\nCodeInputSchema = __decorate([\n    model()\n], CodeInputSchema);\nexport { CodeInputSchema };\nlet CodeFlowNode = class CodeFlowNode extends Model {\n};\n__decorate([\n    required(),\n    input({ handle: \"input\", model: CodeInputSchema }),\n    __metadata(\"design:type\", CodeInputSchema)\n], CodeFlowNode.prototype, \"input\", void 0);\n__decorate([\n    required(),\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            timeoutMs: 1000,\n        },\n    }),\n    model()\n], CodeFlowNode);\nexport { CodeFlowNode };\n//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/nodes/utility/delay.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelayFlowNode = 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/utility/delay
+ * @summary Delay utility node declaration (DECAF-32 §22.2.2).
+ * @description Delay — pauses execution for a configured duration.
+ */
+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 DelayFlowNode = class DelayFlowNode extends decorator_validation_1.Model {
+};
+exports.DelayFlowNode = DelayFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Input value", placeholder: "Value to forward after delay" }),
+    (0, decorators_js_2.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], DelayFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("input", { label: "Output value", placeholder: "Forwarded value" }),
+    (0, decorators_js_2.output)({ handle: "value" }),
+    __metadata("design:type", Object)
+], DelayFlowNode.prototype, "valueOut", void 0);
+exports.DelayFlowNode = DelayFlowNode = __decorate([
+    (0, decorators_js_2.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);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delay.js","sourceRoot":"","sources":["delay.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/utility/delay\n * @summary Delay utility node declaration (DECAF-32 §22.2.2).\n * @description Delay — pauses execution for a configured duration.\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 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//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/nodes/utility/log.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogFlowNode = 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/utility/log
+ * @summary Log utility node declaration (DECAF-32 §22.2.2).
+ * @description Log — logs the input value and forwards it unchanged on the
+ * `logged` output port. Useful for debugging, audit trails, and
+ * discard/side-effect branches in a workflow.
+ */
+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 LogFlowNode = class LogFlowNode extends decorator_validation_1.Model {
+};
+exports.LogFlowNode = LogFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Input value", placeholder: "Value to log" }),
+    (0, decorators_js_2.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], LogFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("input", { label: "Logged value", placeholder: "Forwarded value" }),
+    (0, decorators_js_2.output)({ handle: "logged" }),
+    __metadata("design:type", Object)
+], LogFlowNode.prototype, "logged", void 0);
+exports.LogFlowNode = LogFlowNode = __decorate([
+    (0, decorators_js_2.node)("core.flow.log", {
+        kind: "core.flow.log",
+        category: "Utility",
+        color: "#6366f1",
+        icon: "ti-terminal",
+        width: 96,
+        height: 96,
+        labels: ["flow", "log", "debug", "utility"],
+        metadata: {
+            title: "Log",
+            description: "Logs the input value to the execution logger and forwards it unchanged.",
+        },
+    }),
+    (0, decorator_validation_1.model)()
+], LogFlowNode);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.js","sourceRoot":"","sources":["log.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/utility/log\n * @summary Log utility node declaration (DECAF-32 §22.2.2).\n * @description Log — logs the input value and forwards it unchanged on the\n * `logged` output port. Useful for debugging, audit trails, and\n * discard/side-effect branches in a workflow.\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 LogFlowNode = class LogFlowNode extends Model {\n};\n__decorate([\n    required(),\n    uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to log\" }),\n    input({ handle: \"value\" }),\n    __metadata(\"design:type\", Object)\n], LogFlowNode.prototype, \"value\", void 0);\n__decorate([\n    required(),\n    uielement(\"input\", { label: \"Logged value\", placeholder: \"Forwarded value\" }),\n    output({ handle: \"logged\" }),\n    __metadata(\"design:type\", Object)\n], LogFlowNode.prototype, \"logged\", void 0);\nLogFlowNode = __decorate([\n    node(\"core.flow.log\", {\n        kind: \"core.flow.log\",\n        category: \"Utility\",\n        color: \"#6366f1\",\n        icon: \"ti-terminal\",\n        width: 96,\n        height: 96,\n        labels: [\"flow\", \"log\", \"debug\", \"utility\"],\n        metadata: {\n            title: \"Log\",\n            description: \"Logs the input value to the execution logger and forwards it unchanged.\",\n        },\n    }),\n    model()\n], LogFlowNode);\nexport { LogFlowNode };\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2dyYXBoL25vZGVzL3V0aWxpdHkvbG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOzs7Ozs7R0FNRztBQUNILE9BQU8sRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3hFLE9BQU8sRUFBRSxTQUFTLEVBQUUsb0NBQStCO0FBQ25ELE9BQU8sRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSw4QkFBeUI7QUFFdkQsc0RBQXNEO0FBQ3RELGlDQUE0QjtBQWdCckIsSUFBTSxXQUFXLEdBQWpCLE1BQU0sV0FBWSxTQUFRLEtBQUs7Q0FVckMsQ0FBQTtBQU5DO0lBSEMsUUFBUSxFQUFFO0lBQ1YsU0FBUyxDQUFDLFVBQVUsRUFBRSxFQUFFLEtBQUssRUFBRSxhQUFhLEVBQUUsV0FBVyxFQUFFLGNBQWMsRUFBRSxDQUFDO0lBQzVFLEtBQUssQ0FBQyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsQ0FBQzs7MENBQ1g7QUFLaEI7SUFIQyxRQUFRLEVBQUU7SUFDVixTQUFTLENBQUMsT0FBTyxFQUFFLEVBQUUsS0FBSyxFQUFFLGNBQWMsRUFBRSxXQUFXLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQztJQUM3RSxNQUFNLENBQUMsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLENBQUM7OzJDQUNaO0FBVE4sV0FBVztJQWR2QixJQUFJLENBQUMsZUFBZSxFQUFFO1FBQ3JCLElBQUksRUFBRSxlQUFlO1FBQ3JCLFFBQVEsRUFBRSxTQUFTO1FBQ25CLEtBQUssRUFBRSxTQUFTO1FBQ2hCLElBQUksRUFBRSxhQUFhO1FBQ25CLEtBQUssRUFBRSxFQUFFO1FBQ1QsTUFBTSxFQUFFLEVBQUU7UUFDVixNQUFNLEVBQUUsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxTQUFTLENBQUM7UUFDM0MsUUFBUSxFQUFFO1lBQ1IsS0FBSyxFQUFFLEtBQUs7WUFDWixXQUFXLEVBQUUseUVBQXlFO1NBQ3ZGO0tBQ0YsQ0FBQztJQUNELEtBQUssRUFBRTtHQUNLLFdBQVcsQ0FVdkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgdWktZGVjb3JhdG9ycy9ncmFwaC9ub2Rlcy91dGlsaXR5L2xvZ1xuICogQHN1bW1hcnkgTG9nIHV0aWxpdHkgbm9kZSBkZWNsYXJhdGlvbiAoREVDQUYtMzIgwqcyMi4yLjIpLlxuICogQGRlc2NyaXB0aW9uIExvZyDigJQgbG9ncyB0aGUgaW5wdXQgdmFsdWUgYW5kIGZvcndhcmRzIGl0IHVuY2hhbmdlZCBvbiB0aGVcbiAqIGBsb2dnZWRgIG91dHB1dCBwb3J0LiBVc2VmdWwgZm9yIGRlYnVnZ2luZywgYXVkaXQgdHJhaWxzLCBhbmRcbiAqIGRpc2NhcmQvc2lkZS1lZmZlY3QgYnJhbmNoZXMgaW4gYSB3b3JrZmxvdy5cbiAqL1xuaW1wb3J0IHsgTW9kZWwsIG1vZGVsLCByZXF1aXJlZCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IHVpZWxlbWVudCB9IGZyb20gXCIuLi8uLi8uLi91aS9kZWNvcmF0b3JzXCI7XG5pbXBvcnQgeyBpbnB1dCwgbm9kZSwgb3V0cHV0IH0gZnJvbSBcIi4uLy4uL2RlY29yYXRvcnNcIjtcblxuLy8gRW5zdXJlIGNhdGVnb3J5IHN0eWxlcyBhcmUgcmVnaXN0ZXJlZCAoaWRlbXBvdGVudCkuXG5pbXBvcnQgXCIuLi9jYXRlZ29yeS1zdHlsZXNcIjtcblxuQG5vZGUoXCJjb3JlLmZsb3cubG9nXCIsIHtcbiAga2luZDogXCJjb3JlLmZsb3cubG9nXCIsXG4gIGNhdGVnb3J5OiBcIlV0aWxpdHlcIixcbiAgY29sb3I6IFwiIzYzNjZmMVwiLFxuICBpY29uOiBcInRpLXRlcm1pbmFsXCIsXG4gIHdpZHRoOiA5NixcbiAgaGVpZ2h0OiA5NixcbiAgbGFiZWxzOiBbXCJmbG93XCIsIFwibG9nXCIsIFwiZGVidWdcIiwgXCJ1dGlsaXR5XCJdLFxuICBtZXRhZGF0YToge1xuICAgIHRpdGxlOiBcIkxvZ1wiLFxuICAgIGRlc2NyaXB0aW9uOiBcIkxvZ3MgdGhlIGlucHV0IHZhbHVlIHRvIHRoZSBleGVjdXRpb24gbG9nZ2VyIGFuZCBmb3J3YXJkcyBpdCB1bmNoYW5nZWQuXCIsXG4gIH0sXG59KVxuQG1vZGVsKClcbmV4cG9ydCBjbGFzcyBMb2dGbG93Tm9kZSBleHRlbmRzIE1vZGVsIHtcbiAgQHJlcXVpcmVkKClcbiAgQHVpZWxlbWVudChcInRleHRhcmVhXCIsIHsgbGFiZWw6IFwiSW5wdXQgdmFsdWVcIiwgcGxhY2Vob2xkZXI6IFwiVmFsdWUgdG8gbG9nXCIgfSlcbiAgQGlucHV0KHsgaGFuZGxlOiBcInZhbHVlXCIgfSlcbiAgdmFsdWUhOiB1bmtub3duO1xuXG4gIEByZXF1aXJlZCgpXG4gIEB1aWVsZW1lbnQoXCJpbnB1dFwiLCB7IGxhYmVsOiBcIkxvZ2dlZCB2YWx1ZVwiLCBwbGFjZWhvbGRlcjogXCJGb3J3YXJkZWQgdmFsdWVcIiB9KVxuICBAb3V0cHV0KHsgaGFuZGxlOiBcImxvZ2dlZFwiIH0pXG4gIGxvZ2dlZCE6IHVua25vd247XG59XG4iXX0="]}

package/lib/cjs/graph/nodes/utility/map.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapFlowNode = 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/utility/map
+ * @summary Map utility node declaration (DECAF-32 §22.2.2).
+ * @description Map — transforms the current input into a new output object.
+ */
+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 MapFlowNode = class MapFlowNode extends decorator_validation_1.Model {
+};
+exports.MapFlowNode = MapFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Input value", placeholder: "Value to transform" }),
+    (0, decorators_js_2.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], MapFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("input", { label: "Transformed output", placeholder: "Mapped result" }),
+    (0, decorators_js_2.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], MapFlowNode.prototype, "result", void 0);
+exports.MapFlowNode = MapFlowNode = __decorate([
+    (0, decorators_js_2.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);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.js","sourceRoot":"","sources":["map.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/utility/map\n * @summary Map utility node declaration (DECAF-32 §22.2.2).\n * @description Map — transforms the current input into a new output object.\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 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//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/nodes/utility/merge.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeFlowNode = 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/utility/merge
+ * @summary Merge utility node declaration (DECAF-32 §22.2.2).
+ * @description Merge — normalises branch/parallel outputs into a single
+ * output.
+ */
+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 MergeFlowNode = class MergeFlowNode extends decorator_validation_1.Model {
+};
+exports.MergeFlowNode = MergeFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Branch outputs", placeholder: "Outputs to merge" }),
+    (0, decorators_js_2.input)({ handle: "values" }),
+    __metadata("design:type", Array)
+], MergeFlowNode.prototype, "values", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("input", { label: "Merged output", placeholder: "Merged result" }),
+    (0, decorators_js_2.output)({ handle: "merged" }),
+    __metadata("design:type", Object)
+], MergeFlowNode.prototype, "merged", void 0);
+exports.MergeFlowNode = MergeFlowNode = __decorate([
+    (0, decorators_js_2.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);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merge.js","sourceRoot":"","sources":["merge.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/utility/merge\n * @summary Merge utility node declaration (DECAF-32 §22.2.2).\n * @description Merge — normalises branch/parallel outputs into a single\n * output.\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 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//# sourceMappingURL=data:application/json;base64,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"]}

package/lib/cjs/graph/nodes/utility/return.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnFlowNode = 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/utility/return
+ * @summary Return utility node declaration (DECAF-32 §22.2.2).
+ * @description Return — defines and normalises the final workflow output.
+ */
+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 ReturnFlowNode = class ReturnFlowNode extends decorator_validation_1.Model {
+};
+exports.ReturnFlowNode = ReturnFlowNode;
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("textarea", { label: "Input value", placeholder: "Value to normalise" }),
+    (0, decorators_js_2.input)({ handle: "value" }),
+    __metadata("design:type", Object)
+], ReturnFlowNode.prototype, "value", void 0);
+__decorate([
+    (0, decorator_validation_1.required)(),
+    (0, decorators_js_1.uielement)("input", { label: "Returned output", placeholder: "Normalised output" }),
+    (0, decorators_js_2.output)({ handle: "result" }),
+    __metadata("design:type", Object)
+], ReturnFlowNode.prototype, "result", void 0);
+exports.ReturnFlowNode = ReturnFlowNode = __decorate([
+    (0, decorators_js_2.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);
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"return.js","sourceRoot":"","sources":["return.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/utility/return\n * @summary Return utility node declaration (DECAF-32 §22.2.2).\n * @description Return — defines and normalises the final workflow output.\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 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//# sourceMappingURL=data:application/json;base64,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"]}