@requence/service 0.7.1 → 0.8.1

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,10 +27,10 @@ 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>;
@@ -47,10 +47,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 +66,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 +87,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 +98,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 +118,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 +136,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 +162,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 +215,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,10 +233,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>;
@@ -251,10 +251,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 +268,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 +287,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 +298,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 +316,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 +332,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 +356,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/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,5 @@
+export declare const DEFAULT_AMQP_PUBLISH_TIMEOUT_MS = 10000;
+export declare const DEFAULT_AMQP_PUBLISH_RETRY_ATTEMPTS = 3;
+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;AAKpD,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"}

package/build/types/service/src/boundary.d.ts

@@ -0,0 +1,75 @@
+import type { CallbackEgressContext, CallbackIngressContext } from '@requence/callbacks';
+import { transformer } from './transformer.ts';
+type InboundCtx = Parameters<typeof transformer.inbound>[1];
+export interface OutboundBoundaryOptions {
+    uploadUrl?: string;
+    streamUrl?: string;
+    /** Claim-check offload threshold in bytes, transmitted via task options. */
+    maxPayloadSize?: number;
+    /** Upload/stream cap in bytes, transmitted via task options. */
+    maxFileSize?: number;
+    signal?: AbortSignal;
+    fetch?: typeof globalThis.fetch;
+    /** Sink for best-effort degradation notices. Defaults to `console.warn`. */
+    warn?(message: string, error?: unknown): void;
+}
+export interface OutboundSendOptions {
+    /** The emission this value belongs to (embedded in callback references). */
+    outputName?: string | null;
+    /** Callback registrar for this emission; absent ⇒ functions fail loud. */
+    onCallback?: CallbackEgressContext['onCallback'];
+    /**
+     * Log policy: sanitize the payload first (functions/opaque instances become
+     * labels), degrade offload failures to warnings, and never reject — a log
+     * line must not fail the task. On a transform error resolves to `undefined`
+     * (callers skip publishing).
+     */
+    bestEffort?: boolean;
+}
+export interface OutboundBoundary {
+    /**
+     * Serialize a value through the composed transformer inside a
+     * `withRequenceStreams` scope. The returned promise resolves with the
+     * serialized value as soon as references exist (stream bodies may still be
+     * uploading); background completion is tracked in the boundary's ledger and
+     * surfaced by `settle()`.
+     */
+    send(data: unknown, opts?: OutboundSendOptions): Promise<unknown>;
+    /** Enroll an external promise (e.g. a publish) in the done-gate. */
+    track(promise: Promise<unknown>): void;
+    /**
+     * The done-gate: wait until the ledger stops growing (sends may enqueue
+     * more sends), then throw an `AggregateError` if any fail-hard work failed.
+     * Ledger entries are pre-caught at registration time, so nothing ever
+     * rejects unhandled while the gate is not yet attached.
+     */
+    settle(): Promise<void>;
+}
+export declare function createOutboundBoundary(base: OutboundBoundaryOptions): OutboundBoundary;
+export interface InboundBoundaryOptions {
+    fetch?: typeof globalThis.fetch;
+    /** Cancellation for lazy remote reads of reconstructed values. */
+    signal?: AbortSignal;
+    /** Per-boundary rehydration timeout; composed with `signal` per call. */
+    timeoutMs?: number;
+    /** Default invocation dispatch for reconstructed callbacks. */
+    onCallbackInvoke?: CallbackIngressContext['onCallbackInvoke'];
+    /**
+     * Transformer override for this boundary; defaults to the full composed
+     * chain. Passthrough consumers substitute the claim-check-only instance
+     * (`transformer.ts`) so byte references stay raw wire objects.
+     */
+    transformer?: {
+        inbound(data: unknown, ctx: InboundCtx): Promise<unknown>;
+    };
+}
+export interface InboundReceiveOptions {
+    onCallbackInvoke?: CallbackIngressContext['onCallbackInvoke'];
+}
+/**
+ * The single place the service's ingress cancellation/timeout policy lives:
+ * every inbound transform of the runtime goes through one of these.
+ */
+export declare function createInboundBoundary(base?: InboundBoundaryOptions): (data: unknown, opts?: InboundReceiveOptions) => Promise<unknown>;
+export {};
+//# sourceMappingURL=boundary.d.ts.map

package/build/types/service/src/boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../../../src/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAc9C,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;AAE3D,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,4EAA4E;IAC5E,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;CAC9C;AAED,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,0EAA0E;IAC1E,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAA;IAChD;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACjE,oEAAoE;IACpE,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;IACtC;;;;;OAKG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,uBAAuB,GAC5B,gBAAgB,CAqFlB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,kEAAkE;IAClE,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAA;IAC7D;;;;OAIG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;CAC5E;AAED,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,CAAC,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAA;CAC9D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,sBAA2B,UAE7D,OAAO,SACP,qBAAqB,KAC1B,OAAO,CAAC,OAAO,CAAC,CAiBpB"}