@requence/service 0.8.2-edge.1168 → 0.8.2-edge.1169

package/build/index.js

@@ -324,6 +324,13 @@ var uiRebuildSchema = z8.object({
   source: z8.string()
 });
 
+// ../helpers/src/utils/nodeResume.ts
+import { z as z9 } from "zod/v4";
+var NODE_RESUME_HEADER = "nodeResume";
+var nodeResumeReportSchema = z9.object({
+  messageId: z9.uuid()
+});
+
 // ../helpers/src/utils/obj.ts
 var import_dlv = __toESM(require_dlv(), 1);
 var getByPath = import_dlv.default;
@@ -400,7 +407,7 @@ function wireBodyByteLength(value, codec) {
 
 // src/createAmqpConnection.ts
 import { connect } from "amqp-connection-manager";
-import { z as z10 } from "zod/v4";
+import { z as z11 } from "zod/v4";
 
 // ../files/src/errors.ts
 class RequenceStreamTruncatedError extends Error {
@@ -1566,7 +1573,7 @@ async function createContextHelper(options) {
 var handlerStorage = new AsyncLocalStorage2;
 
 // ../store/src/address.ts
-import { z as z9 } from "zod/v4";
+import { z as z10 } from "zod/v4";
 // ../store/src/capability.ts
 function encode(value) {
   return Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
@@ -1844,7 +1851,7 @@ function reload(registration) {
 function errorText(error) {
   return error instanceof Error ? error.message : String(error);
 }
-var messageKeySchema = z10.string().transform((str) => deobfuscate(str)).pipe(z10.tuple([z10.uuid(), z10.uuid()]).rest(z10.string())).transform((arr) => ({
+var messageKeySchema = z11.string().transform((str) => deobfuscate(str)).pipe(z11.tuple([z11.uuid(), z11.uuid()]).rest(z11.string())).transform((arr) => ({
   taskId: arr[0],
   messageId: arr[1],
   uploadUrl: arr[2] || undefined,
@@ -1853,12 +1860,12 @@ var messageKeySchema = z10.string().transform((str) => deobfuscate(str)).pipe(z1
   maxFileSize: arr[5] && Number.isFinite(Number(arr[5])) ? Number(arr[5]) : undefined,
   nodeId: arr[6] || undefined
 }));
-var headerSchema = z10.object({
-  properties: z10.object({
-    correlationId: z10.uuid(),
-    headers: z10.object({
-      taskId: z10.uuid(),
-      mode: z10.enum(["LINEAR", "CONTINUOUS"]).default("LINEAR")
+var headerSchema = z11.object({
+  properties: z11.object({
+    correlationId: z11.uuid(),
+    headers: z11.object({
+      taskId: z11.uuid(),
+      mode: z11.enum(["LINEAR", "CONTINUOUS"]).default("LINEAR")
     })
   })
 }).transform((msg) => ({
@@ -1866,48 +1873,48 @@ var headerSchema = z10.object({
   taskId: msg.properties.headers.taskId,
   mode: msg.properties.headers.mode
 }));
-var payloadSchema = z10.object({
-  content: z10.instanceof(Buffer),
-  properties: z10.object({ contentType: z10.string().optional() })
-}).transform((msg) => decodeWireBody(msg.content, msg.properties.contentType)).pipe(z10.object({
-  input: z10.unknown().optional(),
-  configuration: z10.unknown().optional(),
-  nodeId: z10.string().optional(),
-  configurationEval: z10.boolean().optional(),
-  options: z10.object({
-    uploadUrl: z10.url().optional(),
-    streamUrl: z10.url().optional(),
-    maxPayloadSize: z10.number().optional(),
-    maxFileSize: z10.number().optional(),
-    storeUrl: z10.string().optional(),
-    storeSignature: z10.string().optional()
+var payloadSchema = z11.object({
+  content: z11.instanceof(Buffer),
+  properties: z11.object({ contentType: z11.string().optional() })
+}).transform((msg) => decodeWireBody(msg.content, msg.properties.contentType)).pipe(z11.object({
+  input: z11.unknown().optional(),
+  configuration: z11.unknown().optional(),
+  nodeId: z11.string().optional(),
+  configurationEval: z11.boolean().optional(),
+  options: z11.object({
+    uploadUrl: z11.url().optional(),
+    streamUrl: z11.url().optional(),
+    maxPayloadSize: z11.number().optional(),
+    maxFileSize: z11.number().optional(),
+    storeUrl: z11.string().optional(),
+    storeSignature: z11.string().optional()
   })
 }));
-var backchannelMessageSchema = z10.object({
-  content: z10.instanceof(Buffer),
-  properties: z10.object({
-    correlationId: z10.string(),
-    contentType: z10.string().optional(),
-    headers: z10.object({ taskId: z10.uuid().optional() }).optional().catch(undefined)
+var backchannelMessageSchema = z11.object({
+  content: z11.instanceof(Buffer),
+  properties: z11.object({
+    correlationId: z11.string(),
+    contentType: z11.string().optional(),
+    headers: z11.object({ taskId: z11.uuid().optional() }).optional().catch(undefined)
   })
 }).transform((message) => ({
   ...message,
   content: decodeWireBody(message.content, message.properties.contentType)
-})).pipe(z10.object({
-  content: z10.discriminatedUnion("type", [
-    z10.object({
-      type: z10.literal("stop")
+})).pipe(z11.object({
+  content: z11.discriminatedUnion("type", [
+    z11.object({
+      type: z11.literal("stop")
     }),
-    z10.object({
-      type: z10.literal("callback"),
-      callbackId: z10.uuid(),
-      arg: z10.any().optional(),
-      surface: z10.uuid().optional()
+    z11.object({
+      type: z11.literal("callback"),
+      callbackId: z11.uuid(),
+      arg: z11.any().optional(),
+      surface: z11.uuid().optional()
     })
   ]),
-  properties: z10.object({
-    correlationId: z10.string(),
-    headers: z10.object({ taskId: z10.uuid().optional() }).optional().catch(undefined)
+  properties: z11.object({
+    correlationId: z11.string(),
+    headers: z11.object({ taskId: z11.uuid().optional() }).optional().catch(undefined)
   })
 })).transform((message) => ({
   payload: message.content,
@@ -1915,21 +1922,21 @@ var backchannelMessageSchema = z10.object({
   taskId: message.properties.headers?.taskId
 }));
 var abortSymbol = Symbol();
-var connectionOptionsSchema = z10.object({
-  url: z10.union([
-    z10.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
-    z10.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+var connectionOptionsSchema = z11.object({
+  url: z11.union([
+    z11.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
+    z11.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
   ]),
-  version: z10.string(),
-  name: z10.string().optional(),
-  devOverlay: z10.string().optional(),
-  silent: z10.boolean().optional(),
-  prefetch: z10.number().int().optional(),
-  connectionTimeout: z10.number().positive().default(3000),
-  heartbeatInterval: z10.number().int().positive().optional(),
-  connectionOptions: z10.any().optional(),
-  maxMessageSize: z10.number().int().positive().default(128 * 1024 * 1024),
-  passthroughByteReferences: z10.boolean().optional()
+  version: z11.string(),
+  name: z11.string().optional(),
+  devOverlay: z11.string().optional(),
+  silent: z11.boolean().optional(),
+  prefetch: z11.number().int().optional(),
+  connectionTimeout: z11.number().positive().default(3000),
+  heartbeatInterval: z11.number().int().positive().optional(),
+  connectionOptions: z11.any().optional(),
+  maxMessageSize: z11.number().int().positive().default(128 * 1024 * 1024),
+  passthroughByteReferences: z11.boolean().optional()
 });
 function isMessageHandlerGenerator(handler) {
   return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
@@ -1993,7 +2000,7 @@ function createConnection({
       clientProperties: {
         ...connectionOptions?.clientProperties,
         ...buildServiceClientProperties({
-          libVersion: "javascript@0.8.2-edge.1168",
+          libVersion: "javascript@0.8.2-edge.1169",
           serviceVersion: version,
           connectionId,
           prefetch,
@@ -2135,6 +2142,19 @@ function createConnection({
       simple_default.error(`Requence: could not report a failed surface interaction on |${params.surface}|:`, error instanceof Error ? error.message : error);
     });
   };
+  const announceResume = (params) => {
+    channelWrapper.publish(exchange, "", Buffer.from(JSON.stringify({ messageId: params.messageId })), {
+      correlationId: params.messageId,
+      contentType: "application/json",
+      persistent: true,
+      headers: {
+        taskId: params.taskId,
+        [NODE_RESUME_HEADER]: true
+      }
+    }).catch((error) => {
+      simple_default.error(`Requence: could not announce the resume of message |${params.messageId}|:`, error instanceof Error ? error.message : error);
+    });
+  };
   const publishBundleSwap = (ui) => {
     const swap = {
       devSession,
@@ -2516,7 +2536,7 @@ function createConnection({
           begin: true,
           epoch,
           ...buildServiceIdentityHeaders({
-            libVersion: "javascript@0.8.2-edge.1168",
+            libVersion: "javascript@0.8.2-edge.1169",
             name,
             holdsSlot: !(isGeneratorHandler && mode === "CONTINUOUS")
           })
@@ -2821,6 +2841,7 @@ function createConnection({
           });
         }
       };
+      announceResume({ taskId, messageId });
       const result = await actor(sendApi);
       if (result != null && typeof result === "object" && ((Symbol.asyncIterator in result) || (Symbol.iterator in result))) {
         const iterable = result;
@@ -3086,5 +3107,5 @@ export {
   PayloadTooLargeError
 };
 
-//# debugId=D39971759710E28964756E2164756E21
+//# debugId=92BCB493C34198B664756E2164756E21
 //# sourceMappingURL=index.js.map