@requence/service 0.7.1 → 0.8.2-edge.1149

package/build/types/helpers/src/protocol/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAK1B,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuB3B,CAAA;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAqD,CAAA;AAC/E,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAK1B,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6B3B,CAAA;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAqD,CAAA;AAC/E,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/build/types/helpers/src/protocol/configurationScript.d.ts

@@ -0,0 +1,10 @@
+export type ConfigurationScriptField = {
+    key: string;
+    body: string;
+};
+/**
+ * The single generator both sides use. `javascript`/`typescript` share the JS
+ * guest; only `python` differs.
+ */
+export declare function generateConfigurationScript(language: string, fields: ConfigurationScriptField[]): string;
+//# sourceMappingURL=configurationScript.d.ts.map

package/build/types/helpers/src/protocol/configurationScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configurationScript.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/configurationScript.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,wBAAwB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AA8DpE;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,wBAAwB,EAAE,GACjC,MAAM,CAIR"}

package/build/types/helpers/src/protocol/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,MAAM,CAAC,EAAE,MAAM;gBAD/B,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,MAAM,YAAA;CAIlC;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,EAC/C,GAAG,EAAE,CAAC,CAAC,aAAa,EACpB,OAAO,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC,CAkBf"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,MAAM,CAAC,EAAE,MAAM;IAFjC,YACE,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,MAAM,YAAA,EAGhC;CACF;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,EAC/C,GAAG,EAAE,CAAC,CAAC,aAAa,EACpB,OAAO,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC,CAkBf"}

package/build/types/helpers/src/protocol/index.d.ts

@@ -1,7 +1,12 @@
+export * from './clientProperties.ts';
 export * from './command.ts';
+export * from './configurationScript.ts';
+export * from './logicLanguages.ts';
+export * from './loopDetection.ts';
 export * from './nodeType.ts';
 export * from './update.ts';
 export * from './treeNodes.ts';
+export * from './validateTreeStructure.ts';
 export * from './NodeTree.ts';
 export * from './taskOptions.ts';
 export * from './templateNodeTypes.ts';

package/build/types/helpers/src/protocol/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,0BAA0B,CAAA;AACxC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA"}

package/build/types/helpers/src/protocol/logicLanguages.d.ts

@@ -0,0 +1,19 @@
+export declare const LOGIC_LANGUAGES: readonly ['javascript', 'python', 'typescript'];
+export type LogicLanguage = (typeof LOGIC_LANGUAGES)[number];
+export declare const EXECUTABLE_LOGIC_LANGUAGES: readonly ["javascript", "python", "typescript"];
+export type ExecutableLogicLanguage = (typeof EXECUTABLE_LOGIC_LANGUAGES)[number];
+export declare const LOGIC_TOOLCHAINS: readonly ['node', 'python'];
+export type LogicToolchain = (typeof LOGIC_TOOLCHAINS)[number];
+export declare const TOOLCHAIN_LANGUAGES: {
+    readonly node: readonly ["javascript", "typescript"];
+    readonly python: readonly ["python"];
+};
+export declare function languagesForToolchains(toolchains: readonly LogicToolchain[]): readonly ExecutableLogicLanguage[];
+export declare const DEFAULT_LOGIC_SCRIPTS: {
+    javascript: string;
+    typescript: string;
+    python: string;
+};
+export declare function getDefaultLogicScript(language: LogicLanguage): string;
+export declare function isDefaultLogicScript(script: string): boolean;
+//# sourceMappingURL=logicLanguages.d.ts.map

package/build/types/helpers/src/protocol/logicLanguages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logicLanguages.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/logicLanguages.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,YAAI,YAAY,EAAE,QAAQ,EAAE,YAAY,CAAU,CAAA;AAC9E,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAQ5D,eAAO,MAAM,0BAA0B,iDAIM,CAAA;AAC7C,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAA;AAK7C,eAAO,MAAM,gBAAgB,YAAI,MAAM,EAAE,QAAQ,CAAU,CAAA;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAA;AAS9D,eAAO,MAAM,mBAAmB;;;CAG+C,CAAA;AAQ/E,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,SAAS,cAAc,EAAE,GACpC,SAAS,uBAAuB,EAAE,CAKpC;AAID,eAAO,MAAM,qBAAqB;;;;CAIO,CAAA;AAEzC,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAErE;AAQD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE5D"}

package/build/types/helpers/src/protocol/loopDetection.d.ts

@@ -0,0 +1,23 @@
+export declare const UNCONDITIONAL_LOOP_MESSAGE = "unconditional infinite loop detected";
+interface LoopDetectionNode {
+    id: string;
+}
+interface LoopDetectionEdge {
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+}
+/**
+ * Detects an unconditional infinite loop: a cycle formed exclusively by edges
+ * that leave their source through its *default* output, where that source has
+ * no named outputs at all. A node with any named output treats its default as a
+ * conditional fallback, so all of its edges are excluded from the cycle search.
+ * Returns the id of the node where the back-edge closes the cycle (matching the
+ * traversal order of the array), or `null` when there is none.
+ *
+ * Single source of truth shared by the backend save-time tree validation
+ * (`validatedTreeSchema`) and the frontend's live structural check.
+ */
+export declare function findUnconditionalLoop(nodes: ReadonlyArray<LoopDetectionNode>, edges: ReadonlyArray<LoopDetectionEdge>): string | null;
+export {};
+//# sourceMappingURL=loopDetection.d.ts.map

package/build/types/helpers/src/protocol/loopDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopDetection.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/loopDetection.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,yCAAyC,CAAA;AAEhF,UAAU,iBAAiB;IACzB,EAAE,EAAE,MAAM,CAAA;CACX;AAED,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,CAAC,iBAAiB,CAAC,EACvC,KAAK,EAAE,aAAa,CAAC,iBAAiB,CAAC,GACtC,MAAM,GAAG,IAAI,CAyDf"}

package/build/types/helpers/src/protocol/nodeType.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod/v4';
+export declare const RESERVED_OUTPUT_NAMES: ReadonlyArray<string>;
 export declare const entryNodeSchema: z.ZodObject<{
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"entry">;
@@ -6,7 +7,20 @@ export declare const entryNodeSchema: z.ZodObject<{
     inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
 }, z.core.$strict>;
 export type EntryNode = z.output<typeof entryNodeSchema>;
+export declare const configurationFunctionsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    body: z.ZodString;
+}, z.core.$strict>>;
+export type ConfigurationFunctions = z.output<typeof configurationFunctionsSchema>;
 export declare const serviceNodeSchema: z.ZodObject<{
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"service">;
     alias: z.ZodOptional<z.ZodString>;
@@ -16,31 +30,45 @@ export declare const serviceNodeSchema: z.ZodObject<{
         type: z.ZodLiteral<"null">;
     }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
         $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodIntersection<z.ZodObject<{
+        oneOf: z.ZodArray<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+            type: z.ZodLiteral<"null">;
+        }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+            $ref: z.ZodString;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
     }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
     name: z.ZodString;
     version: z.ZodString;
     configuration: z.ZodOptional<z.ZodAny>;
     configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
     ttl: z.ZodOptional<z.ZodNumber>;
-    retry: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodDefault<z.ZodNumber>;
     retryDelay: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodDefault<z.ZodEnum<{
-        LINEAR: "LINEAR";
         CONTINUOUS: "CONTINUOUS";
+        LINEAR: "LINEAR";
     }>>;
-    outputs: z.ZodArray<z.ZodObject<{
-        name: z.ZodNullable<z.ZodString>;
-        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
-    }, z.core.$strip>>;
+    privileged: z.ZodDefault<z.ZodBoolean>;
+    wireCodec: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        msgpack: "msgpack";
+    }>>;
+    configurationServices: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
 }, z.core.$strict>;
 export type ServiceNode = z.output<typeof serviceNodeSchema>;
-/** No retry, 10s retry delay, infinite TTL */
+/** No retry (0 attempts), 10s retry delay, infinite TTL */
 export declare const SERVICE_SETTINGS_GLOBAL_DEFAULTS: {
-    readonly retry: undefined;
+    readonly retry: 0;
     readonly retryDelay: 10000;
     readonly ttl: undefined;
 };
 export declare const logicNodeSchema: z.ZodObject<{
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"logic">;
     alias: z.ZodOptional<z.ZodString>;
@@ -52,10 +80,6 @@ export declare const logicNodeSchema: z.ZodObject<{
         typescript: "typescript";
     }>>;
     maxExecutionTime: z.ZodDefault<z.ZodNumber>;
-    outputs: z.ZodArray<z.ZodObject<{
-        name: z.ZodNullable<z.ZodString>;
-        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
-    }, z.core.$strip>>;
 }, z.core.$strict>;
 export type LogicNode = z.output<typeof logicNodeSchema>;
 export declare const orNodeSchema: z.ZodObject<{
@@ -65,6 +89,10 @@ export declare const orNodeSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type OrNode = z.output<typeof orNodeSchema>;
 export declare const referenceNodeSchema: z.ZodObject<{
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"reference">;
     alias: z.ZodOptional<z.ZodString>;
@@ -76,11 +104,15 @@ export declare const referenceNodeSchema: z.ZodObject<{
         type: z.ZodLiteral<"null">;
     }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
         $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodIntersection<z.ZodObject<{
+        oneOf: z.ZodArray<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+            type: z.ZodLiteral<"null">;
+        }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+            $ref: z.ZodString;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
     }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
-    outputs: z.ZodArray<z.ZodObject<{
-        name: z.ZodNullable<z.ZodString>;
-        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
-    }, z.core.$strip>>;
 }, z.core.$strict>;
 export type ReferenceNode = z.output<typeof referenceNodeSchema>;
 export declare const exitNodeSchema: z.ZodObject<{
@@ -103,6 +135,10 @@ export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     alias: z.ZodOptional<z.ZodString>;
     inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
 }, z.core.$strict>, z.ZodObject<{
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"service">;
     alias: z.ZodOptional<z.ZodString>;
@@ -112,23 +148,37 @@ export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"null">;
     }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
         $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodIntersection<z.ZodObject<{
+        oneOf: z.ZodArray<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+            type: z.ZodLiteral<"null">;
+        }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+            $ref: z.ZodString;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
     }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
     name: z.ZodString;
     version: z.ZodString;
     configuration: z.ZodOptional<z.ZodAny>;
     configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
     ttl: z.ZodOptional<z.ZodNumber>;
-    retry: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodDefault<z.ZodNumber>;
     retryDelay: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodDefault<z.ZodEnum<{
-        LINEAR: "LINEAR";
         CONTINUOUS: "CONTINUOUS";
+        LINEAR: "LINEAR";
+    }>>;
+    privileged: z.ZodDefault<z.ZodBoolean>;
+    wireCodec: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        msgpack: "msgpack";
     }>>;
+    configurationServices: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+}, z.core.$strict>, z.ZodObject<{
     outputs: z.ZodArray<z.ZodObject<{
         name: z.ZodNullable<z.ZodString>;
         schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
     }, z.core.$strip>>;
-}, z.core.$strict>, z.ZodObject<{
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"logic">;
     alias: z.ZodOptional<z.ZodString>;
@@ -140,15 +190,15 @@ export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         typescript: "typescript";
     }>>;
     maxExecutionTime: z.ZodDefault<z.ZodNumber>;
-    outputs: z.ZodArray<z.ZodObject<{
-        name: z.ZodNullable<z.ZodString>;
-        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
-    }, z.core.$strip>>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"or">;
     alias: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"reference">;
     alias: z.ZodOptional<z.ZodString>;
@@ -160,11 +210,15 @@ export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"null">;
     }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
         $ref: z.ZodString;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodIntersection<z.ZodObject<{
+        oneOf: z.ZodArray<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+            type: z.ZodLiteral<"null">;
+        }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+            $ref: z.ZodString;
+        }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
     }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>]>>;
-    outputs: z.ZodArray<z.ZodObject<{
-        name: z.ZodNullable<z.ZodString>;
-        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
-    }, z.core.$strip>>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"exit">;

package/build/types/helpers/src/protocol/nodeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeType.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/nodeType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAkC1B,eAAO,MAAM,eAAe;;;;;kBAK1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAExD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBF,CAAA;AAC5B,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE5D,8CAA8C;AAC9C,eAAO,MAAM,gCAAgC;;;;CAInC,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;kBAYA,CAAA;AAC5B,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAExD,eAAO,MAAM,YAAY;;;;kBAIvB,CAAA;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAA;AAElD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;kBAeJ,CAAA;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;kBAKzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AAEtD,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAG5D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;iBAKrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"nodeType.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/nodeType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAmC1B,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,MAAM,CAGvD,CAAA;AA4BD,eAAO,MAAM,eAAe;;;;;kBAS1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAUxD,eAAO,MAAM,4BAA4B;;;;;;;mBAQxC,CAAA;AACD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAC3C,OAAO,4BAA4B,CACpC,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2DF,CAAA;AAC5B,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE5D,2DAA2D;AAC3D,eAAO,MAAM,gCAAgC;aAC3C,KAAK,EAAE,CAAC;aACR,UAAU,EAAE,KAAM;aAClB,GAAG;CACK,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;kBAUA,CAAA;AAC5B,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAExD,eAAO,MAAM,YAAY;;;;kBAIvB,CAAA;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAA;AAElD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;kBASJ,CAAA;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;kBAOzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AAEtD,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAG5D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;iBAKrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/build/types/helpers/src/protocol/taskOptions.d.ts

@@ -2,12 +2,14 @@ import { z } from 'zod/v4';
 export declare const taskOptionsSchema: z.ZodObject<{
     maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     mode: z.ZodDefault<z.ZodEnum<{
-        LINEAR: "LINEAR";
         CONTINUOUS: "CONTINUOUS";
+        LINEAR: "LINEAR";
     }>>;
     priority: z.ZodDefault<z.ZodInt>;
     uploadUrl: z.ZodOptional<z.ZodString>;
     streamUrl: z.ZodOptional<z.ZodString>;
+    maxPayloadSize: z.ZodOptional<z.ZodNumber>;
+    maxFileSize: z.ZodOptional<z.ZodNumber>;
     continuous: z.ZodDefault<z.ZodObject<{
         maxReconnects: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
@@ -16,6 +18,7 @@ export declare const taskOptionsSchema: z.ZodObject<{
         taskId: z.ZodUUID;
         nodeId: z.ZodUUID;
         messageId: z.ZodUUID;
+        epoch: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TaskOptions = z.output<typeof taskOptionsSchema>;

package/build/types/helpers/src/protocol/taskOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taskOptions.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/taskOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBAmB5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"taskOptions.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/taskOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBA4B5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/build/types/helpers/src/protocol/templateNodeTypes.d.ts

@@ -16,15 +16,12 @@ export declare const templateEntryNodeSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type TemplateEntryNode = z.output<typeof templateEntryNodeSchema>;
 export declare const templateServiceNodeSchema: z.ZodObject<{
-    type: z.ZodLiteral<"service">;
     id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"service">;
     alias: z.ZodOptional<z.ZodString>;
     configuration: z.ZodOptional<z.ZodAny>;
     ttl: z.ZodOptional<z.ZodNumber>;
-    retry: z.ZodOptional<z.ZodNumber>;
     retryDelay: z.ZodOptional<z.ZodNumber>;
-    serviceVersion: z.ZodNullable<z.ZodUUID>;
-    localInvocation: z.ZodOptional<z.ZodUUID>;
     position: z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
@@ -34,9 +31,24 @@ export declare const templateServiceNodeSchema: z.ZodObject<{
         height: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     flipped: z.ZodOptional<z.ZodBoolean>;
+    serviceVersion: z.ZodNullable<z.ZodUUID>;
+    localInvocation: z.ZodOptional<z.ZodUUID>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    configurationFunctions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        language: z.ZodDefault<z.ZodEnum<{
+            javascript: "javascript";
+            python: "python";
+            typescript: "typescript";
+        }>>;
+        body: z.ZodString;
+    }, z.core.$strict>>>;
 }, z.core.$strip>;
 export type TemplateServiceNode = z.output<typeof templateServiceNodeSchema>;
 export declare const templateLogicNodeSchema: z.ZodObject<{
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodUUID>;
     type: z.ZodLiteral<"logic">;
     alias: z.ZodOptional<z.ZodString>;
@@ -48,10 +60,6 @@ export declare const templateLogicNodeSchema: z.ZodObject<{
         typescript: "typescript";
     }>>;
     maxExecutionTime: z.ZodDefault<z.ZodNumber>;
-    outputs: z.ZodArray<z.ZodObject<{
-        name: z.ZodNullable<z.ZodString>;
-        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
-    }, z.core.$strip>>;
     position: z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
@@ -79,10 +87,9 @@ export declare const templateOrNodeSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type TemplateOrNode = z.output<typeof templateOrNodeSchema>;
 export declare const templateReferenceNodeSchema: z.ZodObject<{
-    type: z.ZodLiteral<"reference">;
     id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"reference">;
     alias: z.ZodOptional<z.ZodString>;
-    reference: z.ZodNullable<z.ZodUUID>;
     position: z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
@@ -92,6 +99,7 @@ export declare const templateReferenceNodeSchema: z.ZodObject<{
         height: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     flipped: z.ZodOptional<z.ZodBoolean>;
+    reference: z.ZodNullable<z.ZodUUID>;
 }, z.core.$strip>;
 export type TemplateReferenceNode = z.output<typeof templateReferenceNodeSchema>;
 export declare const templateExitNodeSchema: z.ZodObject<{
@@ -162,15 +170,12 @@ export declare const templateTreeSchema: z.ZodObject<{
         }, z.core.$strip>>;
         flipped: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"service">;
         id: z.ZodDefault<z.ZodUUID>;
+        type: z.ZodLiteral<"service">;
         alias: z.ZodOptional<z.ZodString>;
         configuration: z.ZodOptional<z.ZodAny>;
         ttl: z.ZodOptional<z.ZodNumber>;
-        retry: z.ZodOptional<z.ZodNumber>;
         retryDelay: z.ZodOptional<z.ZodNumber>;
-        serviceVersion: z.ZodNullable<z.ZodUUID>;
-        localInvocation: z.ZodOptional<z.ZodUUID>;
         position: z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
@@ -180,7 +185,22 @@ export declare const templateTreeSchema: z.ZodObject<{
             height: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         flipped: z.ZodOptional<z.ZodBoolean>;
+        serviceVersion: z.ZodNullable<z.ZodUUID>;
+        localInvocation: z.ZodOptional<z.ZodUUID>;
+        retry: z.ZodOptional<z.ZodNumber>;
+        configurationFunctions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            language: z.ZodDefault<z.ZodEnum<{
+                javascript: "javascript";
+                python: "python";
+                typescript: "typescript";
+            }>>;
+            body: z.ZodString;
+        }, z.core.$strict>>>;
     }, z.core.$strip>, z.ZodObject<{
+        outputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodNullable<z.ZodString>;
+            schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+        }, z.core.$strip>>;
         id: z.ZodDefault<z.ZodUUID>;
         type: z.ZodLiteral<"logic">;
         alias: z.ZodOptional<z.ZodString>;
@@ -192,10 +212,6 @@ export declare const templateTreeSchema: z.ZodObject<{
             typescript: "typescript";
         }>>;
         maxExecutionTime: z.ZodDefault<z.ZodNumber>;
-        outputs: z.ZodArray<z.ZodObject<{
-            name: z.ZodNullable<z.ZodString>;
-            schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
-        }, z.core.$strip>>;
         position: z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
@@ -219,10 +235,9 @@ export declare const templateTreeSchema: z.ZodObject<{
         }, z.core.$strip>>;
         flipped: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"reference">;
         id: z.ZodDefault<z.ZodUUID>;
+        type: z.ZodLiteral<"reference">;
         alias: z.ZodOptional<z.ZodString>;
-        reference: z.ZodNullable<z.ZodUUID>;
         position: z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
@@ -232,6 +247,7 @@ export declare const templateTreeSchema: z.ZodObject<{
             height: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         flipped: z.ZodOptional<z.ZodBoolean>;
+        reference: z.ZodNullable<z.ZodUUID>;
     }, z.core.$strip>, z.ZodObject<{
         id: z.ZodDefault<z.ZodUUID>;
         type: z.ZodLiteral<"exit">;

package/build/types/helpers/src/protocol/templateNodeTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templateNodeTypes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/templateNodeTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AA2B1B,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;iBAcT,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAEJ,CAAA;AAC7B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAElE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;iBAMX,CAAA;AAC7B,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAEhF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAEN,CAAA;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBAET,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,YAAY;;;;;;;;;iBAQvB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"templateNodeTypes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/templateNodeTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AA4B1B,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCT,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAEJ,CAAA;AAC7B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAElE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;iBAMX,CAAA;AAC7B,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAEhF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAEN,CAAA;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBAET,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,YAAY;;;;;;;;;iBAQvB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}