@requence/service 0.7.1 → 0.8.2-edge.1149

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

@@ -1 +1 @@
-{"version":3,"file":"treeNodes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/treeNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAQ1B,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9C,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEtB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0Q/B,CAAA;AACD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBvB,CAAA;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}
+{"version":3,"file":"treeNodes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/treeNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAmB1B,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9C,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEtB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0O/B,CAAA;AACD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBvB,CAAA;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

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

@@ -7,10 +7,10 @@ declare const nodeInitUpdateSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -27,15 +27,23 @@ declare const nodeStartUpdateSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_START">;
-    libVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    service: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        libVersion: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+        capabilities: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    wireCodec: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        json: "json";
+        msgpack: "msgpack";
+    }>>>;
     triggers: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export type NodeStartUpdate = z.infer<typeof nodeStartUpdateSchema>;
@@ -47,10 +55,10 @@ declare const nodeErrorUpdateSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -66,10 +74,10 @@ declare const nodeUpdateSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -87,10 +95,10 @@ declare const nodeCallbackSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -98,10 +106,10 @@ declare const nodeCallbackSchema: z.ZodObject<{
     targetNode: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -118,10 +126,10 @@ declare const nodeEndUpdateSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -136,20 +144,20 @@ declare const nodeDebugUpdateSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_DEBUG">;
     severity: z.ZodEnum<{
         error: "error";
-        log: "log";
-        warn: "warn";
         info: "info";
+        log: "log";
         system: "system";
+        warn: "warn";
     }>;
     data: z.ZodUnknown;
 }, z.core.$strip>;
@@ -162,10 +170,10 @@ declare const nodeDeferUpdateSchema: z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -215,10 +223,10 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -233,15 +241,23 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_START">;
-    libVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    service: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        libVersion: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+        capabilities: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    wireCodec: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        json: "json";
+        msgpack: "msgpack";
+    }>>>;
     triggers: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
@@ -251,10 +267,10 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -268,10 +284,10 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -287,10 +303,10 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -298,10 +314,10 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     targetNode: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -316,10 +332,10 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -332,20 +348,20 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_DEBUG">;
     severity: z.ZodEnum<{
         error: "error";
-        log: "log";
-        warn: "warn";
         info: "info";
+        log: "log";
         system: "system";
+        warn: "warn";
     }>;
     data: z.ZodUnknown;
 }, z.core.$strip>, z.ZodObject<{
@@ -356,10 +372,10 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
-            service: "service";
             logic: "logic";
             or: "or";
             reference: "reference";
+            service: "service";
         }>;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;

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

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAoB1B,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAEvB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;iBAYzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,mBAAmB;;;;;;;;iBAIvB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAO/D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAavB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAoB1B,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAYjE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAEvB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;iBAYzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,mBAAmB;;;;;;;;iBAIvB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAO/D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAavB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

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

@@ -0,0 +1,22 @@
+import type { TemplateTree } from './templateNodeTypes.ts';
+export interface TreeStructureError {
+    detail: string;
+    nodeId?: string;
+    structural: boolean;
+}
+/**
+ * Structural (tree-shape) validation shared by the backend save-time check
+ * (`validateTemplateTree`) and the frontend's live structural monitor. Coerces
+ * the authoring `TemplateTree` into the strict resolved tree shape — the same
+ * coercion the backend applies — then runs `validatedTreeSchema`, returning one
+ * issue per structural violation.
+ *
+ * This is exactly the set the backend persists as `code: 'TREE'` errors from the
+ * schema. It deliberately excludes the env-dependent logic execution-time limit
+ * and the computed-configuration placement checks, which the backend appends
+ * separately (they are not pure functions of the graph shape).
+ */
+export declare function validateTreeStructure(templateTree: TemplateTree, options: {
+    allowMultipleOutputs: boolean;
+}): TreeStructureError[];
+//# sourceMappingURL=validateTreeStructure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateTreeStructure.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/validateTreeStructure.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAG1D,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IAMf,UAAU,EAAE,OAAO,CAAA;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE;IAAE,oBAAoB,EAAE,OAAO,CAAA;CAAE,GACzC,kBAAkB,EAAE,CAqDtB"}

package/build/types/helpers/src/utils/amqpHeartbeat.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_AMQP_HEARTBEAT_SECONDS = 30;
+export declare function withAmqpHeartbeat(url: URL): URL;
+//# sourceMappingURL=amqpHeartbeat.d.ts.map

package/build/types/helpers/src/utils/amqpHeartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amqpHeartbeat.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/amqpHeartbeat.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,8BAA8B,KAAK,CAAA;AAShD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAM/C"}

package/build/types/helpers/src/utils/amqpPublishRetry.d.ts

@@ -0,0 +1,45 @@
+export declare const DEFAULT_AMQP_PUBLISH_TIMEOUT_MS = 10000;
+export declare const DEFAULT_AMQP_PUBLISH_RETRY_ATTEMPTS = 3;
+/**
+ * How long the loop must have been unable to run a callback during a publish's
+ * in-flight window for its confirm deadline to be treated as spurious rather
+ * than as a lost message.
+ *
+ * Mirrors the operator's event-loop stall threshold: a full second in which no
+ * callback could run is a stall, not scheduling jitter. Comfortably above normal
+ * GC pauses (so a genuinely unresponsive broker on a healthy loop still times
+ * out and retries) and far below the incident's multi-second stalls.
+ */
+export declare const PUBLISH_STARVATION_THRESHOLD_MS = 1000;
+export interface LoopStarvationProbe {
+    /**
+     * Stop sampling and return the longest stretch (ms) during which the loop
+     * could not run a callback since the probe started. Idempotent — subsequent
+     * calls return the same value without re-reading the clock.
+     */
+    stop: () => number;
+}
+/**
+ * Measure how long the event loop was starved while a single publish is in
+ * flight. It runs a self-rescheduling timer and, crucially, also reads the
+ * pending gap synchronously at `stop()`: a stall that blocked the loop right up
+ * to `stop()` is caught by `now() - expected` even though the timer never got a
+ * chance to fire. That makes the reading immune to the very stall it measures
+ * and independent of callback ordering after the loop resumes.
+ *
+ * The clock is monotonic (`performance.now`), never wall time — the operator's
+ * lag monitor uses the same, and a wall-clock step (NTP) must not read as
+ * starvation and suppress a legitimate retry. `now` is injectable for tests.
+ */
+export declare function createLoopStarvationProbe({ now, }?: {
+    now?: () => number;
+}): LoopStarvationProbe;
+/**
+ * Whether a confirm deadline that elapsed should be read as loop starvation
+ * rather than a lost publish. When it returns true the publish must NOT be
+ * re-sent: the message is in the broker's hands and only the confirm was late.
+ */
+export declare function isStarvedPublishTimeout(starvedMs: number): boolean;
+export declare function isRetryablePublishError(error: unknown): boolean;
+export declare function computeAmqpPublishRetryDelay(attempt: number): number;
+//# sourceMappingURL=amqpPublishRetry.d.ts.map

package/build/types/helpers/src/utils/amqpPublishRetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amqpPublishRetry.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/amqpPublishRetry.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,+BAA+B,QAAS,CAAA;AACrD,eAAO,MAAM,mCAAmC,IAAI,CAAA;AAqBpD;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B,OAAQ,CAAA;AAEpD,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,IAAI,EAAE,MAAM,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,GAA6B,GAC9B,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO,GAAG,mBAAmB,CAyBnD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,WAExD;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,WAQrD;AAID,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,UAM3D"}

package/build/types/helpers/src/utils/claimCheckObject.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod/v4';
+declare const claimCheckObjectSchema: z.ZodObject<{
+    url: z.ZodURL;
+    size: z.ZodInt;
+    __REQUENCE_type: z.ZodLiteral<"ClaimCheck">;
+}, z.core.$strip>;
+/**
+ * Reference left behind by the oversized-message claim-check: the value was
+ * offloaded to the files service and is fetched back (and re-walked) on
+ * ingress by the `ClaimCheck` value handler.
+ */
+export type ClaimCheckObject = z.infer<typeof claimCheckObjectSchema>;
+export declare function toClaimCheckObject(info: {
+    url: string;
+    size: number;
+}): ClaimCheckObject;
+export declare function isClaimCheckObject(data: unknown): data is ClaimCheckObject;
+/**
+ * JSON-schema equivalent of the reference shape, for claim-check-aware
+ * validation: a subschema position holding a `ClaimCheck` reference is
+ * validated against this instead of the declared subschema (shape validation
+ * of the offloaded value is deferred to the consumer after rehydration).
+ */
+export declare const claimCheckJsonSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly url: {
+            readonly type: 'string';
+        };
+        readonly size: {
+            readonly type: 'integer';
+        };
+        readonly __REQUENCE_type: {
+            readonly const: 'ClaimCheck';
+        };
+    };
+    readonly required: readonly ['url', 'size', '__REQUENCE_type'];
+};
+export {};
+//# sourceMappingURL=claimCheckObject.d.ts.map

package/build/types/helpers/src/utils/claimCheckObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimCheckObject.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/claimCheckObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,QAAA,MAAM,sBAAsB;;;;iBAI1B,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,GAAG,gBAAgB,CAKnB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,gBAAgB,CAE1E;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;aAC/B,IAAI,EAAE,QAAQ;aACd,UAAU;iBACR,GAAG;qBAAI,IAAI,EAAE,QAAQ;;iBACrB,IAAI;qBAAI,IAAI,EAAE,SAAS;;iBACvB,eAAe;qBAAI,KAAK,EAAE,YAAY;;;aAExC,QAAQ,YAAG,KAAK,EAAE,MAAM,EAAE,iBAAiB;CACnC,CAAA"}

package/build/types/helpers/src/utils/debounce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/debounce.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EACzD,EAAE,EAAE,CAAC,EACL,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,IAIpB,GAAG,MAAM,UAAU,CAAC,CAAC,CAAC,UAc/B"}
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/debounce.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EACzD,EAAE,EAAE,CAAC,EACL,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,aAIX,UAAU,CAAC,CAAC,CAAC,UAc/B"}

package/build/types/helpers/src/{files → utils}/fileObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fileObject.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/files/fileObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,QAAA,MAAM,gBAAgB;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,wBAAgB,YAAY,CAAC,QAAQ,EAAE;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,GAAG,UAAU,CAKb;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAE9D"}
+{"version":3,"file":"fileObject.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/fileObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,QAAA,MAAM,gBAAgB;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,wBAAgB,YAAY,CAAC,QAAQ,EAAE;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,GAAG,UAAU,CAKb;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAE9D"}

package/build/types/helpers/src/{files → utils}/isValidMimeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isValidMimeType.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/files/isValidMimeType.ts"],"names":[],"mappings":"AAuCA,wBAAgB,eAAe,CAC7B,QAAQ,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACxC,MAAM,EAAE,MAAM,WA6Bf"}
+{"version":3,"file":"isValidMimeType.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/isValidMimeType.ts"],"names":[],"mappings":"AAuCA,wBAAgB,eAAe,CAC7B,QAAQ,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACxC,MAAM,EAAE,MAAM,WA6Bf"}

package/build/types/helpers/src/utils/mapData.d.ts

@@ -5,7 +5,7 @@ interface DataVistors {
     Number?: DataVistor<number>;
     Object?: DataVistor<object>;
     Array?: DataVistor<Array<any>>;
-    Buffer?: DataVistor<Buffer>;
+    Buffer?: DataVistor<Uint8Array>;
     Function?: DataVistor<(...args: any[]) => any>;
     Symbol?: DataVistor<symbol>;
 }

package/build/types/helpers/src/utils/mapData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapData.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/mapData.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,CAAC,IAAI,CACnB,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KACzB,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;AAEvB,UAAU,WAAW;IACnB,IAAI,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,CAAA;IACvB,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,KAAK,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAA;IAC9C,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;CAC5B;AAED,KAAK,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAC5E,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,GAAG,GACJ,OAAO,CAAC,GAAG,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACzC,IAAI,GACJ,IAAI,GACN,IAAI,CAAA;AAmBR,wBAAgB,OAAO,CACrB,MAAM,EACN,KAAK,GAAG,OAAO,EACf,CAAC,SAAS,WAAW,GAAG,WAAW,EAEnC,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,CAAC,GACV,gBAAgB,CACjB,CAAC,EACD,OAAO,CAAC,OAAO,SAAS,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC,EAChD,OAAO,SAAS,MAAM,GAAG,KAAK,GAAG,MAAM,CACxC,CAiFA;yBA5Fe,OAAO"}
+{"version":3,"file":"mapData.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/mapData.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,CAAC,IAAI,CACnB,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KACzB,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;AAEvB,UAAU,WAAW;IACnB,IAAI,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,CAAA;IACvB,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC3B,KAAK,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,CAAA;IAC/B,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAA;IAC9C,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;CAC5B;AAED,KAAK,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAC5E,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,GAAG,GACJ,OAAO,CAAC,GAAG,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACzC,IAAI,GACJ,IAAI,GACN,IAAI,CAAA;AAmBR,wBAAgB,OAAO,CACrB,MAAM,EACN,KAAK,GAAG,OAAO,EACf,CAAC,SAAS,WAAW,GAAG,WAAW,EAEnC,IAAI,EAAE,KAAK,EACX,QAAQ,EAAE,CAAC,GACV,gBAAgB,CACjB,CAAC,EACD,OAAO,CAAC,OAAO,SAAS,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC,EAChD,OAAO,SAAS,MAAM,GAAG,KAAK,GAAG,MAAM,CACxC,CAiFA;yBA5Fe,OAAO"}

package/build/types/helpers/src/{files → utils}/streamObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamObject.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/files/streamObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,QAAA,MAAM,kBAAkB;;;;iBAItB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,YAAY,CAElE;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,GAAG,YAAY,CAKf"}
+{"version":3,"file":"streamObject.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/streamObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,QAAA,MAAM,kBAAkB;;;;iBAItB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,YAAY,CAElE;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,GAAG,YAAY,CAKf"}

package/build/types/helpers/src/utils/variableRef.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod/v4';
+export declare const VARIABLE_KEY_PATTERN: RegExp;
+declare const variableRefSchema: z.ZodObject<{
+    __REQUENCE_type: z.ZodLiteral<"VariableRef">;
+    key: z.ZodString;
+    id: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;
+/**
+ * Reference to a scope variable in a service configuration field. One form,
+ * `{ key }`, and it lives ONLY in templates: task creation replaces it with the
+ * variable's literal value — plain and secret identically, since secrets are
+ * decrypted in ui/backend before they are baked (D-V1). Grep-able invariant: a
+ * `VariableRef` never appears in a serialized treeList.
+ */
+export type VariableRefObject = z.infer<typeof variableRefSchema>;
+export declare function toVariableRefObject(key: string): VariableRefObject;
+export declare function isVariableRefObject(data: unknown): data is VariableRefObject;
+export {};
+//# sourceMappingURL=variableRef.d.ts.map

package/build/types/helpers/src/utils/variableRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variableRef.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/variableRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,eAAO,MAAM,oBAAoB,QAAsB,CAAA;AAOvD,QAAA,MAAM,iBAAiB;;;;iBAIrB,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAKlE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,iBAAiB,CAE5E"}

package/build/types/helpers/src/utils/variableScriptPatterns.d.ts

@@ -0,0 +1,125 @@
+/**
+ * The call forms the logic-node guests document and this module recognizes — the
+ * shared fixture that keeps the two in lockstep: what users can write is exactly
+ * what a rename rewrites AND what task creation inlines. `%KEY%` is the key
+ * placeholder; render with {@link renderVariableAccess}.
+ *
+ * Identical in TypeScript, JavaScript and Python — the call shape does not
+ * differ by language, and it carries NO `await` in any of them (unit 08): the
+ * call becomes the value, and both languages' typed surfaces return that value
+ * directly. Deliberately short: every extra sugar is another form the patterns
+ * must chase (README D-P6). Since unit 07 a computed key
+ * (`variables.get(someVariable)`) is not merely outside rename safety, it cannot
+ * work at all: there is no value to inline, and no run-time lookup left to fall
+ * back on (see {@link findUnrecognizedVariableAccess}).
+ */
+export declare const VARIABLE_ACCESS_FORMS: readonly [`context.variables.get('%KEY%')`, `context.variables.get("%KEY%")`, `context.variables.get( '%KEY%' )`, `variables.get('%KEY%')`];
+export declare function renderVariableAccess(form: string, key: string): string;
+export type VariableKeyMatch = {
+    /** Offset of the first character of the key (inside the quotes). */
+    start: number;
+    /** Offset one past the last character of the key. */
+    end: number;
+};
+export type VariableAccessMatch = {
+    /** Offset of the first character of the replaced expression. */
+    start: number;
+    /** Offset one past the last character of the replaced expression. */
+    end: number;
+    key: string;
+};
+/**
+ * Every recognized access as the exact span an inliner replaces — the whole
+ * CALL, not just its key (that is {@link findVariableKeyMatches}), so
+ * surrounding code is untouched.
+ *
+ * `includeAwait` extends the span over a preceding `await`. It is pure
+ * ROBUSTNESS, not a documented form: since unit 08 the typed surface returns the
+ * value in every language, so no author has a reason to write `await` — but a
+ * pre-08 script (or a habit) might, and in Python `await <literal>` raises a
+ * TypeError, so the `await` must GO along with the call. JS/TS deliberately keep
+ * theirs: `await` of a non-promise is legal there, so a stray `await` survives
+ * the replacement untouched.
+ *
+ * A match inside a comment or a string literal is replaced like any other (no
+ * parser, by design). That is safe rather than merely tolerated: every
+ * serializer escapes newlines, so a replacement can never break out of the line
+ * — or the string — it was found on.
+ */
+export declare function findVariableAccessMatches(script: string, options?: {
+    includeAwait?: boolean;
+}): VariableAccessMatch[];
+/**
+ * Every distinct key a script names through a recognized `variables.get(…)`
+ * call — the inverse of {@link findVariableKeyMatches}, which asks about one
+ * known key. Used by authoring validation to flag a script that reads a variable
+ * that no longer exists: since unit 07 the value is inlined at task creation, so
+ * an unknown key must fail authoring — otherwise it fails task creation, later.
+ *
+ * Built on {@link findVariableAccessMatches}, so a key this returns is exactly a
+ * key task creation inlines. Computed keys stay invisible here and are reported
+ * by {@link findUnrecognizedVariableAccess} instead.
+ */
+export declare function findVariableKeys(script: string): string[];
+export type VariableAccessIssue = {
+    start: number;
+    end: number;
+    /**
+     * `dynamic-key` — a `get(…)` call whose argument is not a literal key
+     * (`get('smtp.' + region)`, `get(someKey)`): nothing to inline.
+     * `method-reference` — the method taken without calling it
+     * (`const get = context.variables.get`): the call site is invisible.
+     */
+    kind: 'dynamic-key' | 'method-reference';
+};
+/**
+ * `context.variables.get` uses this module cannot inline. Since unit 07 these
+ * are authoring errors, not runtime lookups: a call the replacement pass does
+ * not see is not a lookup at all — it reaches the guests' teaching stub.
+ *
+ * Scoped to the `context.` receiver ON PURPOSE, and it is the narrower of two
+ * bad options. The destructured `variables.get(…)` form is indistinguishable
+ * from any user-authored object named `variables` that happens to have a `get`
+ * (a `Map`, most obviously — this repo's own code does it), so scanning it would
+ * fail authoring on scripts that never touched a variable. The cost is symmetric
+ * and accepted: a dynamic key written through the destructured form, an aliased
+ * receiver (`const v = context.variables; v.get(x)`), or a `variables` member of
+ * another object is neither inlined nor reported, and hits the stub at run time.
+ * That is what the stub is for.
+ */
+export declare function findUnrecognizedVariableAccess(script: string): VariableAccessIssue[];
+/**
+ * Exact offsets of every quoted `key` inside a recognized
+ * `variables.get(…)` call, ascending. Only the key segment is addressed, so
+ * a rewrite replaces nothing but the key itself. Keys match
+ * `VARIABLE_KEY_PATTERN` (no quotes or backslashes possible), and the match
+ * is anchored on the closing quote — `a.b` never matches inside `a.bc`.
+ */
+export declare function findVariableKeyMatches(script: string, key: string): VariableKeyMatch[];
+/**
+ * Rewrites every recognized access of `oldKey` to `newKey` — built on the
+ * same matches as the scan, so the two never disagree about what a usage is.
+ */
+export declare function rewriteVariableKey(script: string, oldKey: string, newKey: string): string;
+/**
+ * The value as the language's own literal, always parenthesized.
+ *
+ * The parens are not cosmetic in either language: an unparenthesized object
+ * literal cannot start a JS statement, and an unparenthesized negative number
+ * changes the meaning of a surrounding Python `**` (`x ** -5` vs `x ** (-5)`).
+ *
+ * Both languages inline the value's JSON projection, so what a script sees is
+ * exactly what a service node's configuration field would have been baked with.
+ */
+export declare function serializeVariableLiteral(language: string, value: unknown): string;
+/**
+ * Replaces every recognized access in `script` with its value as a literal —
+ * the bake's script half, the exact analogue of replacing a config-ref tag with
+ * its value. Returns the input unchanged when there is nothing to replace, so a
+ * re-bake of an already-inlined snapshot is a no-op.
+ *
+ * `resolve` owns lookup, decryption and failure: it is called once per distinct
+ * key, in source order, and whatever it throws fails task creation.
+ */
+export declare function inlineVariableAccess(script: string, language: string, resolve: (key: string) => Promise<unknown>): Promise<string>;
+//# sourceMappingURL=variableScriptPatterns.d.ts.map

package/build/types/helpers/src/utils/variableScriptPatterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variableScriptPatterns.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/variableScriptPatterns.ts"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,YAChC,gCAAgC,EAChC,gCAAgC,EAChC,kCAAkC,EAClC,wBAAwB,CAChB,CAAA;AAEV,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAsBD,MAAM,MAAM,mBAAmB,GAAG;IAChC,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAA;IACb,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACvC,mBAAmB,EAAE,CAiBvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEzD;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX;;;;;OAKG;IACH,IAAI,EAAE,aAAa,GAAG,kBAAkB,CAAA;CACzC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,MAAM,GACb,mBAAmB,EAAE,CAsBvB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GACV,gBAAgB,EAAE,CAkBpB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAYD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,MAAM,CAoBR;AA+DD;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACzC,OAAO,CAAC,MAAM,CAAC,CA2BjB"}