@requence/service 1.0.0-alpha.13 → 1.0.0-alpha.14

package/build/index.js

@@ -1,25 +1,158 @@
 import {
-  clone,
-  createObjectProxy,
   deobfuscate,
-  mapData,
   obfuscate
-} from "./chunk-fa95vcc4.js";
+} from "./chunk-6w7td62p.js";
 
 // src/index.ts
 import { readFileSync } from "node:fs";
-import { z as z8 } from "zod";
+
+// ../helpers/src/utils/clone.ts
+var CLONE_SYMBOL = Symbol("original");
+function clone(data) {
+  if (typeof data !== "object" || data === null) {
+    return data;
+  }
+  const target = data[CLONE_SYMBOL];
+  if (target) {
+    return clone(target);
+  }
+  if (Array.isArray(data)) {
+    return data.map(clone);
+  }
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, clone(value)]));
+}
+
+// ../helpers/src/utils/createObjectProxy.ts
+function createObjectProxy(obj, onChange) {
+  return new Proxy(obj, {
+    set(target, property, newValue) {
+      const result = Reflect.set(target, property, newValue);
+      onChange(target);
+      return result;
+    },
+    deleteProperty(target, property) {
+      const result = Reflect.deleteProperty(target, property);
+      onChange(target);
+      return result;
+    },
+    get(target, property, receiver) {
+      if (property === CLONE_SYMBOL) {
+        return target;
+      }
+      const result = Reflect.get(target, property, receiver);
+      if (typeof result === "object" && result !== null) {
+        return createObjectProxy(result, () => onChange(target));
+      }
+      return result;
+    }
+  });
+}
+
+// ../helpers/src/utils/createRemotePromise.ts
+function createRemotePromise(onAwait) {
+  let resolvePromise;
+  let rejectPromise;
+  const internalPromise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  let isAwaited = false;
+  const wrappedPromise = new Proxy(internalPromise, {
+    get(target, property) {
+      if (property === "then" || property === "catch" || property === "finally") {
+        if (!isAwaited && onAwait) {
+          isAwaited = true;
+          onAwait(resolvePromise, rejectPromise);
+        }
+        return target[property].bind(target);
+      }
+      return target[property];
+    }
+  });
+  return Object.assign(wrappedPromise, {
+    resolve: resolvePromise,
+    reject: rejectPromise,
+    promise: wrappedPromise
+  });
+}
+
+// ../helpers/src/utils/isRecord.ts
+import { z } from "zod";
+var recordSchema = z.record(z.unknown());
+function isRecord(data) {
+  return recordSchema.safeParse(data).success;
+}
+
+// ../helpers/src/utils/mapData.ts
+function resolve(value, onResolve) {
+  if (value instanceof Promise) {
+    return Promise.resolve().then(() => value).then(onResolve);
+  }
+  return onResolve(value);
+}
+function notUndefined(value, fallback) {
+  return resolve(value, (resolvedValue) => typeof resolvedValue === "undefined" ? fallback : resolvedValue);
+}
+function mapData(data, visitors) {
+  const traverseData = (data2, path) => {
+    if (Array.isArray(data2)) {
+      return resolve(visitors.Array?.(data2, path), (resolvedData) => {
+        if (resolvedData) {
+          return resolvedData;
+        }
+        const items = data2.map((item, index) => traverseData(item, [...path, index]));
+        if (items.some((item) => item instanceof Promise)) {
+          return Promise.all(items);
+        }
+        return items;
+      });
+    }
+    if (data2 === null) {
+      return notUndefined(visitors.Null?.(data2, path), data2);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(data2)) {
+      return notUndefined(visitors.Buffer?.(data2, path), data2);
+    }
+    if (typeof data2 === "string") {
+      return notUndefined(visitors.String?.(data2, path), data2);
+    }
+    if (typeof data2 === "number") {
+      return notUndefined(visitors.Number?.(data2, path), data2);
+    }
+    if (isRecord(data2)) {
+      return resolve(visitors.Object?.(data2, path), (resolvedData) => {
+        if (resolvedData) {
+          return resolvedData;
+        }
+        const entries = Object.entries(data2).map(([key, value]) => [
+          key,
+          traverseData(value, [...path, key])
+        ]);
+        if (entries.some(([, value]) => value instanceof Promise)) {
+          return Promise.all(entries.map(([key, value]) => Promise.resolve().then(() => value).then((resolvedValue) => [key, resolvedValue]))).then((entries2) => Object.fromEntries(entries2));
+        }
+        return Object.fromEntries(entries);
+      });
+    }
+    return data2;
+  };
+  return traverseData(data, []);
+}
+
+// src/index.ts
+import { z as z9 } from "zod";
 
 // ../helpers/src/context/context.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // ../helpers/src/files/index.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // ../helpers/src/files/mapOutput.ts
-async function upload(uploadUrl, body, contentType) {
+async function upload(uploadUrl, body, signal, contentType) {
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
+    signal,
     headers: contentType ? {
       "Content-Type": contentType
     } : {},
@@ -31,7 +164,7 @@ async function upload(uploadUrl, body, contentType) {
   }
   return toFileObject(data);
 }
-async function stream(streamUrl, stream2, contentType) {
+async function stream(streamUrl, stream2, signal, contentType) {
   const [testStream, dataStream] = stream2.tee();
   const reader = testStream.getReader();
   const dataPromise = reader.read().then(({ done: done2 }) => {
@@ -42,6 +175,7 @@ async function stream(streamUrl, stream2, contentType) {
   });
   const streamResponse = await fetch(streamUrl, {
     method: "POST",
+    signal,
     headers: contentType ? { "Content-Type": contentType } : {}
   });
   const data = await streamResponse.json();
@@ -52,36 +186,37 @@ async function stream(streamUrl, stream2, contentType) {
   await dataPromise;
   const done = fetch(url, {
     method: "POST",
+    signal,
     duplex: "half",
     body: dataStream
   });
   return [toStreamObject({ mime, url }), done];
 }
-async function mapOutput(value, nodeOptions, eventHandlers) {
+async function mapOutput(params) {
   const streamPromises = [];
-  const mapped = await mapData(value, {
+  const mapped = await mapData(params.value, {
     async Object(obj) {
       if (obj instanceof Blob || obj instanceof RequenceFile) {
         if (obj instanceof RequenceFile && obj.fileObject) {
           return obj.fileObject;
         }
-        if (nodeOptions.uploadUrl) {
+        if (params.options.uploadUrl) {
           try {
             if (obj instanceof Blob) {
-              return await upload(nodeOptions.uploadUrl, obj, obj.type);
+              return await upload(params.options.uploadUrl, obj, params.signal, obj.type);
             }
             if (obj instanceof RequenceFile) {
-              return await upload(nodeOptions.uploadUrl, await obj.blob(), obj.mimeType);
+              return await upload(params.options.uploadUrl, await obj.blob(), params.signal, obj.mimeType);
             }
           } catch (error) {
             if (!(error instanceof Error)) {
               throw error;
             }
-            eventHandlers?.onFail?.(error);
+            params.onFail?.(error);
             return null;
           }
         } else {
-          eventHandlers?.onSkip?.();
+          params.onSkip?.();
           return null;
         }
       }
@@ -89,15 +224,15 @@ async function mapOutput(value, nodeOptions, eventHandlers) {
         if (obj instanceof RequenceStream && obj.streamObject) {
           return obj.streamObject;
         }
-        if (nodeOptions.streamUrl) {
+        if (params.options.streamUrl) {
           try {
             if (obj instanceof Response && obj.body) {
-              const [streamObject, streamPromise] = await stream(nodeOptions.streamUrl, obj.body, obj.headers.get("Content-Type"));
+              const [streamObject, streamPromise] = await stream(params.options.streamUrl, obj.body, params.signal, obj.headers.get("Content-Type"));
               streamPromises.push(streamPromise);
               return streamObject;
             }
             if (obj instanceof RequenceStream) {
-              const [streamObject, streamPromise] = await stream(nodeOptions.streamUrl, obj.stream(), obj.mimeType);
+              const [streamObject, streamPromise] = await stream(params.options.streamUrl, obj.stream(), params.signal, obj.mimeType);
               streamPromises.push(streamPromise);
               return streamObject;
             }
@@ -105,17 +240,17 @@ async function mapOutput(value, nodeOptions, eventHandlers) {
             if (!(error instanceof Error)) {
               throw error;
             }
-            eventHandlers?.onFail?.(error);
+            params.onFail?.(error);
             return null;
           }
         } else {
-          eventHandlers?.onSkip?.();
+          params.onSkip?.();
           return null;
         }
       }
     }
   });
-  Promise.allSettled(streamPromises).then(() => eventHandlers?.onDone?.());
+  Promise.allSettled(streamPromises).then(() => params.onDone?.());
   return mapped;
 }
 // ../helpers/src/files/isValidMimeType.ts
@@ -261,11 +396,11 @@ class RequenceStream {
 }
 
 // ../helpers/src/files/index.ts
-var fileObjectSchema = z.object({
-  size: z.number().int().positive(),
-  mime: z.string(),
-  url: z.string().url(),
-  __REQUENCE_type: z.literal("RequenceFile")
+var fileObjectSchema = z2.object({
+  size: z2.number().int().positive(),
+  mime: z2.string(),
+  url: z2.string().url(),
+  __REQUENCE_type: z2.literal("RequenceFile")
 });
 function toFileObject(fileInfo) {
   return {
@@ -276,10 +411,10 @@ function toFileObject(fileInfo) {
 function isFileObject(data) {
   return fileObjectSchema.safeParse(data).success;
 }
-var streamObjectSchema = z.object({
-  mime: z.string(),
-  url: z.string().url(),
-  __REQUENCE_type: z.literal("RequenceStream")
+var streamObjectSchema = z2.object({
+  mime: z2.string(),
+  url: z2.string().url(),
+  __REQUENCE_type: z2.literal("RequenceStream")
 });
 function toStreamObject(streamInfo) {
   return {
@@ -292,21 +427,21 @@ function isStreamObject(data) {
 }
 
 // ../helpers/src/context/context.ts
-var contextSchema = z2.object({
-  input: z2.any(),
-  meta: z2.any(),
-  tenant: z2.object({ name: z2.string() }),
-  data: z2.record(z2.string(), z2.any()),
-  errors: z2.record(z2.string(), z2.string()),
-  dates: z2.record(z2.string(), z2.string().datetime())
+var contextSchema = z3.object({
+  input: z3.any(),
+  meta: z3.any(),
+  tenant: z3.object({ name: z3.string() }),
+  data: z3.record(z3.string(), z3.any()),
+  errors: z3.record(z3.string(), z3.string()),
+  dates: z3.record(z3.string(), z3.string().datetime())
 });
 var internalKey = Symbol.for("internal");
 
 // ../helpers/src/protocol/command.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // ../helpers/src/protocol/nodes.ts
-import { ZodError, z as z5 } from "zod";
+import { ZodError, z as z6 } from "zod";
 
 // ../helpers/src/protocol/getNodeOutputs.ts
 function getNodeOutputs(node, outputName) {
@@ -442,10 +577,10 @@ function identifyNode(nodeId, getNode) {
 }
 
 // ../helpers/src/protocol/node.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../helpers/src/jsonschema/zod.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../helpers/src/jsonschema/validate.ts
 import {
@@ -539,42 +674,42 @@ class Ajv extends BaseAjv {
 }
 
 // ../helpers/src/jsonschema/zod.ts
-var jsonSchema7Schema = z3.custom((value) => {
+var jsonSchema7Schema = z4.custom((value) => {
   const ajv = new Ajv;
   return ajv.validateSchema(value);
 }, { message: "Invalid json schema" });
-var jsonSchema7ObjectSchema = z3.object({
-  type: z3.literal("object")
+var jsonSchema7ObjectSchema = z4.object({
+  type: z4.literal("object")
 }).and(jsonSchema7Schema);
-var jsonSchema7NullSchema = z3.object({
-  type: z3.literal("null")
+var jsonSchema7NullSchema = z4.object({
+  type: z4.literal("null")
 });
 
 // ../helpers/src/protocol/node.ts
-var outputDefinitionSchema = z4.object({
+var outputDefinitionSchema = z5.object({
   schema: jsonSchema7Schema.nullable().optional()
-}).and(z4.union([
-  z4.object({
-    default: z4.literal(false).default(false),
-    name: z4.string().min(1)
+}).and(z5.union([
+  z5.object({
+    default: z5.literal(false).default(false),
+    name: z5.string().min(1)
   }),
-  z4.object({
-    default: z4.literal(true).default(true)
+  z5.object({
+    default: z5.literal(true).default(true)
   })
-])).and(z4.union([
-  z4.object({
-    exit: z4.literal(false).default(false),
-    target: z4.string().min(1)
+])).and(z5.union([
+  z5.object({
+    exit: z5.literal(false).default(false),
+    target: z5.string().min(1)
   }),
-  z4.object({ exit: z4.literal(true) })
+  z5.object({ exit: z5.literal(true) })
 ]));
-var defaultOutputSchema = z4.union([
-  z4.string().min(1),
-  z4.object({ default: z4.literal(true).default(true), exit: z4.literal(true) }),
-  z4.object({
-    default: z4.literal(true).default(true),
-    exit: z4.literal(false).default(false),
-    target: z4.string().min(1)
+var defaultOutputSchema = z5.union([
+  z5.string().min(1),
+  z5.object({ default: z5.literal(true).default(true), exit: z5.literal(true) }),
+  z5.object({
+    default: z5.literal(true).default(true),
+    exit: z5.literal(false).default(false),
+    target: z5.string().min(1)
   })
 ]).transform((output) => {
   if (typeof output === "string") {
@@ -586,7 +721,7 @@ var defaultOutputSchema = z4.union([
   }
   return output;
 });
-var outputSchema = z4.union([z4.string().min(1), outputDefinitionSchema]).transform((output) => {
+var outputSchema = z5.union([z5.string().min(1), outputDefinitionSchema]).transform((output) => {
   if (typeof output === "string") {
     return {
       default: true,
@@ -627,59 +762,59 @@ function validateOutputs(outputs, ctx) {
     knownTargets.add(target);
   });
 }
-var defaultOutputsSchema = z4.array(defaultOutputSchema).default([]).superRefine(validateOutputs);
-var outputsSchema = z4.array(outputSchema).default([]).superRefine(validateOutputs);
-var idSchema = z4.string().uuid().default(() => crypto.randomUUID());
-var metaSchema = z4.record(z4.any()).optional();
-var entryNodeSchema = z4.object({
-  type: z4.literal("entry"),
-  id: z4.literal("__entry__").default("__entry__"),
+var defaultOutputsSchema = z5.array(defaultOutputSchema).default([]).superRefine(validateOutputs);
+var outputsSchema = z5.array(outputSchema).default([]).superRefine(validateOutputs);
+var idSchema = z5.string().uuid().default(() => crypto.randomUUID());
+var metaSchema = z5.record(z5.any()).optional();
+var entryNodeSchema = z5.object({
+  type: z5.literal("entry"),
+  id: z5.literal("__entry__").default("__entry__"),
   output: defaultOutputsSchema,
   inputSchema: jsonSchema7Schema.default({ type: "null" }),
   metaSchema: jsonSchema7Schema.default({ type: "null" }),
   meta: metaSchema
 });
-var serviceNodeSchema = z4.object({
-  type: z4.literal("service"),
+var serviceNodeSchema = z5.object({
+  type: z5.literal("service"),
   output: outputsSchema,
-  inputSchema: z4.union([jsonSchema7ObjectSchema, jsonSchema7NullSchema]).default({ type: "null" }),
+  inputSchema: z5.union([jsonSchema7ObjectSchema, jsonSchema7NullSchema]).default({ type: "null" }),
   id: idSchema,
-  name: z4.string(),
-  version: z4.string(),
-  configuration: z4.any().optional(),
+  name: z5.string(),
+  version: z5.string(),
+  configuration: z5.any().optional(),
   configurationSchema: jsonSchema7Schema.default({ type: "null" }),
-  alias: z4.string().optional(),
-  ttl: z4.number().int().min(1).optional(),
-  retry: z4.number().int().min(1).optional(),
-  retryDelay: z4.number().int().min(100).optional(),
+  alias: z5.string().optional(),
+  ttl: z5.number().int().min(1).optional(),
+  retry: z5.number().int().min(1).optional(),
+  retryDelay: z5.number().int().min(100).optional(),
   meta: metaSchema
 });
-var catchNodeSchema = z4.object({
-  type: z4.literal("catch"),
+var catchNodeSchema = z5.object({
+  type: z5.literal("catch"),
   output: outputsSchema,
   id: idSchema,
-  subject: z4.string(),
+  subject: z5.string(),
   meta: metaSchema
 });
-var logicNodeSchema = z4.object({
-  type: z4.literal("logic"),
-  alias: z4.string().optional(),
+var logicNodeSchema = z5.object({
+  type: z5.literal("logic"),
+  alias: z5.string().optional(),
   output: outputsSchema,
   id: idSchema,
-  script: z4.string(),
-  concurrency: z4.boolean().default(true),
-  language: z4.enum(["javascript", "python", "typescript"]).default("javascript"),
-  maxExecutionTime: z4.number().int().min(0).default(1000),
+  script: z5.string(),
+  concurrency: z5.boolean().default(true),
+  language: z5.enum(["javascript", "python", "typescript"]).default("javascript"),
+  maxExecutionTime: z5.number().int().min(0).default(1000),
   meta: metaSchema
 });
-var orNodeSchema = z4.object({
+var orNodeSchema = z5.object({
   id: idSchema,
-  type: z4.literal("or"),
-  alias: z4.string().optional(),
+  type: z5.literal("or"),
+  alias: z5.string().optional(),
   output: outputsSchema,
   meta: metaSchema
 });
-var nodeSchema = z4.discriminatedUnion("type", [
+var nodeSchema = z5.discriminatedUnion("type", [
   entryNodeSchema,
   serviceNodeSchema,
   catchNodeSchema,
@@ -692,7 +827,7 @@ class NodesError extends ZodError {
   constructor(message, params, path = []) {
     super([
       {
-        code: z5.ZodIssueCode.custom,
+        code: z6.ZodIssueCode.custom,
         message,
         path,
         params
@@ -700,7 +835,7 @@ class NodesError extends ZodError {
     ]);
   }
 }
-var nodesSchema = z5.array(nodeSchema).transform((nodes) => {
+var nodesSchema = z6.array(nodeSchema).transform((nodes) => {
   const aliases = new Map;
   const names = new Map;
   let entryNode = null;
@@ -837,27 +972,27 @@ var nodesSchema = z5.array(nodeSchema).transform((nodes) => {
 });
 
 // ../helpers/src/protocol/command.ts
-var abortSchema = z6.object({
-  type: z6.literal("ABORT"),
-  reason: z6.string().optional()
+var abortSchema = z7.object({
+  type: z7.literal("ABORT"),
+  reason: z7.string().optional()
 });
-var nodeOptionsSchema = z6.object({
-  maxExecutions: z6.number().int().min(0).optional().default(10),
-  uploadUrl: z6.string().optional(),
-  streamUrl: z6.string().optional()
+var nodeOptionsSchema = z7.object({
+  maxExecutions: z7.number().int().min(0).optional().default(10),
+  uploadUrl: z7.string().optional(),
+  streamUrl: z7.string().optional()
 });
-var createNodesSchema = z6.object({
-  type: z6.literal("CREATE_NODES"),
+var createNodesSchema = z7.object({
+  type: z7.literal("CREATE_NODES"),
   nodes: nodesSchema,
-  input: z6.any(),
-  meta: z6.any(),
+  input: z7.any(),
+  meta: z7.any(),
   options: nodeOptionsSchema
 });
-var commandSchema = z6.union([abortSchema, createNodesSchema]);
+var commandSchema = z7.union([abortSchema, createNodesSchema]);
 
 // src/createAmqpConnection.ts
 import { connect } from "amqp-connection-manager";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/helpers.ts
 class RetryError extends Error {
@@ -874,17 +1009,20 @@ var OUTPUT_VALUE = Symbol("output_value");
 function isOutputValue(value) {
   return value !== null && typeof value === "object" && OUTPUT_VALUE in value;
 }
-function isRecord(data) {
+function isRecord2(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-async function unwrapResult(result, options) {
+async function unwrapResult(result, options, onDone) {
   if (isOutputValue(result)) {
     return {
-      value: await mapOutput(result.value, options),
+      value: await mapOutput({ value: result.value, options, onDone }),
       outputName: result[OUTPUT_VALUE]
     };
   }
-  return { value: await mapOutput(result, options), outputName: null };
+  return {
+    value: await mapOutput({ value: result, options, onDone }),
+    outputName: null
+  };
 }
 function createContextHelper(options) {
   const nodes = new Map(options.nodes.map((node) => [
@@ -904,10 +1042,10 @@ function createContextHelper(options) {
       return options.context.meta;
     },
     getData() {
-      return Array.from(nodes.values()).filter((result) => result.executionDate && isRecord(result.data)).toSorted((a, b) => a.executionDate.getTime() - b.executionDate.getTime()).reduce((acc, result) => ({
+      return Array.from(nodes.values()).filter((result) => result.executionDate && isRecord2(result.data)).toSorted((a, b) => a.executionDate.getTime() - b.executionDate.getTime()).reduce((acc, result) => ({
         ...acc,
         ...result.data
-      }), isRecord(options.context.input) ? { ...options.context.input } : {});
+      }), isRecord2(options.context.input) ? { ...options.context.input } : {});
     },
     toOutput(name, value) {
       return {
@@ -968,18 +1106,20 @@ function mapInput(data) {
 }
 
 // src/createAmqpConnection.ts
-var messageKeySchema = z7.string().transform((str) => deobfuscate(str)).pipe(z7.array(z7.string().uuid()).length(3)).transform((arr) => ({
+var messageKeySchema = z8.string().transform((str) => deobfuscate(str)).pipe(z8.tuple([z8.string().uuid(), z8.string().uuid(), z8.string().uuid()]).rest(z8.string())).transform((arr) => ({
   taskId: arr[0],
   serviceId: arr[1],
-  messageId: arr[2]
+  messageId: arr[2],
+  uploadUrl: arr[3] || undefined,
+  streamUrl: arr[4] || undefined
 }));
-var headerSchema = z7.object({
-  properties: z7.object({
-    correlationId: z7.string().uuid(),
-    headers: z7.object({
-      version: z7.string(),
-      taskId: z7.string().uuid(),
-      serviceId: z7.string().uuid()
+var headerSchema = z8.object({
+  properties: z8.object({
+    correlationId: z8.string().uuid(),
+    headers: z8.object({
+      version: z8.string(),
+      taskId: z8.string().uuid(),
+      serviceId: z8.string().uuid()
     })
   })
 }).transform((msg) => ({
@@ -988,11 +1128,11 @@ var headerSchema = z7.object({
   taskId: msg.properties.headers.taskId,
   serviceId: msg.properties.headers.serviceId
 }));
-var payloadSchema = z7.object({ content: z7.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z7.object({
+var payloadSchema = z8.object({ content: z8.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z8.object({
   context: contextSchema,
-  meta: z7.object({
+  meta: z8.object({
     nodes: nodesSchema,
-    state: z7.record(z7.any()),
+    state: z8.record(z8.any()),
     options: nodeOptionsSchema
   })
 }));
@@ -1010,7 +1150,7 @@ function createConnection({
   const queue = `${url.username}@${version}`;
   const exchange = url.username;
   const connection = connect(url.toString());
-  const connectedPromise = new Promise((resolve, reject) => {
+  const connectedPromise = new Promise((resolve2, reject) => {
     const unsubscribe = () => {
       clearTimeout(timeout);
       connection.removeListener("connect", handleConnect);
@@ -1021,7 +1161,7 @@ function createConnection({
     }, connectionTimeout);
     const handleConnect = () => {
       unsubscribe();
-      resolve();
+      resolve2();
     };
     const handleConnectFailed = ({ err }) => {
       unsubscribe();
@@ -1058,6 +1198,7 @@ function createConnection({
       channel.nack(message, false, false);
       return;
     }
+    const donePromises = [];
     let removeActiveMessage = () => {
     };
     try {
@@ -1107,7 +1248,7 @@ function createConnection({
           deferred = true;
           deferredReason = reason || null;
           ack();
-          return obfuscate(taskId, serviceId, messageId);
+          return obfuscate(taskId, serviceId, messageId, payload.meta.options.uploadUrl ?? "", payload.meta.options.streamUrl ?? "");
         }
       });
       if (isMessageHandlerGenerator(messageHandler)) {
@@ -1119,7 +1260,9 @@ function createConnection({
             deferred = false;
             console.warn("returning a value in a deferred message resets the deferred status");
           }
-          const { value, outputName } = await unwrapResult(result, payload.meta.options);
+          const donePromise = createRemotePromise();
+          donePromises.push(donePromise);
+          const { value, outputName } = await unwrapResult(result, payload.meta.options, donePromise.resolve);
           if (!done || typeof value !== "undefined") {
             publish({
               messageId,
@@ -1136,7 +1279,9 @@ function createConnection({
       } else {
         const result = await messageHandler(extendedContext);
         ack();
-        const { value, outputName } = await unwrapResult(result, payload.meta.options);
+        const donePromise = createRemotePromise();
+        donePromises.push(donePromise);
+        const { value, outputName } = await unwrapResult(result, payload.meta.options, donePromise.resolve);
         if (deferred && value) {
           console.warn("returning a value in a deferred message resets the deferred status");
           deferred = false;
@@ -1151,14 +1296,19 @@ function createConnection({
           });
         }
       }
-      setImmediate(() => publish({
-        messageId,
-        taskId,
-        serviceId,
-        data: deferredReason,
-        deferred,
-        done: !deferred
-      }));
+      setImmediate(async () => {
+        if (!deferred) {
+          await Promise.allSettled(donePromises);
+        }
+        publish({
+          messageId,
+          taskId,
+          serviceId,
+          data: deferredReason,
+          deferred,
+          done: !deferred
+        });
+      });
     } catch (error) {
       if (error instanceof RetryError) {
         const properties = {
@@ -1213,26 +1363,39 @@ function createConnection({
     },
     open: () => connectedPromise.then(() => api),
     async act(messageKey, actor) {
-      const { taskId, serviceId, messageId } = messageKeySchema.parse(messageKey);
+      const { taskId, serviceId, messageId, ...options } = messageKeySchema.parse(messageKey);
       if (activeMessages.has(messageId)) {
         throw new Error("Cannot send deferred message while callback handler is still running");
       }
+      const donePromises = [];
       await actor({
-        sendToOutput(outputName, data) {
+        async sendToOutput(outputName, data) {
+          const donePromise = createRemotePromise();
+          donePromises.push(donePromise);
           publish({
             messageId,
             taskId,
             serviceId,
-            data,
+            data: await mapOutput({
+              value: data,
+              options,
+              onDone: donePromise.resolve
+            }),
             outputName
           });
         },
-        send(data) {
+        async send(data) {
+          const donePromise = createRemotePromise();
+          donePromises.push(donePromise);
           publish({
             messageId,
             taskId,
             serviceId,
-            data
+            data: await mapOutput({
+              value: data,
+              options,
+              onDone: donePromise.resolve
+            })
           });
         },
         abort(error) {
@@ -1249,27 +1412,30 @@ function createConnection({
           });
         }
       });
-      setImmediate(() => publish({
-        messageId,
-        taskId,
-        serviceId,
-        done: true
-      }));
+      setImmediate(async () => {
+        await Promise.allSettled(donePromises);
+        publish({
+          messageId,
+          taskId,
+          serviceId,
+          done: true
+        });
+      });
     }
   };
   return api;
 }
 
 // src/index.ts
-var connectionOptionsSchema = z8.object({
-  url: z8.union([
-    z8.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
-    z8.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+var connectionOptionsSchema = z9.object({
+  url: z9.union([
+    z9.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
+    z9.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
   ]),
-  version: z8.string(),
-  silent: z8.boolean().optional(),
-  prefetch: z8.number().int().optional(),
-  connectionTimeout: z8.number().positive().default(3000)
+  version: z9.string(),
+  silent: z9.boolean().optional(),
+  prefetch: z9.number().int().optional(),
+  connectionTimeout: z9.number().positive().default(3000)
 });
 function createService(optionsOrVersion, optionalMessageHandler) {
   let options;
@@ -1303,5 +1469,5 @@ export {
   RequenceFile
 };
 
-//# debugId=566CE181EC007E2D64756E2164756E21
+//# debugId=41E805E9FDA0F22664756E2164756E21
 //# sourceMappingURL=index.js.map