@requence/service 0.7.1

package/build/index.js

@@ -0,0 +1,1229 @@
+import {
+  deobfuscate,
+  obfuscate
+} from "./chunk-6w7td62p.js";
+
+// src/index.ts
+import fs from "node:fs";
+
+// ../helpers/src/utils/guards.ts
+import { z } from "zod/v4";
+var recordSchema = z.record(z.string(), z.unknown());
+function isRecord(data) {
+  return recordSchema.safeParse(data).success;
+}
+var uuidSchema = z.uuid();
+
+// ../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);
+}
+
+class AbortMapData extends Error {
+}
+function mapData(data, visitors) {
+  let aborted = false;
+  const traverseData = (data2, path) => {
+    if (aborted) {
+      return data2;
+    }
+    try {
+      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 (typeof data2 === "symbol") {
+        return notUndefined(visitors.Symbol?.(data2, path), data2);
+      }
+      if (typeof data2 === "function") {
+        return notUndefined(visitors.Function?.(data2, path), data2);
+      }
+      if (isRecord(data2)) {
+        return resolve(visitors.Object?.(structuredClone(data2), path), (resolvedData) => {
+          const nextData = resolvedData ?? data2;
+          if (!isRecord(nextData)) {
+            return nextData;
+          }
+          const entries = Object.entries(nextData).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);
+        });
+      }
+      if (typeof data2 === "object" && data2) {
+        return notUndefined(visitors.Object?.(data2, path), data2);
+      }
+      return data2;
+    } catch (error) {
+      if (error instanceof AbortMapData) {
+        aborted = true;
+        return data2;
+      }
+      throw error;
+    }
+  };
+  return traverseData(data, []);
+}
+mapData.abort = () => {
+  throw new AbortMapData;
+};
+
+// ../helpers/src/utils/requenceCallback.ts
+import { z as z2 } from "zod/v4";
+var callbackObjectSchema = z2.object({
+  sourceId: z2.string(),
+  outputName: z2.string().nullable(),
+  propertyPath: z2.array(z2.union([z2.string(), z2.int()])),
+  callbackId: z2.uuid(),
+  __REQUENCE_type: z2.literal("RequenceCallback")
+});
+function isCallbackObject(data) {
+  return callbackObjectSchema.safeParse(data).success;
+}
+function createCallback(callback) {
+  const { promise, resolve: resolve2 } = Promise.withResolvers();
+  const executor = (arg) => {
+    resolve2(arg);
+    callback?.(arg);
+  };
+  return Object.assign(executor, {
+    response() {
+      return promise;
+    }
+  });
+}
+
+// ../helpers/src/files/fileObject.ts
+import { z as z3 } from "zod/v4";
+var fileObjectSchema = z3.object({
+  size: z3.int().positive(),
+  mime: z3.string(),
+  url: z3.url(),
+  __REQUENCE_type: z3.literal("RequenceFile")
+});
+function toFileObject(fileInfo) {
+  return {
+    ...fileInfo,
+    __REQUENCE_type: "RequenceFile"
+  };
+}
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
+}
+
+// ../helpers/src/files/RequenceFile.ts
+class RequenceFile {
+  #data;
+  #file = null;
+  constructor(blobParts, options) {
+    this.#data = new Blob(blobParts, options);
+  }
+  static fromFileObject(file) {
+    const instance = new this([], { type: "x/x" });
+    instance.#file = file;
+    return instance;
+  }
+  get fileObject() {
+    return this.#file;
+  }
+  get size() {
+    return this.#file?.size ?? this.#data.size;
+  }
+  get mimeType() {
+    return this.#file?.mime ?? this.#data.type;
+  }
+  get mainMimeType() {
+    return this.mimeType.split("/")[0];
+  }
+  get subMimeType() {
+    return this.mimeType.split("/")[1];
+  }
+  async text() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.text());
+    }
+    return this.#data.text();
+  }
+  async json() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.json());
+    }
+    return JSON.parse(await this.text());
+  }
+  async blob() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.blob());
+    }
+    return this.#data;
+  }
+  async arrayBuffer() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.arrayBuffer());
+    }
+    return this.#data.arrayBuffer();
+  }
+  toString() {
+    return `RequenceFile<${this.mimeType}>`;
+  }
+  toJSON() {
+    return `RequenceFile<${this.mimeType}>`;
+  }
+}
+
+// ../helpers/src/files/RequenceStream.ts
+class RequenceStream {
+  #data;
+  #stream = null;
+  #options;
+  constructor(stream, options) {
+    this.#data = stream;
+    this.#options = options;
+  }
+  static fromStreamObject(stream) {
+    const instance = new this(null, {
+      type: "x/x"
+    });
+    instance.#stream = stream;
+    return instance;
+  }
+  get streamObject() {
+    return this.#stream;
+  }
+  get mimeType() {
+    return this.#stream?.mime ?? this.#options.type;
+  }
+  get mainMimeType() {
+    return this.mimeType.split("/")[0];
+  }
+  get subMimeType() {
+    return this.mimeType.split("/")[1];
+  }
+  stream() {
+    if (this.#stream) {
+      const { readable, writable } = new TransformStream;
+      fetch(this.#stream.url).then((response) => response.body?.pipeTo(writable));
+      return readable;
+    }
+    return this.#data;
+  }
+  asyncIterable() {
+    const reader = this.stream().getReader();
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            return reader.read();
+          },
+          async return() {
+            reader.cancel();
+            reader.releaseLock();
+            return { done: true, value: null };
+          }
+        };
+      }
+    };
+  }
+  toString() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
+  toJSON() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
+}
+
+// ../helpers/src/files/streamObject.ts
+import { z as z4 } from "zod/v4";
+var streamObjectSchema = z4.object({
+  mime: z4.string(),
+  url: z4.string().url(),
+  __REQUENCE_type: z4.literal("RequenceStream")
+});
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
+function toStreamObject(streamInfo) {
+  return {
+    ...streamInfo,
+    __REQUENCE_type: "RequenceStream"
+  };
+}
+
+// ../helpers/src/files/mapOutput.ts
+async function upload(uploadUrl, body, signal, contentType) {
+  const uploadResponse = await fetch(uploadUrl, {
+    method: "POST",
+    signal,
+    headers: contentType ? {
+      "Content-Type": contentType
+    } : {},
+    body
+  });
+  const data = await uploadResponse.json();
+  if (!data || typeof data !== "object") {
+    throw new Error("invalid upload response");
+  }
+  return toFileObject(data);
+}
+async function stream(streamUrl, stream2, signal, contentType) {
+  const [testStream, dataStream] = stream2.tee();
+  const reader = testStream.getReader();
+  const dataPromise = reader.read().then(({ done: done2 }) => {
+    if (done2) {
+      throw new Error("No streaming date received");
+    }
+    reader.cancel();
+  });
+  const streamResponse = await fetch(streamUrl, {
+    method: "POST",
+    signal,
+    headers: contentType ? { "Content-Type": contentType } : {}
+  });
+  const data = await streamResponse.json();
+  if (!data || typeof data !== "object") {
+    throw new Error("invalid stream response");
+  }
+  const { mime, url } = data;
+  await dataPromise;
+  const done = fetch(url, {
+    method: "POST",
+    signal,
+    duplex: "half",
+    body: dataStream
+  });
+  return [toStreamObject({ mime, url }), done];
+}
+async function mapOutput(params) {
+  const streamPromises = [];
+  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 (params.options.uploadUrl) {
+          try {
+            if (obj instanceof Blob) {
+              return await upload(params.options.uploadUrl, obj, params.signal, obj.type);
+            }
+            if (obj instanceof RequenceFile) {
+              return await upload(params.options.uploadUrl, await obj.blob(), params.signal, obj.mimeType);
+            }
+          } catch (error) {
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            params.onFail?.(error);
+            return null;
+          }
+        } else {
+          params.onSkip?.();
+          return null;
+        }
+      }
+      if (obj instanceof Response || obj instanceof RequenceStream) {
+        if (obj instanceof RequenceStream && obj.streamObject) {
+          return obj.streamObject;
+        }
+        if (params.options.streamUrl) {
+          try {
+            if (obj instanceof Response && obj.body) {
+              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(params.options.streamUrl, obj.stream(), params.signal, obj.mimeType);
+              streamPromises.push(streamPromise);
+              return streamObject;
+            }
+          } catch (error) {
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            params.onFail?.(error);
+            return null;
+          }
+        } else {
+          params.onSkip?.();
+          return null;
+        }
+      }
+    }
+  });
+  Promise.allSettled(streamPromises).then(() => params.onDone?.());
+  return mapped;
+}
+
+// ../helpers/src/utils/resolveRequenceTypes.ts
+function resolveRequenceTypes(data, onCallback) {
+  return mapData(data, {
+    Object(obj) {
+      if (isFileObject(obj)) {
+        return RequenceFile.fromFileObject(obj);
+      }
+      if (isStreamObject(obj)) {
+        return RequenceStream.fromStreamObject(obj);
+      }
+      if (isCallbackObject(obj)) {
+        return (arg) => {
+          onCallback?.({ ...obj, arg });
+        };
+      }
+    }
+  });
+}
+
+// src/createAmqpConnection.ts
+import { connect } from "amqp-connection-manager";
+import { z as z5 } from "zod/v4";
+
+// src/errors.ts
+class RequenceConnectionError extends Error {
+}
+
+// src/helpers.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+class RetryError extends Error {
+  delay;
+  constructor(delay) {
+    super();
+    this.delay = delay;
+  }
+}
+
+class SkipError extends Error {
+}
+
+class AbortError extends Error {
+}
+var OUTPUT_VALUE = Symbol("output_value");
+function isOutputValue(value) {
+  return value !== null && typeof value === "object" && OUTPUT_VALUE in value;
+}
+function processData(params) {
+  return mapOutput({
+    value: mapData(params.data, {
+      Function(data, path) {
+        return {
+          ...params.onCallback(data),
+          outputName: params.outputName,
+          propertyPath: path,
+          __REQUENCE_type: "RequenceCallback"
+        };
+      }
+    }),
+    options: params.options,
+    onDone: params.onDone
+  });
+}
+async function unwrapResult(params) {
+  if (isOutputValue(params.result)) {
+    return {
+      value: await processData({
+        outputName: params.result[OUTPUT_VALUE],
+        data: params.result.value,
+        options: params.options,
+        onDone: params.onDone,
+        onCallback: params.onCallback
+      }),
+      outputName: params.result[OUTPUT_VALUE]
+    };
+  }
+  return {
+    value: await processData({
+      outputName: null,
+      data: params.result,
+      options: params.options,
+      onDone: params.onDone,
+      onCallback: params.onCallback
+    }),
+    outputName: null
+  };
+}
+function createContextHelper(options) {
+  const terminatePromise = Promise.withResolvers();
+  const abortController = new AbortController;
+  terminatePromise.promise.then(() => abortController.abort());
+  const terminated = Object.assign(terminatePromise.promise, {
+    signal: abortController.signal
+  });
+  return [
+    {
+      taskId: options.taskId,
+      input: resolveRequenceTypes(options.input, options.onCallback),
+      configuration: resolveRequenceTypes(options.configuration, () => {
+        throw new Error("configuration may not have callbacks");
+      }),
+      toOutput(name, value) {
+        return {
+          [OUTPUT_VALUE]: name,
+          value
+        };
+      },
+      defer: options.onDefer,
+      debug: {
+        log(...data) {
+          options.onLog("log", data);
+        },
+        info(...data) {
+          options.onLog("info", data);
+        },
+        warn(...data) {
+          options.onLog("warn", data);
+        },
+        error(...data) {
+          options.onLog("error", data);
+        }
+      },
+      retry(delay) {
+        throw new RetryError(delay);
+      },
+      abort(reason) {
+        throw new AbortError(reason);
+      },
+      skip() {
+        throw new SkipError;
+      },
+      terminated
+    },
+    terminatePromise
+  ];
+}
+var handlerStorage = new AsyncLocalStorage;
+
+// src/mapInput.ts
+function mapInput(data) {
+  return mapData(data, {
+    Object(obj) {
+      if (isFileObject(obj)) {
+        return RequenceFile.fromFileObject(obj);
+      }
+      if (isStreamObject(obj)) {
+        return RequenceStream.fromStreamObject(obj);
+      }
+    }
+  });
+}
+
+// src/createAmqpConnection.ts
+var messageKeySchema = z5.string().transform((str) => deobfuscate(str)).pipe(z5.tuple([z5.uuid(), z5.uuid()]).rest(z5.string())).transform((arr) => ({
+  taskId: arr[0],
+  messageId: arr[1],
+  uploadUrl: arr[2] || undefined,
+  streamUrl: arr[3] || undefined
+}));
+var headerSchema = z5.object({
+  properties: z5.object({
+    correlationId: z5.uuid(),
+    headers: z5.object({
+      taskId: z5.uuid(),
+      mode: z5.enum(["LINEAR", "CONTINUOUS"]).default("LINEAR")
+    })
+  })
+}).transform((msg) => ({
+  messageId: msg.properties.correlationId,
+  taskId: msg.properties.headers.taskId,
+  mode: msg.properties.headers.mode
+}));
+var payloadSchema = z5.object({ content: z5.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z5.object({
+  input: z5.unknown(),
+  configuration: z5.unknown(),
+  options: z5.object({
+    uploadUrl: z5.url().optional(),
+    streamUrl: z5.url().optional()
+  })
+}));
+var backchannelMessageSchema = z5.object({
+  content: z5.instanceof(Buffer).transform((content) => JSON.parse(content.toString())).pipe(z5.discriminatedUnion("type", [
+    z5.object({
+      type: z5.literal("stop")
+    }),
+    z5.object({
+      type: z5.literal("callback"),
+      callbackId: z5.uuid(),
+      arg: z5.any()
+    })
+  ])),
+  properties: z5.object({
+    correlationId: z5.string()
+  })
+}).transform((message) => ({
+  payload: message.content,
+  messageId: message.properties.correlationId
+}));
+var abortSymbol = Symbol();
+var connectionOptionsSchema = z5.object({
+  url: z5.union([
+    z5.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
+    z5.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+  ]),
+  version: z5.string(),
+  devOverlay: z5.string().optional(),
+  silent: z5.boolean().optional(),
+  prefetch: z5.number().int().optional(),
+  connectionTimeout: z5.number().positive().default(3000),
+  connectionOptions: z5.any().optional()
+});
+function isMessageHandlerGenerator(handler) {
+  return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
+}
+var activeMessages = new Map;
+function createConnection({
+  url,
+  version,
+  prefetch = 1,
+  silent = false,
+  connectionTimeout,
+  connectionOptions,
+  devOverlay = ""
+}, messageHandler) {
+  const baseQueue = `${url.username}@${version}`;
+  const queue = devOverlay ? `${baseQueue}-dev-overlay-${devOverlay}` : baseQueue;
+  const exchange = url.username;
+  const connection = connect(url.toString(), { connectionOptions });
+  const connectedPromise = new Promise((resolve2, reject) => {
+    const unsubscribe = () => {
+      clearTimeout(timeout);
+      connection.removeListener("connect", handleConnect);
+      connection.removeListener("connectFailed", handleConnectFailed);
+    };
+    const timeout = setTimeout(() => {
+      handleConnectFailed({
+        err: new RequenceConnectionError("Requence connection timeout")
+      });
+    }, connectionTimeout);
+    const handleConnect = () => {
+      unsubscribe();
+      resolve2();
+    };
+    const handleConnectFailed = ({ err }) => {
+      unsubscribe();
+      if (err.message.startsWith("Handshake terminated by server: 403 (ACCESS-REFUSED)")) {
+        reject(new RequenceConnectionError("Invalid service credentials"));
+      } else {
+        reject(err);
+      }
+    };
+    connection.addListener("connect", handleConnect);
+    connection.addListener("connectFailed", handleConnectFailed);
+  });
+  const connectionId = crypto.randomUUID();
+  const backchannelQueue = `${baseQueue}-backchannel-${connectionId}`;
+  const generatorTerminators = new Map;
+  const callbacks = new Map;
+  const channelWrapper = connection.createChannel({
+    async setup(channel) {
+      if (devOverlay) {
+        await channel.assertQueue(queue);
+        await channel.bindQueue(queue, "service", queue);
+      }
+      await channel.checkExchange(exchange);
+      await channel.checkExchange(`${exchange}-retry`);
+      await channel.checkQueue(queue);
+      await channel.prefetch(prefetch);
+      await channel.assertQueue(backchannelQueue, {
+        exclusive: true
+      });
+      await channel.bindQueue(backchannelQueue, "service", backchannelQueue);
+      await channel.consume(backchannelQueue, async (message) => {
+        const result = backchannelMessageSchema.safeParse(message);
+        if (!result.success) {
+          return;
+        }
+        const backchannelMessage = result.data;
+        switch (backchannelMessage.payload.type) {
+          case "stop": {
+            generatorTerminators.get(backchannelMessage.messageId)?.("task stopped");
+            break;
+          }
+          case "callback": {
+            callbacks.get(backchannelMessage.payload.callbackId)?.(backchannelMessage.payload.arg);
+            break;
+          }
+        }
+      }, {
+        noAck: true
+      });
+    }
+  });
+  const publish = ({
+    data,
+    outputName,
+    messageId,
+    priority,
+    ...headers
+  }) => channelWrapper.publish(exchange, "", Buffer.from(JSON.stringify(data ?? null)), {
+    correlationId: messageId,
+    contentType: "application/json",
+    persistent: true,
+    priority,
+    headers: {
+      outputName: outputName ?? null,
+      connectionId,
+      libVersion: "javascript@0.7.1",
+      ...headers
+    }
+  });
+  channelWrapper.addSetup(async (channel) => {
+    channel.consume(queue, async (message) => {
+      if (!message) {
+        return;
+      }
+      let publishIndex = 0;
+      let acked = false;
+      let terminated = false;
+      const donePromises = [];
+      const registeredCallbackIds = new Set;
+      let resolveActiveMessage = () => {};
+      const { messageId, taskId, mode } = headerSchema.parse(message);
+      try {
+        let deferred = false;
+        let deferredReason = null;
+        const messageExecution = Promise.withResolvers();
+        activeMessages.set(messageId, messageExecution.promise);
+        messageExecution.promise.then(() => {
+          activeMessages.delete(messageId);
+        });
+        resolveActiveMessage = () => {
+          messageExecution.resolve();
+        };
+        const payload = payloadSchema.parse(message);
+        const [extendedContext, terminatePromise] = createContextHelper({
+          taskId,
+          input: mapInput(payload.input),
+          configuration: mapInput(payload.configuration),
+          onLog(debugMethod, data) {
+            publish({
+              index: publishIndex++,
+              version,
+              messageId,
+              taskId,
+              data,
+              debugMethod,
+              priority: message.properties.priority,
+              debug: true
+            });
+          },
+          onDefer(reason) {
+            deferred = true;
+            deferredReason = reason || null;
+            return obfuscate(taskId, messageId, payload.options.uploadUrl ?? "", payload.options.streamUrl ?? "");
+          },
+          onCallback(params) {
+            publish({
+              index: 0,
+              version,
+              taskId,
+              messageId,
+              data: params.arg,
+              outputName: params.outputName,
+              connectionId: params.sourceId,
+              callbackId: params.callbackId,
+              propertyPath: params.propertyPath
+            });
+          }
+        });
+        await publish({
+          index: publishIndex++,
+          version,
+          messageId,
+          taskId,
+          priority: message.properties.priority,
+          begin: true
+        });
+        if (isMessageHandlerGenerator(messageHandler) && mode === "CONTINUOUS") {
+          channel.ack(message);
+          acked = true;
+          const generator = messageHandler(extendedContext);
+          const terminationPromise = Promise.withResolvers();
+          generatorTerminators.set(messageId, (reason) => {
+            terminated = true;
+            generator.return().catch((error) => {
+              if (terminated && error instanceof Error && error.name === "AbortError" && !(error instanceof AbortError)) {
+                return;
+              }
+              throw error;
+            });
+            terminationPromise.resolve(abortSymbol);
+            terminatePromise.resolve(reason);
+          });
+          await handlerStorage.run(extendedContext, async () => {
+            while (true) {
+              const nextPromise = Promise.resolve(generator.next()).then((r) => r, (error) => {
+                if (terminated && error instanceof Error && error.name === "AbortError" && !(error instanceof AbortError)) {
+                  return { value: undefined, done: true };
+                }
+                throw error;
+              });
+              const next = await Promise.race([
+                terminationPromise.promise,
+                nextPromise
+              ]);
+              if (next === abortSymbol) {
+                break;
+              }
+              const { value: result, done } = next;
+              if (deferred) {
+                deferred = false;
+                console.warn("returning a value in a deferred message resets the deferred status");
+              }
+              const donePromise = Promise.withResolvers();
+              donePromises.push(donePromise.promise);
+              const { value, outputName } = await unwrapResult({
+                result,
+                options: payload.options,
+                onDone: donePromise.resolve,
+                onCallback: (callback) => {
+                  const callbackId = crypto.randomUUID();
+                  registeredCallbackIds.add(callbackId);
+                  callbacks.set(callbackId, callback);
+                  return {
+                    sourceId: connectionId,
+                    callbackId
+                  };
+                }
+              });
+              if (!done || typeof value !== "undefined") {
+                publish({
+                  index: publishIndex++,
+                  version,
+                  messageId,
+                  taskId,
+                  data: value,
+                  priority: message.properties.priority,
+                  outputName
+                });
+              }
+              if (done) {
+                break;
+              }
+            }
+          });
+        } else {
+          const result = await handlerStorage.run(extendedContext, () => messageHandler(extendedContext));
+          const donePromise = Promise.withResolvers();
+          donePromises.push(donePromise.promise);
+          const { value, outputName } = await unwrapResult({
+            result,
+            options: payload.options,
+            onDone: donePromise.resolve,
+            onCallback: () => {
+              throw new Error("callbacks can only be used in generator functions");
+            }
+          });
+          if (deferred && value) {
+            console.warn("returning a value in a deferred message resets the deferred status");
+            deferred = false;
+          }
+          if (!deferred || value) {
+            publish({
+              index: publishIndex++,
+              version,
+              messageId,
+              taskId,
+              data: value,
+              priority: message.properties.priority,
+              outputName
+            });
+          }
+        }
+        await new Promise((resolve2) => {
+          setImmediate(async () => {
+            if (!deferred) {
+              await Promise.allSettled(donePromises);
+            }
+            await publish({
+              index: publishIndex++,
+              version,
+              messageId,
+              taskId,
+              data: deferredReason,
+              priority: message.properties.priority,
+              deferred,
+              done: !deferred
+            });
+            if (!acked) {
+              channel.ack(message);
+            }
+            resolve2();
+          });
+        });
+      } catch (error) {
+        if (error instanceof SkipError) {
+          if (!acked) {
+            channel.nack(message);
+          }
+          return;
+        }
+        if (error instanceof RetryError) {
+          if (!acked) {
+            channel.ack(message);
+          }
+          const properties = {
+            ...message.properties,
+            expiration: error.delay || 1000
+          };
+          channel.publish(`${exchange}-retry`, version, message.content, properties);
+          return;
+        }
+        if (error instanceof AbortError && error.message.length > 0) {
+          if (!acked) {
+            channelWrapper.ack(message);
+          }
+          channelWrapper.publish(`${exchange}-retry`, "operator", error.message, {
+            ...message.properties,
+            contentType: "text/plain",
+            headers: {
+              ...message.properties.headers,
+              index: publishIndex++,
+              libVersion: "javascript@0.7.1",
+              abort: true
+            }
+          });
+          return;
+        }
+        if (terminated && error instanceof Error && error.name === "AbortError" && !(error instanceof AbortError)) {
+          if (!acked) {
+            channel.ack(message);
+          }
+          return;
+        }
+        if (error instanceof Error) {
+          if (!silent) {
+            console.error("Encountered an error inside service handler:");
+            console.error(error);
+          }
+          if (!acked) {
+            channel.ack(message);
+          }
+          channel.publish(`${exchange}-retry`, "operator", message.content, {
+            ...message.properties,
+            headers: {
+              ...message.properties.headers,
+              version,
+              exception: true,
+              index: publishIndex++,
+              libVersion: "javascript@0.7.1",
+              "error-message": error.message || "error in service handler"
+            }
+          });
+          return;
+        }
+      } finally {
+        generatorTerminators.delete(messageId);
+        registeredCallbackIds.forEach((id) => callbacks.delete(id));
+        resolveActiveMessage();
+      }
+    });
+  });
+  const activeMessageKeys = new Set;
+  const api = {
+    close: async () => {
+      await channelWrapper.close();
+      await connection.close();
+    },
+    open: () => connectedPromise.then(() => api),
+    async act(messageKey, actor) {
+      if (activeMessageKeys.has(messageKey)) {
+        throw new Error("a defer key can only be used once");
+      }
+      activeMessageKeys.add(messageKey);
+      let publishIndex = 0;
+      const { taskId, messageId, ...options } = messageKeySchema.parse(messageKey);
+      const activeMessage = async () => {
+        if (activeMessages.has(messageId)) {
+          await activeMessages.get(messageId);
+        }
+      };
+      const registeredCallbackIds = new Set;
+      const donePromises = [];
+      const sendApi = {
+        async sendToOutput(outputName, data) {
+          await activeMessage();
+          const donePromise = Promise.withResolvers();
+          donePromises.push(donePromise.promise);
+          donePromises.push(publish({
+            index: publishIndex++,
+            version,
+            messageId,
+            taskId,
+            data: await processData({
+              outputName,
+              data,
+              options,
+              onDone: donePromise.resolve,
+              onCallback: (callback) => {
+                const callbackId = crypto.randomUUID();
+                registeredCallbackIds.add(callbackId);
+                callbacks.set(callbackId, callback);
+                return {
+                  sourceId: connectionId,
+                  callbackId
+                };
+              }
+            }),
+            outputName
+          }));
+        },
+        async send(data) {
+          await activeMessage();
+          const donePromise = Promise.withResolvers();
+          donePromises.push(donePromise.promise);
+          donePromises.push(publish({
+            index: publishIndex++,
+            version,
+            messageId,
+            taskId,
+            data: await processData({
+              outputName: null,
+              data,
+              options,
+              onDone: donePromise.resolve,
+              onCallback: (callback) => {
+                const callbackId = crypto.randomUUID();
+                registeredCallbackIds.add(callbackId);
+                callbacks.set(callbackId, callback);
+                return {
+                  sourceId: connectionId,
+                  callbackId
+                };
+              }
+            })
+          }));
+        },
+        async abort(error) {
+          await activeMessage();
+          channelWrapper.publish(`${exchange}-retry`, "operator", error instanceof Error ? error.message : error, {
+            persistent: true,
+            correlationId: messageId,
+            expiration: 0,
+            priority: 0,
+            contentType: "text/plain",
+            headers: {
+              taskId,
+              libVersion: "javascript@0.7.1",
+              index: publishIndex++,
+              abort: true
+            }
+          });
+        }
+      };
+      const result = await actor(sendApi);
+      if (result != null && typeof result === "object" && ((Symbol.asyncIterator in result) || (Symbol.iterator in result))) {
+        const iterable = result;
+        for await (const value of iterable) {
+          if (value !== undefined) {
+            await sendApi.send(value);
+          }
+        }
+      } else if (result !== undefined) {
+        await sendApi.send(result);
+      }
+      await new Promise((resolve2) => setImmediate(resolve2));
+      await activeMessage();
+      while (true) {
+        const promiseCount = donePromises.length;
+        await Promise.allSettled(donePromises);
+        if (promiseCount === donePromises.length) {
+          break;
+        }
+      }
+      registeredCallbackIds.forEach((id) => callbacks.delete(id));
+      await publish({
+        index: publishIndex++,
+        version,
+        messageId,
+        taskId,
+        done: true
+      });
+      activeMessageKeys.delete(messageKey);
+    }
+  };
+  return api;
+}
+// src/utils.ts
+function isAsyncIterable(iterable) {
+  return typeof iterable[Symbol.asyncIterator] === "function";
+}
+function wrapIterable(iterable) {
+  const context = handlerStorage.getStore();
+  if (!context) {
+    return iterable;
+  }
+  let terminated = false;
+  context.terminated.then(() => {
+    terminated = true;
+  });
+  if (isAsyncIterable(iterable)) {
+    return {
+      [Symbol.asyncIterator]() {
+        const iterator = iterable[Symbol.asyncIterator]();
+        return {
+          async next() {
+            const result = await Promise.race([
+              context.terminated,
+              iterator.next()
+            ]);
+            if (terminated) {
+              return { done: true, value: undefined };
+            }
+            return result;
+          }
+        };
+      }
+    };
+  }
+  return {
+    [Symbol.iterator]() {
+      const iterator = iterable[Symbol.iterator]();
+      return {
+        next() {
+          if (terminated) {
+            return { done: true, value: undefined };
+          }
+          const result = iterator.next();
+          return result;
+        }
+      };
+    }
+  };
+}
+function asyncEventEmitter(initial = []) {
+  const context = handlerStorage.getStore();
+  let terminated = false;
+  context?.terminated.then(() => {
+    terminated = true;
+  });
+  let resolve2;
+  const initialValues = structuredClone(initial);
+  return {
+    push: (value) => {
+      if (resolve2) {
+        resolve2(value);
+      } else {
+        initialValues.push(value);
+      }
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        async next() {
+          if (initialValues.length > 0) {
+            return { value: initialValues.shift(), done: false };
+          }
+          const defer = Promise.withResolvers();
+          resolve2 = defer.resolve;
+          if (context) {
+            const value = await Promise.race([
+              defer.promise,
+              context.terminated
+            ]);
+            return terminated ? { done: true, value: undefined } : { done: false, value };
+          }
+          return { value: await defer.promise, done: false };
+        }
+      };
+    }
+  };
+}
+
+// src/index.ts
+var pkgJson;
+function loadPkgJson() {
+  if (!pkgJson) {
+    pkgJson = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+  }
+  return pkgJson;
+}
+function createService(optionsOrVersion, optionalMessageHandler) {
+  let options;
+  let messageHandler;
+  if (typeof optionsOrVersion === "string") {
+    options = {
+      version: optionsOrVersion
+    };
+    messageHandler = optionalMessageHandler;
+  } else {
+    options = optionsOrVersion;
+    messageHandler = optionalMessageHandler;
+  }
+  let token = options.accessToken ?? process.env.REQUENCE_SERVICE_ACCESS_TOKEN ?? process.env.REQUENCE_ACCESS_TOKEN;
+  if (!token) {
+    try {
+      const pkgJson2 = loadPkgJson();
+      token = pkgJson2.requence?.service?.accessToken ?? pkgJson2.requence?.accessToken;
+    } catch {}
+  }
+  let devToken = options.devToken ?? process.env.REQUENCE_SERVICE_DEV_TOKEN ?? process.env.REQUENCE_DEV_TOKEN;
+  if (!devToken) {
+    try {
+      const pkgJson2 = loadPkgJson();
+      devToken = pkgJson2.requence?.service?.devToken ?? pkgJson2.requence?.devToken;
+    } catch {}
+  }
+  if (!token) {
+    throw new Error("no access token provided");
+  }
+  const parts = deobfuscate(token);
+  if (parts.length < 2 || parts[0] !== "service") {
+    throw new Error("invalid access token");
+  }
+  const url = parts[1];
+  let devOverlay;
+  if (devToken) {
+    const devParts = deobfuscate(devToken);
+    if (devParts[0] !== "api") {
+      throw new Error("invalid dev token: please provide a personal access token");
+    }
+    if (devParts[2] !== parts[2]) {
+      throw new Error("invalid dev token: access token and dev token belong to different requence instances");
+    }
+    devOverlay = devParts[1];
+  }
+  return createConnection(connectionOptionsSchema.parse({
+    ...options,
+    url,
+    devOverlay
+  }), messageHandler);
+}
+export {
+  wrapIterable,
+  createService,
+  createCallback,
+  asyncEventEmitter,
+  RequenceStream,
+  RequenceFile,
+  RequenceConnectionError
+};
+
+//# debugId=DF5C6A6E1370BBD564756E2164756E21
+//# sourceMappingURL=index.js.map