@requence/service 1.0.0-alpha.5 → 1.0.0-alpha.50

package/build/index.js

@@ -1,611 +1,418 @@
 import {
-  clone,
-  createObjectProxy,
   deobfuscate,
   obfuscate
-} from "./chunk-0x9092n4.js";
+} from "./chunk-6w7td62p.js";
 
 // src/index.ts
-import { readFileSync } from "node:fs";
-import { z as z8 } from "zod";
+import fs from "node:fs";
 
-// ../helpers/src/context/context.ts
-import { z } from "zod";
-var contextSchema = z.object({
-  input: z.any(),
-  meta: z.any(),
-  tenant: z.object({ name: z.string() }),
-  data: z.record(z.string(), z.any()),
-  errors: z.record(z.string(), z.string()),
-  dates: z.record(z.string(), z.string().datetime())
-});
-var internalKey = Symbol.for("internal");
-// ../helpers/src/protocol/command.ts
-import { z as z5 } from "zod";
-
-// ../helpers/src/protocol/nodes.ts
-import { ZodError, z as z4 } from "zod";
+// ../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/protocol/getNodeOutputs.ts
-function getNodeOutputs(node, outputName) {
-  const outputs = !outputName ? node.output : outputName === "__default__" ? node.output.filter((o) => o.default) : node.output.filter((o) => ("name" in o) && o.name === outputName);
-  const outputTargets = new Set;
-  for (const output of outputs) {
-    if (output.exit) {
-      outputTargets.add("__exit__");
-    } else {
-      outputTargets.add(output.target);
-    }
+// ../helpers/src/utils/mapData.ts
+function resolve(value, onResolve) {
+  if (value instanceof Promise) {
+    return Promise.resolve().then(() => value).then(onResolve);
   }
-  return Array.from(outputTargets);
+  return onResolve(value);
+}
+function notUndefined(value, fallback) {
+  return resolve(value, (resolvedValue) => typeof resolvedValue === "undefined" ? fallback : resolvedValue);
 }
 
-// ../helpers/src/protocol/createNodeMaps.ts
-function createNodeMaps(nodes) {
-  const nodesByIdMap = new Map;
-  const nodesByNameOrAlias = new Map;
-  const inputsNodeMap = new Map([
-    ["__exit__", []]
-  ]);
-  for (const node of nodes) {
-    nodesByIdMap.set(node.id, node);
-    if ("alias" in node && node.alias) {
-      nodesByNameOrAlias.set(node.alias, node);
-    }
-    if ("name" in node && node.name) {
-      nodesByNameOrAlias.set(node.name, node);
+class AbortMapData extends Error {
+}
+function mapData(data, visitors) {
+  let aborted = false;
+  const traverseData = (data2, path) => {
+    if (aborted) {
+      return data2;
     }
-  }
-  for (const node of nodes) {
-    for (const outputNodeId of getNodeOutputs(node)) {
-      if (!inputsNodeMap.has(outputNodeId)) {
-        inputsNodeMap.set(outputNodeId, []);
+    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;
+        });
       }
-      inputsNodeMap.get(outputNodeId).push(node);
-    }
-  }
-  return {
-    getInputs(node) {
-      if (typeof node === "string") {
-        return inputsNodeMap.get(node) ?? [];
+      if (data2 === null) {
+        return notUndefined(visitors.Null?.(data2, path), data2);
       }
-      if (node.type === "catch" || node.type === "entry") {
-        return [];
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(data2)) {
+        return notUndefined(visitors.Buffer?.(data2, path), data2);
       }
-      return inputsNodeMap.get(node.id) ?? [];
-    },
-    getNode(nodeId) {
-      return nodesByIdMap.get(nodeId);
-    },
-    lookupNode(nameOrAlias) {
-      return nodesByNameOrAlias.get(nameOrAlias);
+      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/protocol/getPossiblePaths.ts
-function getPossiblePaths({
-  getInputs,
-  getNode,
-  onMissingInputs
-}) {
-  const sets = new Set;
-  const followPath = (nodeId, set2) => {
-    if (nodeId === "__entry__") {
-      return;
-    }
-    const node = nodeId !== "__exit__" ? getNode(nodeId) : null;
-    const isOrNode = node?.type === "or";
-    const inputNodes = getInputs(nodeId);
-    if (node && node.type !== "catch" && inputNodes.length === 0) {
-      onMissingInputs?.(node, Array.from(set2).toReversed());
-    }
-    for (const inputNode of inputNodes) {
-      let usedSet = set2;
-      if (isOrNode) {
-        usedSet = new Set(set2);
-        sets.add(usedSet);
-      }
-      const inputNodeId = inputNode.id;
-      if (inputNode.type !== "or") {
-        if (usedSet.has(inputNodeId)) {
-          return;
-        }
-        usedSet.add(inputNodeId);
-      }
-      followPath(inputNodeId, usedSet);
-    }
-    if (isOrNode) {
-      sets.delete(set2);
+// ../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"
   };
-  const set = new Set(["__exit__"]);
-  sets.add(set);
-  followPath("__exit__", set);
-  return Array.from(sets, (set2) => Array.from(set2).toReversed());
+}
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
 }
 
-// ../helpers/src/protocol/identifyNode.ts
-function identifyNode(nodeId, getNode) {
-  if (nodeId === "__entry__") {
-    return "ENTRY";
+// ../helpers/src/files/RequenceFile.ts
+class RequenceFile {
+  #data;
+  #file = null;
+  constructor(blobParts, options) {
+    this.#data = new Blob(blobParts, options);
   }
-  if (nodeId === "__exit__") {
-    return "EXIT";
+  static fromFileObject(file) {
+    const instance = new this([], { type: "x/x" });
+    instance.#file = file;
+    return instance;
   }
-  if (typeof nodeId === "symbol") {
-    return String(nodeId);
+  get fileObject() {
+    return this.#file;
   }
-  const node = getNode(nodeId);
-  if (!node) {
-    return `Unknown[${nodeId}]`;
+  get size() {
+    return this.#file?.size ?? this.#data.size;
   }
-  switch (node.type) {
-    case "service": {
-      return `Service[${node.alias || node.name}]`;
-    }
-    case "catch": {
-      return `Catch[${identifyNode(node.subject, getNode)}]`;
+  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());
     }
-    case "logic": {
-      return `Logic[${node.alias || node.id}]`;
+    return this.#data.text();
+  }
+  async json() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.json());
     }
-    case "entry": {
-      return "ENTRY";
+    return JSON.parse(await this.text());
+  }
+  async blob() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.blob());
     }
-    case "or": {
-      return `OR[${node.alias || node.id}]`;
+    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/protocol/node.ts
-import { z as z3 } from "zod";
-
-// ../helpers/src/protocol/jsonSchema.ts
-import { z as z2 } from "zod";
-var jsonSchema7Schema = z2.lazy(() => z2.object({
-  $id: z2.string().optional(),
-  $schema: z2.string().optional(),
-  $ref: z2.string().optional(),
-  title: z2.string().optional(),
-  description: z2.string().optional(),
-  type: z2.union([
-    z2.literal("string"),
-    z2.literal("number"),
-    z2.literal("integer"),
-    z2.literal("boolean"),
-    z2.literal("object"),
-    z2.literal("array"),
-    z2.literal("null")
-  ]).optional(),
-  enum: z2.array(z2.union([z2.string(), z2.number(), z2.boolean(), z2.null()])).optional(),
-  const: z2.union([z2.string(), z2.number(), z2.boolean(), z2.null()]).optional(),
-  multipleOf: z2.number().positive().optional(),
-  maximum: z2.number().optional(),
-  exclusiveMaximum: z2.number().optional(),
-  minimum: z2.number().optional(),
-  exclusiveMinimum: z2.number().optional(),
-  maxLength: z2.number().int().nonnegative().optional(),
-  minLength: z2.number().int().nonnegative().optional(),
-  pattern: z2.string().optional(),
-  additionalItems: z2.boolean().optional(),
-  items: z2.union([z2.lazy(() => jsonSchema7Schema), z2.array(jsonSchema7Schema)]).optional(),
-  maxItems: z2.number().int().nonnegative().optional(),
-  minItems: z2.number().int().nonnegative().optional(),
-  uniqueItems: z2.boolean().optional(),
-  contains: z2.lazy(() => jsonSchema7Schema).optional(),
-  maxProperties: z2.number().int().nonnegative().optional(),
-  minProperties: z2.number().int().nonnegative().optional(),
-  required: z2.array(z2.string()).optional(),
-  properties: z2.record(jsonSchema7Schema).optional(),
-  patternProperties: z2.record(jsonSchema7Schema).optional(),
-  additionalProperties: z2.union([z2.boolean(), z2.lazy(() => jsonSchema7Schema)]).optional(),
-  dependencies: z2.record(z2.union([z2.array(z2.string()), jsonSchema7Schema])).optional(),
-  propertyNames: z2.lazy(() => jsonSchema7Schema).optional(),
-  if: z2.lazy(() => jsonSchema7Schema).optional(),
-  then: z2.lazy(() => jsonSchema7Schema).optional(),
-  else: z2.lazy(() => jsonSchema7Schema).optional(),
-  allOf: z2.array(jsonSchema7Schema).optional(),
-  anyOf: z2.array(jsonSchema7Schema).optional(),
-  oneOf: z2.array(jsonSchema7Schema).optional(),
-  not: z2.lazy(() => jsonSchema7Schema).optional(),
-  definitions: z2.record(jsonSchema7Schema).optional(),
-  format: z2.string().optional(),
-  contentMediaType: z2.string().optional(),
-  contentEncoding: z2.string().optional()
-}).transform((obj) => {
-  if (obj.type === "object" && typeof obj.additionalProperties === "undefined") {
-    return {
-      ...obj,
-      additionalProperties: false
-    };
+// ../helpers/src/files/RequenceStream.ts
+class RequenceStream {
+  #data;
+  #stream = null;
+  #options;
+  constructor(stream, options) {
+    this.#data = stream;
+    this.#options = options;
   }
-  return obj;
-}));
-var jsonSchema7ObjectSchema = z2.object({
-  type: z2.literal("object"),
-  properties: z2.record(jsonSchema7Schema),
-  required: z2.array(z2.string()).optional(),
-  description: z2.string().optional(),
-  maxProperties: z2.number().int().nonnegative().optional(),
-  minProperties: z2.number().int().nonnegative().optional(),
-  additionalProperties: z2.boolean().default(false)
-});
-var jsonSchema7NullSchema = z2.object({
-  type: z2.literal("null")
-});
-
-// ../helpers/src/protocol/node.ts
-var outputDefinitionSchema = z3.object({
-  schema: jsonSchema7Schema.nullable().optional()
-}).and(z3.union([
-  z3.object({
-    default: z3.literal(false).default(false),
-    name: z3.string().min(1)
-  }),
-  z3.object({
-    default: z3.literal(true).default(true)
-  })
-])).and(z3.union([
-  z3.object({
-    exit: z3.literal(false).default(false),
-    target: z3.string().min(1)
-  }),
-  z3.object({ exit: z3.literal(true) })
-]));
-var defaultOutputSchema = z3.union([
-  z3.string().min(1),
-  z3.object({ default: z3.literal(true).default(true), exit: z3.literal(true) }),
-  z3.object({
-    default: z3.literal(true).default(true),
-    exit: z3.literal(false).default(false),
-    target: z3.string().min(1)
-  })
-]).transform((output) => {
-  if (typeof output === "string") {
-    return {
-      default: true,
-      exit: false,
-      target: output
-    };
+  static fromStreamObject(stream) {
+    const instance = new this(null, {
+      type: "x/x"
+    });
+    instance.#stream = stream;
+    return instance;
   }
-  return output;
-});
-var outputSchema = z3.union([z3.string().min(1), outputDefinitionSchema]).transform((output) => {
-  if (typeof output === "string") {
+  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 {
-      default: true,
-      exit: false,
-      target: output
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            return reader.read();
+          },
+          async return() {
+            reader.cancel();
+            reader.releaseLock();
+            return { done: true, value: null };
+          }
+        };
+      }
     };
   }
-  return output;
-});
-function validateOutputs(outputs, ctx) {
-  const exitOutputs = new Set(outputs.filter((output) => output.exit).map((output) => output.default ? "__default__" : output.name));
-  outputs.filter((output) => !output.exit).forEach((output) => {
-    const name = output.default ? "__default__" : output.name;
-    if (exitOutputs.has(name)) {
-      ctx.addIssue({
-        code: "custom",
-        message: output.default ? `default exit output cannot be mixed with target output "${output.target}"` : `named exit output "${name}" cannot be mixed with target output "${output.target}"`
-      });
-    }
-  });
-  const targets = new Map;
-  outputs.forEach((output) => {
-    const name = output.default ? "__default__" : output.name;
-    const target = output.exit ? "__exit__" : output.target;
-    if (!targets.has(name)) {
-      targets.set(name, new Set);
-    }
-    const knownTargets = targets.get(name);
-    if (knownTargets.has(target)) {
-      ctx.addIssue({
-        code: "custom",
-        message: [
-          output.default ? "duplicate default output" : `duplicate named output "${name}"`,
-          output.exit ? "for exit" : `for target "${target}"`
-        ].join(" ")
-      });
-    }
-    knownTargets.add(target);
-  });
+  toString() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
+  toJSON() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
 }
-var defaultOutputsSchema = z3.array(defaultOutputSchema).default([]).superRefine(validateOutputs);
-var outputsSchema = z3.array(outputSchema).default([]).superRefine(validateOutputs);
-var idSchema = z3.string().uuid().default(() => crypto.randomUUID());
-var metaSchema = z3.record(z3.any()).optional();
-var entryNodeSchema = z3.object({
-  type: z3.literal("entry"),
-  id: z3.literal("__entry__").default("__entry__"),
-  output: defaultOutputsSchema,
-  inputSchema: jsonSchema7Schema.default({ type: "null" }),
-  metaSchema: jsonSchema7Schema.default({ type: "null" }),
-  meta: metaSchema
-});
-var serviceNodeSchema = z3.object({
-  type: z3.literal("service"),
-  output: outputsSchema,
-  inputSchema: z3.union([jsonSchema7ObjectSchema, jsonSchema7NullSchema]).default({ type: "null" }),
-  id: idSchema,
-  name: z3.string(),
-  version: z3.string(),
-  configuration: z3.any().optional(),
-  configurationSchema: jsonSchema7Schema.default({ type: "null" }),
-  alias: z3.string().optional(),
-  ttl: z3.number().int().min(1).optional(),
-  retry: z3.number().int().min(1).optional(),
-  retryDelay: z3.number().int().min(100).optional(),
-  meta: metaSchema
-});
-var catchNodeSchema = z3.object({
-  type: z3.literal("catch"),
-  output: outputsSchema,
-  id: idSchema,
-  subject: z3.string(),
-  meta: metaSchema
-});
-var logicNodeSchema = z3.object({
-  type: z3.literal("logic"),
-  alias: z3.string().optional(),
-  output: outputsSchema,
-  id: idSchema,
-  script: z3.string(),
-  concurrency: z3.boolean().default(true),
-  language: z3.enum(["javascript", "python", "typescript"]).default("javascript"),
-  maxExecutionTime: z3.number().int().min(0).default(200),
-  meta: metaSchema
-});
-var orNodeSchema = z3.object({
-  id: idSchema,
-  type: z3.literal("or"),
-  alias: z3.string().optional(),
-  output: outputsSchema,
-  meta: metaSchema
+
+// ../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")
 });
-var nodeSchema = z3.discriminatedUnion("type", [
-  entryNodeSchema,
-  serviceNodeSchema,
-  catchNodeSchema,
-  logicNodeSchema,
-  orNodeSchema
-]);
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
+function toStreamObject(streamInfo) {
+  return {
+    ...streamInfo,
+    __REQUENCE_type: "RequenceStream"
+  };
+}
 
-// ../helpers/src/protocol/nodes.ts
-class NodesError extends ZodError {
-  constructor(message, params, path = []) {
-    super([
-      {
-        code: z4.ZodIssueCode.custom,
-        message,
-        path,
-        params
-      }
-    ]);
+// ../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);
 }
-var nodesSchema = z4.array(nodeSchema).transform((nodes) => {
-  const aliases = new Map;
-  const names = new Map;
-  let entryNode = null;
-  let firstNodeId = null;
-  for (const node of nodes) {
-    if (node.type === "entry") {
-      entryNode = node;
-    }
-    if ((node.type === "service" || node.type === "logic") && !firstNodeId) {
-      firstNodeId = node.id;
+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");
     }
-    if ("alias" in node && node.alias) {
-      if (!aliases.has(node.alias)) {
-        aliases.set(node.alias, []);
-      }
-      aliases.get(node.alias).push(node.id);
-    }
-    if ("name" in node && node.name) {
-      if (!names.has(node.name)) {
-        names.set(node.name, []);
-      }
-      names.get(node.name).push(node.id);
-    }
-  }
-  if (!entryNode && firstNodeId) {
-    nodes.unshift({
-      type: "entry",
-      id: "__entry__",
-      inputSchema: { type: "null" },
-      metaSchema: { type: "null" },
-      output: [{ default: true, exit: false, target: firstNodeId }]
-    });
+    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 resolveOutput = (identifier) => {
-    if (aliases.get(identifier)?.length === 1) {
-      return aliases.get(identifier)[0];
-    }
-    if (names.get(identifier)?.length === 1) {
-      return names.get(identifier)[0];
-    }
-    return identifier;
-  };
-  return nodes.map((node) => {
-    node.output = node.output.map((output) => ("target" in output) ? {
-      ...output,
-      target: resolveOutput(output.target)
-    } : output);
-    if ("subject" in node) {
-      node.subject = resolveOutput(node.subject);
-    }
-    return node;
+  const { mime, url } = data;
+  await dataPromise;
+  const done = fetch(url, {
+    method: "POST",
+    signal,
+    duplex: "half",
+    body: dataStream
   });
-}).transform((nodes) => {
-  const { getInputs, getNode } = createNodeMaps(nodes);
-  const nodeAliases = new Set;
-  const nodeIds = new Set;
-  const catchSubjects = new Map;
-  const identify = (nodeId) => identifyNode(nodeId, getNode);
-  for (const node of nodes) {
-    if (nodeIds.has(node.id)) {
-      throw new NodesError("id is not unique", {
-        id: node.id
-      });
-    }
-    nodeIds.add(node.id);
-    if ("alias" in node && node.alias) {
-      if (nodeAliases.has(node.alias)) {
-        throw new NodesError("alias is not unique", {
-          alias: node.alias
-        });
+  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;
+        }
       }
-      nodeAliases.add(node.alias);
-    }
-    if (node.type === "catch") {
-      if (catchSubjects.has(node.subject)) {
-        throw new NodesError("only one catch node per service allowed", {
-          id: node.subject
-        });
+      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;
+        }
       }
-      catchSubjects.set(node.subject, node);
-    }
-  }
-  if (!getNode("__entry__")) {
-    throw new NodesError("missing entry node");
-  }
-  if (getInputs("__exit__").length === 0) {
-    throw new NodesError("no path leads to exit");
-  }
-  for (const catchNode of nodes.filter((node) => node.type === "catch")) {
-    if (!getNode(catchNode.subject)) {
-      throw new NodesError("catch node has invalid subject", {
-        id: catchNode.subject
-      });
     }
-  }
-  for (const node of nodes) {
-    if (node.type === "or") {
-      const inputs = getInputs(node);
-      if (!inputs || inputs.length < 2) {
-        throw new NodesError("or nodes need at least 2 inputs");
+  });
+  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);
       }
-    }
-    for (const targetNodeId of getNodeOutputs(node)) {
-      if (targetNodeId !== "__exit__" && !getNode(targetNodeId)) {
-        throw new NodesError("missing node", {
-          id: targetNodeId
-        });
+      if (isStreamObject(obj)) {
+        return RequenceStream.fromStreamObject(obj);
       }
-    }
-  }
-  const possiblePaths = getPossiblePaths({
-    getInputs,
-    getNode,
-    onMissingInputs: (_node, path) => {
-      throw new NodesError("no path from entry to node", {
-        path: path.map(identify)
-      });
-    }
-  });
-  if (possiblePaths.every((possiblePath) => !possiblePath.includes("__entry__"))) {
-    throw new NodesError("no path from entry to exit");
-  }
-  for (const possiblePath of possiblePaths) {
-    for (const pathSegment of possiblePath) {
-      const node = pathSegment === "__exit__" ? null : getNode(pathSegment);
-      if (node?.type === "catch" && possiblePath.includes(node.subject)) {
-        throw new NodesError("Unresolvable, inputs needs both catch and subject", {
-          path: possiblePath.map(identify)
-        });
+      if (isCallbackObject(obj)) {
+        return (arg) => {
+          onCallback?.({ ...obj, arg });
+        };
       }
     }
-  }
-  return nodes;
-});
+  });
+}
 
-// ../helpers/src/protocol/command.ts
-var abortSchema = z5.object({
-  type: z5.literal("ABORT"),
-  reason: z5.string().optional()
-});
-var nodeOptionsSchema = z5.object({
-  maxExecutions: z5.number().int().min(0).optional().default(10)
-});
-var createNodesSchema = z5.object({
-  type: z5.literal("CREATE_NODES"),
-  nodes: nodesSchema,
-  input: z5.any(),
-  meta: z5.any(),
-  options: nodeOptionsSchema
-});
-var commandSchema = z5.union([abortSchema, createNodesSchema]);
-// ../helpers/src/protocol/update.ts
-import { z as z6 } from "zod";
-var baseUpdateSchema = z6.object({
-  timestamp: z6.number().int().transform((int) => new Date(int))
-});
-var baseNodeUpdateSchema = baseUpdateSchema.extend({
-  nodeId: z6.string().uuid()
-});
-var nodeStartUpdateSchema = baseNodeUpdateSchema.extend({
-  type: z6.literal("NODE_START"),
-  context: contextSchema
-});
-var nodeErrorUpdateSchema = baseNodeUpdateSchema.extend({
-  type: z6.literal("NODE_ERROR"),
-  error: z6.string(),
-  context: contextSchema
-});
-var nodeUpdateSchema = baseNodeUpdateSchema.extend({
-  type: z6.literal("NODE_UPDATE"),
-  output: z6.string(),
-  data: z6.unknown(),
-  context: contextSchema
-});
-var nodeFinishedUpdateSchema = baseNodeUpdateSchema.extend({
-  type: z6.literal("NODE_FINISHED"),
-  context: contextSchema
-});
-var nodeDebugUpdateSchema = baseNodeUpdateSchema.extend({
-  type: z6.literal("NODE_DEBUG"),
-  severity: z6.enum(["log", "info", "warn", "error"]),
-  data: z6.unknown(),
-  context: contextSchema
-});
-var nodeDeferUpdateSchema = baseNodeUpdateSchema.extend({
-  type: z6.literal("NODE_DEFER"),
-  data: z6.unknown(),
-  context: contextSchema
-});
-var taskStartUpdateSchema = baseUpdateSchema.extend({
-  type: z6.literal("TASK_START"),
-  nodes: nodesSchema,
-  context: contextSchema
-});
-var taskErrorUpdateSchema = baseUpdateSchema.extend({
-  type: z6.literal("TASK_ERROR"),
-  reason: z6.string().optional(),
-  context: contextSchema
-});
-var taskFinishedUpdateSchema = baseUpdateSchema.extend({
-  type: z6.literal("TASK_FINISHED"),
-  context: contextSchema
-});
-var updateSchema = z6.discriminatedUnion("type", [
-  nodeStartUpdateSchema,
-  nodeErrorUpdateSchema,
-  nodeUpdateSchema,
-  nodeFinishedUpdateSchema,
-  nodeDebugUpdateSchema,
-  nodeDeferUpdateSchema,
-  taskStartUpdateSchema,
-  taskErrorUpdateSchema,
-  taskFinishedUpdateSchema
-]);
 // src/createAmqpConnection.ts
 import { connect } from "amqp-connection-manager";
-import { z as z7 } from "zod";
+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) {
@@ -614,400 +421,701 @@ class RetryError extends Error {
   }
 }
 
+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 isRecord(data) {
-  return typeof data === "object" && data !== null && !Array.isArray(data);
+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
+  });
 }
-function unwrapResult(result) {
-  if (isOutputValue(result)) {
-    return { value: result.value, outputName: result[OUTPUT_VALUE] };
+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: result, outputName: null };
+  return {
+    value: await processData({
+      outputName: null,
+      data: params.result,
+      options: params.options,
+      onDone: params.onDone,
+      onCallback: params.onCallback
+    }),
+    outputName: null
+  };
 }
 function createContextHelper(options) {
-  const nodes2 = new Map(options.nodes.map((node2) => [
-    node2.id,
-    Object.assign(node2, {
-      executionDate: node2.id in options.context.dates ? new Date(options.context.dates[node2.id]) : null,
-      data: options.context.data[node2.id] ?? null,
-      error: options.context.errors[node2.id] ?? null
-    })
-  ]));
-  return {
-    taskId: options.taskId,
-    getInput() {
-      return options.context.input;
-    },
-    getMeta() {
-      return options.context.meta;
-    },
-    getData() {
-      return Array.from(nodes2.values()).filter((result) => result.executionDate && isRecord(result.data)).toSorted((a, b) => a.executionDate.getTime() - b.executionDate.getTime()).reduce((acc, result) => ({
-        ...acc,
-        ...result.data
-      }), isRecord(options.context.input) ? { ...options.context.input } : {});
-    },
-    toOutput(name, value) {
-      return {
-        [OUTPUT_VALUE]: name,
-        value
-      };
-    },
-    defer: options.onDefer,
-    getConfiguration() {
-      const result = nodes2.get(options.serviceId);
-      if (result?.type === "service") {
-        return result.configuration ?? null;
-      }
-      return null;
-    },
-    getNode() {
-      return nodes2.get(options.serviceId);
-    },
-    getNodes() {
-      return Array.from(nodes2.values());
-    },
-    state: createObjectProxy(options.state, options.onStateChange),
-    debug: {
-      log(...data) {
-        options.onLog("log", data);
+  const terminatePromise = Promise.withResolvers();
+  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
+        };
       },
-      info(...data) {
-        options.onLog("info", data);
+      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);
+        }
       },
-      warn(...data) {
-        options.onLog("warn", data);
+      retry(delay) {
+        throw new RetryError(delay);
       },
-      error(...data) {
-        options.onLog("error", data);
-      }
-    },
-    retry(delay) {
-      throw new RetryError(delay);
+      abort(reason) {
+        throw new AbortError(reason);
+      },
+      skip() {
+        throw new SkipError;
+      },
+      terminated: terminatePromise.promise
     },
-    abort(reason) {
-      throw new AbortError(reason);
+    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 = z7.string().transform((str) => deobfuscate(str)).pipe(z7.array(z7.string().uuid()).length(3)).transform((arr) => ({
+var messageKeySchema = z5.string().transform((str) => deobfuscate(str)).pipe(z5.tuple([z5.uuid(), z5.uuid()]).rest(z5.string())).transform((arr) => ({
   taskId: arr[0],
-  serviceId: arr[1],
-  messageId: arr[2]
+  messageId: arr[1],
+  uploadUrl: arr[2] || undefined,
+  streamUrl: arr[3] || 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 = z5.object({
+  properties: z5.object({
+    correlationId: z5.uuid(),
+    headers: z5.object({
+      taskId: z5.uuid()
     })
   })
 }).transform((msg) => ({
-  version: msg.properties.headers.version,
   messageId: msg.properties.correlationId,
-  taskId: msg.properties.headers.taskId,
-  serviceId: msg.properties.headers.serviceId
+  taskId: msg.properties.headers.taskId
 }));
-var payloadSchema = z7.object({ content: z7.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z7.object({
-  context: contextSchema,
-  meta: z7.object({
-    nodes: nodesSchema,
-    state: z7.record(z7.any())
+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()
+});
 function isMessageHandlerGenerator(handler) {
   return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
 }
-var activeMessages = new Set;
+var activeMessages = new Map;
 function createConnection({
   url,
   version,
   prefetch = 1,
   silent = false,
-  connectionTimeout
+  connectionTimeout,
+  connectionOptions,
+  devOverlay = ""
 }, messageHandler) {
-  const queue = `${url.username}@${version}`;
+  const baseQueue = `${url.username}@${version}`;
+  const queue = devOverlay ? `${baseQueue}-dev-overlay-${devOverlay}` : baseQueue;
   const exchange = url.username;
-  const connection = connect(url.toString());
-  const connectedPromise = new Promise((resolve, reject) => {
+  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: "Connection timeout" });
+      handleConnectFailed({
+        err: new RequenceConnectionError("Requence connection timeout")
+      });
     }, connectionTimeout);
     const handleConnect = () => {
       unsubscribe();
-      resolve();
+      resolve2();
     };
     const handleConnectFailed = ({ err }) => {
       unsubscribe();
-      reject(new Error(err));
+      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 channel = connection.createChannel({
-    async setup(channel2) {
-      await channel2.checkExchange(exchange);
-      await channel2.checkExchange(`${exchange}-retry`);
-      await channel2.checkQueue(queue);
-      await channel2.prefetch(prefetch);
+  const connectionId = crypto.randomUUID();
+  const backchannelQueue = `${baseQueue}-backchannel-${connectionId}`;
+  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);
     }
   });
   const publish = ({
     data,
     outputName,
     messageId,
+    priority,
     ...headers
-  }) => {
-    channel.publish(exchange, "", Buffer.from(JSON.stringify(data ?? null)), {
-      correlationId: messageId,
-      contentType: "application/json",
-      headers: {
-        outputName: outputName ?? null,
-        ...headers
-      }
-    });
-  };
-  channel.consume(queue, async (message) => {
-    if (message.properties.headers?.abort || message.properties.headers?.exception) {
-      channel.nack(message, false, false);
-      return;
+  }) => channelWrapper.publish(exchange, "", Buffer.from(JSON.stringify(data ?? null)), {
+    correlationId: messageId,
+    contentType: "application/json",
+    persistent: true,
+    priority,
+    headers: {
+      outputName: outputName ?? null,
+      connectionId,
+      libVersion: "javascript@1.0.0-alpha.50",
+      ...headers
     }
-    let removeActiveMessage = () => {
-    };
-    try {
-      let deferred = false;
-      let deferredReason = null;
-      const { messageId, serviceId, taskId } = headerSchema.parse(message);
-      activeMessages.add(messageId);
-      removeActiveMessage = () => activeMessages.delete(messageId);
-      const payload = payloadSchema.parse(message);
-      let acked = false;
-      const ack = () => {
-        if (!acked) {
-          acked = true;
-          channel.ack(message);
+  });
+  const generatorTerminators = new Map;
+  const callbacks = new Map;
+  channelWrapper.addSetup(async (channel) => {
+    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;
         }
-      };
-      let immediateUpdateState;
-      const extendedContext = createContextHelper({
-        serviceId,
-        context: payload.context,
-        nodes: payload.meta.nodes,
-        taskId,
-        state: payload.meta.state,
-        onStateChange(newState) {
-          clearImmediate(immediateUpdateState);
-          immediateUpdateState = setImmediate(() => {
+        case "callback": {
+          callbacks.get(backchannelMessage.payload.callbackId)?.(backchannelMessage.payload.arg);
+          break;
+        }
+      }
+    }, {
+      noAck: true
+    });
+  });
+  channelWrapper.addSetup(async (channel) => {
+    channel.consume(queue, async (message) => {
+      if (!message) {
+        return;
+      }
+      let publishIndex = 0;
+      const donePromises = [];
+      const registeredCallbackIds = new Set;
+      let resolveActiveMessage = () => {};
+      const { messageId, taskId } = 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,
-              serviceId,
-              data: clone(newState),
-              state: true
+              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)) {
+          const generator = messageHandler(extendedContext);
+          const terminationPromise = Promise.withResolvers();
+          generatorTerminators.set(messageId, (reason) => {
+            generator.return();
+            terminationPromise.resolve(abortSymbol);
+            terminatePromise.resolve(reason);
           });
-        },
-        onLog(debugMethod, data) {
-          publish({
-            messageId,
-            taskId,
-            serviceId,
-            data,
-            debugMethod,
-            debug: true
+          await handlerStorage.run(extendedContext, async () => {
+            while (true) {
+              const next = await Promise.race([
+                terminationPromise.promise,
+                generator.next()
+              ]);
+              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;
+              }
+            }
           });
-        },
-        onDefer(reason) {
-          deferred = true;
-          deferredReason = reason || null;
-          ack();
-          return obfuscate(taskId, serviceId, messageId);
-        }
-      });
-      if (isMessageHandlerGenerator(messageHandler)) {
-        const generator = messageHandler(extendedContext);
-        while (true) {
-          const { value: result, done } = await generator.next();
-          ack();
-          if (deferred) {
-            deferred = false;
+        } 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;
           }
-          const { value, outputName } = unwrapResult(result);
-          if (!done || typeof value !== "undefined") {
+          if (!deferred || value) {
             publish({
+              index: publishIndex++,
+              version,
               messageId,
               taskId,
-              serviceId,
               data: value,
+              priority: message.properties.priority,
               outputName
             });
           }
-          if (done) {
-            break;
-          }
         }
-      } else {
-        const result = await messageHandler(extendedContext);
-        ack();
-        const { value, outputName } = unwrapResult(result);
-        if (deferred && value) {
-          console.warn("returning a value in a deferred message resets the deferred status");
-          deferred = false;
+        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
+            });
+            channel.ack(message);
+            resolve2();
+          });
+        });
+      } catch (error) {
+        if (error instanceof SkipError) {
+          channel.nack(message);
+          return;
         }
-        if (!deferred || value) {
-          publish({
-            messageId,
-            taskId,
-            serviceId,
-            data: value,
-            outputName
+        if (error instanceof RetryError) {
+          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) {
+          channelWrapper.ack(message);
+          channelWrapper.publish(`${exchange}-retry`, "operator", error.message, {
+            ...message.properties,
+            contentType: "text/plain",
+            headers: {
+              ...message.properties.headers,
+              index: publishIndex++,
+              libVersion: "javascript@1.0.0-alpha.50",
+              abort: true
+            }
           });
+          return;
         }
-      }
-      setImmediate(() => publish({
-        messageId,
-        taskId,
-        serviceId,
-        data: deferredReason,
-        deferred,
-        done: !deferred
-      }));
-    } catch (error) {
-      if (error instanceof RetryError) {
-        const properties = {
-          ...message.properties,
-          expiration: error.delay || 1000
-        };
-        channel.publish(`${exchange}-retry`, "retry", message.content, properties);
-        channel.ack(message);
-        return;
-      }
-      if (error instanceof AbortError && error.message.length > 0) {
-        channel.publish(`${exchange}-retry`, "requeue", error.message, {
-          ...message.properties,
-          expiration: 0,
-          priority: 0,
-          contentType: "text/plain",
-          headers: {
-            ...message.properties.headers,
-            abort: true
+        if (error instanceof Error) {
+          if (!silent) {
+            console.error("Encountered an error inside service handler:");
+            console.error(error);
           }
-        });
-        channel.ack(message);
-        return;
-      }
-      if (error instanceof Error) {
-        if (!silent) {
-          console.error(`Encountered an error inside service handler:`);
-          console.error(error);
+          channel.ack(message);
+          channel.publish(`${exchange}-retry`, "operator", message.content, {
+            ...message.properties,
+            headers: {
+              ...message.properties.headers,
+              version,
+              exception: true,
+              index: publishIndex++,
+              libVersion: "javascript@1.0.0-alpha.50",
+              "error-message": error.message || "error in service handler"
+            }
+          });
+          return;
         }
-        channel.publish(`${exchange}-retry`, "requeue", message.content, {
-          ...message.properties,
-          expiration: 0,
-          priority: 0,
-          headers: {
-            ...message.properties.headers,
-            exception: true,
-            "error-message": error.message || "error in service handler"
-          }
-        });
-        channel.ack(message);
-        return;
+      } finally {
+        generatorTerminators.delete(messageId);
+        registeredCallbackIds.forEach((id) => callbacks.delete(id));
+        resolveActiveMessage();
       }
-      channel.nack(message, false, false);
-    } finally {
-      removeActiveMessage();
-    }
+    });
   });
+  const activeMessageKeys = new Set;
   const api = {
     close: async () => {
-      await channel.close();
+      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 = [];
       await actor({
-        sendToOutput(outputName, data) {
-          const { taskId: taskId2, serviceId: serviceId2, messageId: messageId2 } = messageKeySchema.parse(messageKey);
-          if (activeMessages.has(messageId2)) {
-            throw new Error("Cannot send deferred message while callback handler is still running");
-          }
-          publish({
-            messageId: messageId2,
-            taskId: taskId2,
-            serviceId: serviceId2,
-            data,
+        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
-          });
+          }));
         },
-        send(data) {
-          const { taskId: taskId2, serviceId: serviceId2, messageId: messageId2 } = messageKeySchema.parse(messageKey);
-          if (activeMessages.has(messageId2)) {
-            throw new Error("Cannot send deferred message while callback handler is still running");
-          }
-          publish({
-            messageId: messageId2,
-            taskId: taskId2,
-            serviceId: serviceId2,
-            data
-          });
+        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
+                };
+              }
+            })
+          }));
         },
-        abort(error) {
-          const { taskId: taskId2, serviceId: serviceId2, messageId: messageId2 } = messageKeySchema.parse(messageKey);
-          if (activeMessages.has(messageId2)) {
-            throw new Error("Cannot send deferred message while callback handler is still running");
-          }
-          channel.publish(`${exchange}-retry`, "requeue", error instanceof Error ? error.message : error, {
-            correlationId: messageId2,
+        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: taskId2,
-              serviceId: serviceId2,
+              taskId,
+              libVersion: "javascript@1.0.0-alpha.50",
+              index: publishIndex++,
               abort: true
             }
           });
         }
       });
-      const { taskId, serviceId, messageId } = messageKeySchema.parse(messageKey);
-      setImmediate(() => publish({
+      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,
-        serviceId,
         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 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")
-  ]),
-  version: z8.string(),
-  silent: z8.boolean().optional(),
-  prefetch: z8.number().int().optional(),
-  connectionTimeout: z8.number().positive().default(3000)
-});
+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;
@@ -1020,23 +1128,54 @@ function createService(optionsOrVersion, optionalMessageHandler) {
     options = optionsOrVersion;
     messageHandler = optionalMessageHandler;
   }
-  const token = options.accessToken ?? process.env.REQUENCE_ACCESS_TOKEN ?? JSON.parse(readFileSync("package.json", "utf-8")).requence?.accessToken;
+  let token = options.accessToken ?? process.env.REQUENCE_SERVICE_ACCESS_TOKEN ?? process.env.REQUENCE_ACCESS_TOKEN;
   if (!token) {
-    throw new Error("No service key found");
+    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 service key");
+    throw new Error("invalid access token");
   }
-  const connectionOptions = {
+  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: parts[1]
-  };
-  return createConnection(connectionOptionsSchema.parse(connectionOptions), messageHandler);
+    url,
+    devOverlay
+  }), messageHandler);
 }
 export {
-  createService
+  wrapIterable,
+  createService,
+  createCallback,
+  asyncEventEmitter,
+  RequenceStream,
+  RequenceFile,
+  RequenceConnectionError
 };
 
-//# debugId=41D15659E9341B8064756E2164756E21
+//# debugId=57C0C865BD4C680C64756E2164756E21
 //# sourceMappingURL=index.js.map