@requence/service 1.0.0-alpha.18 → 1.0.0-alpha.19

package/build/index.js

@@ -6,48 +6,6 @@ import {
 // src/index.ts
 import fs from "node:fs";
 
-// ../helpers/src/utils/clone.ts
-var CLONE_SYMBOL = Symbol("original");
-function clone(data) {
-  if (typeof data !== "object" || data === null) {
-    return data;
-  }
-  const target = data[CLONE_SYMBOL];
-  if (target) {
-    return clone(target);
-  }
-  if (Array.isArray(data)) {
-    return data.map(clone);
-  }
-  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, clone(value)]));
-}
-
-// ../helpers/src/utils/createObjectProxy.ts
-function createObjectProxy(obj, onChange) {
-  return new Proxy(obj, {
-    set(target, property, newValue) {
-      const result = Reflect.set(target, property, newValue);
-      onChange(target);
-      return result;
-    },
-    deleteProperty(target, property) {
-      const result = Reflect.deleteProperty(target, property);
-      onChange(target);
-      return result;
-    },
-    get(target, property, receiver) {
-      if (property === CLONE_SYMBOL) {
-        return target;
-      }
-      const result = Reflect.get(target, property, receiver);
-      if (typeof result === "object" && result !== null) {
-        return createObjectProxy(result, () => onChange(target));
-      }
-      return result;
-    }
-  });
-}
-
 // ../helpers/src/utils/createRemotePromise.ts
 function createRemotePromise(onAwait) {
   let resolvePromise;
@@ -77,8 +35,8 @@ function createRemotePromise(onAwait) {
 }
 
 // ../helpers/src/utils/isRecord.ts
-import { z } from "zod";
-var recordSchema = z.record(z.unknown());
+import { z } from "zod/v4";
+var recordSchema = z.record(z.string(), z.unknown());
 function isRecord(data) {
   return recordSchema.safeParse(data).success;
 }
@@ -93,60 +51,73 @@ function resolve(value, onResolve) {
 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 (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 (aborted) {
+      return data2;
     }
-    if (data2 === null) {
-      return notUndefined(visitors.Null?.(data2, path), data2);
-    }
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(data2)) {
-      return notUndefined(visitors.Buffer?.(data2, path), data2);
-    }
-    if (typeof data2 === "string") {
-      return notUndefined(visitors.String?.(data2, path), data2);
-    }
-    if (typeof data2 === "number") {
-      return notUndefined(visitors.Number?.(data2, path), data2);
-    }
-    if (isRecord(data2)) {
-      return resolve(visitors.Object?.(data2, path), (resolvedData) => {
-        if (resolvedData) {
-          return resolvedData;
-        }
-        const entries = Object.entries(data2).map(([key, value]) => [
-          key,
-          traverseData(value, [...path, key])
-        ]);
-        if (entries.some(([, value]) => value instanceof Promise)) {
-          return Promise.all(entries.map(([key, value]) => Promise.resolve().then(() => value).then((resolvedValue) => [key, resolvedValue]))).then((entries2) => Object.fromEntries(entries2));
-        }
-        return Object.fromEntries(entries);
-      });
+    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 (isRecord(data2)) {
+        return resolve(visitors.Object?.(structuredClone(data2), path), (resolvedData) => {
+          const nextData = resolvedData ?? data2;
+          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 data2;
   };
   return traverseData(data, []);
 }
-
-// src/index.ts
-import { z as z9 } from "zod";
-
-// ../helpers/src/context/context.ts
-import { z as z3 } from "zod";
-
-// ../helpers/src/files/index.ts
-import { z as z2 } from "zod";
+mapData.abort = () => {
+  throw new AbortMapData;
+};
 
 // ../helpers/src/files/mapOutput.ts
 async function upload(uploadUrl, body, signal, contentType) {
@@ -253,29 +224,7 @@ async function mapOutput(params) {
   Promise.allSettled(streamPromises).then(() => params.onDone?.());
   return mapped;
 }
-// ../helpers/src/files/isValidMimeType.ts
-import { extension } from "mime-types";
-function isValidMimeType(fileInfo, accept) {
-  const ext = fileInfo.ext ?? (extension(fileInfo.mime) || "???");
-  const mimeType = fileInfo.mime.toLowerCase().split(";")[0].trim();
-  const acceptTypes = accept.split(",").map((type) => type.toLowerCase().split(";")[0].trim());
-  return acceptTypes.some((acceptedType) => {
-    if (acceptedType === "*/*") {
-      return true;
-    }
-    if (acceptedType.endsWith("/*")) {
-      const baseType = acceptedType.split("/")[0];
-      return mimeType.startsWith(baseType + "/");
-    }
-    if (acceptedType.includes("/")) {
-      return mimeType === acceptedType;
-    }
-    if (acceptedType.startsWith(".")) {
-      return ext.toLowerCase().endsWith(acceptedType);
-    }
-    return false;
-  });
-}
+
 // ../helpers/src/files/RequenceFile.ts
 class RequenceFile {
   #data;
@@ -334,6 +283,7 @@ class RequenceFile {
     return `RequenceFile<${this.mimeType}>`;
   }
 }
+
 // ../helpers/src/files/RequenceStream.ts
 class RequenceStream {
   #data;
@@ -395,608 +345,63 @@ class RequenceStream {
   }
 }
 
-// ../helpers/src/files/index.ts
-var fileObjectSchema = z2.object({
-  size: z2.number().int().positive(),
-  mime: z2.string(),
-  url: z2.string().url(),
-  __REQUENCE_type: z2.literal("RequenceFile")
-});
-function toFileObject(fileInfo) {
-  return {
-    ...fileInfo,
-    __REQUENCE_type: "RequenceFile"
-  };
-}
-function isFileObject(data) {
-  return fileObjectSchema.safeParse(data).success;
-}
+// ../helpers/src/files/streamObject.ts
+import { z as z2 } from "zod/v4";
 var streamObjectSchema = z2.object({
   mime: z2.string(),
   url: z2.string().url(),
   __REQUENCE_type: z2.literal("RequenceStream")
 });
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
 function toStreamObject(streamInfo) {
   return {
     ...streamInfo,
     __REQUENCE_type: "RequenceStream"
   };
 }
-function isStreamObject(data) {
-  return streamObjectSchema.safeParse(data).success;
-}
 
-// ../helpers/src/context/context.ts
-var contextSchema = z3.object({
-  input: z3.any(),
-  meta: z3.any(),
-  tenant: z3.object({ name: z3.string() }),
-  data: z3.record(z3.string(), z3.any()),
-  errors: z3.record(z3.string(), z3.string()),
-  dates: z3.record(z3.string(), z3.string().datetime())
+// ../helpers/src/files/fileObject.ts
+import { z as z3 } from "zod/v4";
+var fileObjectSchema = z3.object({
+  size: z3.number().int().positive(),
+  mime: z3.string(),
+  url: z3.string().url(),
+  __REQUENCE_type: z3.literal("RequenceFile")
 });
-var internalKey = Symbol.for("internal");
-
-// ../helpers/src/protocol/command.ts
-import { z as z7 } from "zod";
-
-// ../helpers/src/protocol/nodes.ts
-import { ZodError, z as z6 } from "zod";
-
-// ../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);
-    }
-  }
-  return Array.from(outputTargets);
-}
-
-// ../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);
-    }
-  }
-  for (const node of nodes) {
-    for (const outputNodeId of getNodeOutputs(node)) {
-      if (!inputsNodeMap.has(outputNodeId)) {
-        inputsNodeMap.set(outputNodeId, []);
-      }
-      inputsNodeMap.get(outputNodeId).push(node);
-    }
-  }
+function toFileObject(fileInfo) {
   return {
-    getInputs(node) {
-      if (typeof node === "string") {
-        return inputsNodeMap.get(node) ?? [];
-      }
-      if (node.type === "catch" || node.type === "entry") {
-        return [];
-      }
-      return inputsNodeMap.get(node.id) ?? [];
-    },
-    getNode(nodeId) {
-      return nodesByIdMap.get(nodeId);
-    },
-    lookupNode(nameOrAlias) {
-      return nodesByNameOrAlias.get(nameOrAlias);
-    }
-  };
-}
-
-// ../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);
-    }
+    ...fileInfo,
+    __REQUENCE_type: "RequenceFile"
   };
-  const set = new Set(["__exit__"]);
-  sets.add(set);
-  followPath("__exit__", set);
-  return Array.from(sets, (set2) => Array.from(set2).toReversed());
 }
-
-// ../helpers/src/protocol/identifyNode.ts
-function identifyNode(nodeId, getNode) {
-  if (nodeId === "__entry__") {
-    return "ENTRY";
-  }
-  if (nodeId === "__exit__") {
-    return "EXIT";
-  }
-  if (typeof nodeId === "symbol") {
-    return String(nodeId);
-  }
-  const node = getNode(nodeId);
-  if (!node) {
-    return `Unknown[${nodeId}]`;
-  }
-  switch (node.type) {
-    case "service": {
-      return `Service[${node.alias || node.name}]`;
-    }
-    case "catch": {
-      return `Catch[${identifyNode(node.subject, getNode)}]`;
-    }
-    case "logic": {
-      return `Logic[${node.alias || node.id}]`;
-    }
-    case "entry": {
-      return "ENTRY";
-    }
-    case "or": {
-      return `OR[${node.alias || node.id}]`;
-    }
-  }
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
 }
 
-// ../helpers/src/protocol/node.ts
-import { z as z5 } from "zod";
-
-// ../helpers/src/jsonschema/zod.ts
-import { z as z4 } from "zod";
-
-// ../helpers/src/jsonschema/validate.ts
-import {
-  Ajv as BaseAjv
-} from "ajv";
-var acceptKeyword = {
-  keyword: "accept",
-  type: "object",
-  metaSchema: {
-    type: "string",
-    pattern: "^\\s*(?:(?:\\w+/\\*|\\w+/[-+.\\w]+|\\*/\\*))(?:\\s*,\\s*(?:(?:\\w+/\\*|\\w+/[-+.\\w]+|\\*/\\*)))*\\s*$"
-  }
-};
-var acceptKeywordEnforced = {
-  ...acceptKeyword,
-  compile: (accept) => function validate(data) {
-    const errors = validate.errors = [];
-    if (isFileObject(data) || isStreamObject(data)) {
-      if (!isValidMimeType(data, accept)) {
-        errors.push({ message: `must be of type ${accept}` });
-        return false;
+// ../helpers/src/utils/resolveRequenceTypes.ts
+function resolveRequenceTypes(data) {
+  return mapData(data, {
+    Object(obj) {
+      if (isFileObject(obj)) {
+        return RequenceFile.fromFileObject(obj);
       }
-    } else {
-      errors.push({ message: "invalid file type" });
-      return false;
-    }
-    return true;
-  }
-};
-var requenceTypeKeywords = {
-  keyword: "requenceType",
-  metaSchema: {
-    enum: ["file", "stream"]
-  }
-};
-var instanceOfKeyword = {
-  keyword: "instanceOf",
-  schemaType: "string",
-  compile: (schema) => function validate(data) {
-    const errors = validate.errors = [];
-    if (typeof data !== "object" || !data || !("constructor" in data)) {
-      errors.push({ message: "not a object" });
-      return false;
-    }
-    if (data.constructor.name !== schema) {
-      errors.push({ message: `must be instanceof ${schema}` });
-      return false;
-    }
-    return true;
-  }
-};
-var maxByteLengthKeyword = {
-  keyword: "maxByteLength",
-  type: "object",
-  metaSchema: {
-    type: "integer",
-    minimum: 0
-  }
-};
-var maxByteLengthKeywordEnforced = {
-  ...maxByteLengthKeyword,
-  compile: (maxByteLength) => function validate(data) {
-    const errors = validate.errors = [];
-    if (isFileObject(data)) {
-      if (data.size > maxByteLength) {
-        errors.push({
-          message: `file size must by lower tan ${maxByteLength}`
-        });
-        return false;
+      if (isStreamObject(obj)) {
+        return RequenceStream.fromStreamObject(obj);
       }
-    } else {
-      errors.push({ message: "invalid file type" });
-      return false;
     }
-    return true;
-  }
-};
-
-class Ajv extends BaseAjv {
-  constructor(options) {
-    super({
-      ...options,
-      keywords: [
-        options?.enforeFileKeywords ? acceptKeywordEnforced : acceptKeyword,
-        options?.enforeFileKeywords ? maxByteLengthKeywordEnforced : maxByteLengthKeyword,
-        requenceTypeKeywords,
-        instanceOfKeyword
-      ]
-    });
-  }
-}
-
-// ../helpers/src/jsonschema/zod.ts
-var jsonSchema7Schema = z4.custom((value) => {
-  const ajv = new Ajv;
-  return ajv.validateSchema(value);
-}, { message: "Invalid json schema" });
-var jsonSchema7ObjectSchema = z4.object({
-  type: z4.literal("object")
-}).and(jsonSchema7Schema);
-var jsonSchema7NullSchema = z4.object({
-  type: z4.literal("null")
-});
-
-// ../helpers/src/protocol/node.ts
-var outputDefinitionSchema = z5.object({
-  schema: jsonSchema7Schema.nullable().optional()
-}).and(z5.union([
-  z5.object({
-    default: z5.literal(false).default(false),
-    name: z5.string().min(1)
-  }),
-  z5.object({
-    default: z5.literal(true).default(true)
-  })
-])).and(z5.union([
-  z5.object({
-    exit: z5.literal(false).default(false),
-    target: z5.string().min(1)
-  }),
-  z5.object({ exit: z5.literal(true) })
-]));
-var defaultOutputSchema = z5.union([
-  z5.string().min(1),
-  z5.object({ default: z5.literal(true).default(true), exit: z5.literal(true) }),
-  z5.object({
-    default: z5.literal(true).default(true),
-    exit: z5.literal(false).default(false),
-    target: z5.string().min(1)
-  })
-]).transform((output) => {
-  if (typeof output === "string") {
-    return {
-      default: true,
-      exit: false,
-      target: output
-    };
-  }
-  return output;
-});
-var outputSchema = z5.union([z5.string().min(1), outputDefinitionSchema]).transform((output) => {
-  if (typeof output === "string") {
-    return {
-      default: true,
-      exit: false,
-      target: output
-    };
-  }
-  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);
   });
 }
-var defaultOutputsSchema = z5.array(defaultOutputSchema).default([]).superRefine(validateOutputs);
-var outputsSchema = z5.array(outputSchema).default([]).superRefine(validateOutputs);
-var idSchema = z5.string().uuid().default(() => crypto.randomUUID());
-var metaSchema = z5.record(z5.any()).optional();
-var entryNodeSchema = z5.object({
-  type: z5.literal("entry"),
-  id: z5.literal("__entry__").default("__entry__"),
-  output: defaultOutputsSchema,
-  inputSchema: jsonSchema7Schema.default({ type: "null" }),
-  metaSchema: jsonSchema7Schema.default({ type: "null" }),
-  meta: metaSchema
-});
-var serviceNodeSchema = z5.object({
-  type: z5.literal("service"),
-  output: outputsSchema,
-  inputSchema: z5.union([jsonSchema7ObjectSchema, jsonSchema7NullSchema]).default({ type: "null" }),
-  id: idSchema,
-  name: z5.string(),
-  version: z5.string(),
-  configuration: z5.any().optional(),
-  configurationSchema: jsonSchema7Schema.default({ type: "null" }),
-  alias: z5.string().optional(),
-  ttl: z5.number().int().min(1).optional(),
-  retry: z5.number().int().min(1).optional(),
-  retryDelay: z5.number().int().min(100).optional(),
-  meta: metaSchema
-});
-var catchNodeSchema = z5.object({
-  type: z5.literal("catch"),
-  output: outputsSchema,
-  id: idSchema,
-  subject: z5.string(),
-  meta: metaSchema
-});
-var logicNodeSchema = z5.object({
-  type: z5.literal("logic"),
-  alias: z5.string().optional(),
-  output: outputsSchema,
-  id: idSchema,
-  script: z5.string(),
-  concurrency: z5.boolean().default(true),
-  language: z5.enum(["javascript", "python", "typescript"]).default("javascript"),
-  maxExecutionTime: z5.number().int().min(0).default(1000),
-  meta: metaSchema
-});
-var orNodeSchema = z5.object({
-  id: idSchema,
-  type: z5.literal("or"),
-  alias: z5.string().optional(),
-  output: outputsSchema,
-  meta: metaSchema
-});
-var nodeSchema = z5.discriminatedUnion("type", [
-  entryNodeSchema,
-  serviceNodeSchema,
-  catchNodeSchema,
-  logicNodeSchema,
-  orNodeSchema
-]);
-
-// ../helpers/src/protocol/nodes.ts
-class NodesError extends ZodError {
-  constructor(message, params, path = []) {
-    super([
-      {
-        code: z6.ZodIssueCode.custom,
-        message,
-        path,
-        params
-      }
-    ]);
-  }
-}
-var nodesSchema = z6.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;
-    }
-    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 }]
-    });
-  }
-  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;
-  });
-}).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
-        });
-      }
-      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
-        });
-      }
-      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");
-      }
-    }
-    for (const targetNodeId of getNodeOutputs(node)) {
-      if (targetNodeId !== "__exit__" && !getNode(targetNodeId)) {
-        throw new NodesError("missing node", {
-          id: targetNodeId
-        });
-      }
-    }
-  }
-  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)
-        });
-      }
-    }
-  }
-  return nodes;
-});
 
-// ../helpers/src/protocol/command.ts
-var abortSchema = z7.object({
-  type: z7.literal("ABORT"),
-  reason: z7.string().optional()
-});
-var nodeOptionsSchema = z7.object({
-  maxExecutions: z7.number().int().min(0).optional().default(10),
-  compliance: z7.enum(["mcp-tool"]).nullable().default(null),
-  exitEarly: z7.boolean().optional(),
-  uploadUrl: z7.string().optional(),
-  streamUrl: z7.string().optional()
-});
-var createNodesSchema = z7.object({
-  type: z7.literal("CREATE_NODES"),
-  nodes: nodesSchema,
-  input: z7.any(),
-  meta: z7.any(),
-  options: nodeOptionsSchema
-});
-var commandSchema = z7.union([abortSchema, createNodesSchema]);
+// src/index.ts
+import { z as z5 } from "zod/v4";
 
 // src/createAmqpConnection.ts
 import {
   connect
 } from "amqp-connection-manager";
-import { z as z8 } from "zod";
+import { z as z4 } from "zod/v4";
 
 // src/helpers.ts
 class RetryError extends Error {
@@ -1007,6 +412,9 @@ class RetryError extends Error {
   }
 }
 
+class SkipError extends Error {
+}
+
 class AbortError extends Error {
 }
 var OUTPUT_VALUE = Symbol("output_value");
@@ -1026,28 +434,10 @@ async function unwrapResult(result, options, onDone) {
   };
 }
 function createContextHelper(options) {
-  const nodes = new Map(options.nodes.map((node) => [
-    node.id,
-    Object.assign(node, {
-      executionDate: node.id in options.context.dates ? new Date(options.context.dates[node.id]) : null,
-      data: options.context.data[node.id] ?? null,
-      error: options.context.errors[node.id] ?? null
-    })
-  ]));
   return {
     taskId: options.taskId,
-    getInput() {
-      return options.context.input;
-    },
-    getMeta() {
-      return options.context.meta;
-    },
-    getData() {
-      return Array.from(nodes.values()).filter((result) => result.executionDate && isRecord(result.data)).toSorted((a, b) => a.executionDate.getTime() - b.executionDate.getTime()).reduce((acc, result) => ({
-        ...acc,
-        ...result.data
-      }), isRecord(options.context.input) ? { ...options.context.input } : {});
-    },
+    input: resolveRequenceTypes(options.input),
+    configuration: resolveRequenceTypes(options.configuration),
     toOutput(name, value) {
       return {
         [OUTPUT_VALUE]: name,
@@ -1055,20 +445,6 @@ function createContextHelper(options) {
       };
     },
     defer: options.onDefer,
-    getConfiguration() {
-      const result = nodes.get(options.serviceId);
-      if (result?.type === "service") {
-        return result.configuration ?? null;
-      }
-      return null;
-    },
-    getNode() {
-      return nodes.get(options.serviceId);
-    },
-    getNodes() {
-      return Array.from(nodes.values());
-    },
-    state: createObjectProxy(options.state, options.onStateChange),
     debug: {
       log(...data) {
         options.onLog("log", data);
@@ -1088,6 +464,9 @@ function createContextHelper(options) {
     },
     abort(reason) {
       throw new AbortError(reason);
+    },
+    skip() {
+      throw new SkipError;
     }
   };
 }
@@ -1107,34 +486,31 @@ function mapInput(data) {
 }
 
 // src/createAmqpConnection.ts
-var messageKeySchema = z8.string().transform((str) => deobfuscate(str)).pipe(z8.tuple([z8.string().uuid(), z8.string().uuid(), z8.string().uuid()]).rest(z8.string())).transform((arr) => ({
+var messageKeySchema = z4.string().transform((str) => deobfuscate(str)).pipe(z4.tuple([z4.uuid(), z4.uuid()]).rest(z4.string())).transform((arr) => ({
   taskId: arr[0],
-  serviceId: arr[1],
-  messageId: arr[2],
-  uploadUrl: arr[3] || undefined,
-  streamUrl: arr[4] || undefined
+  messageId: arr[1],
+  uploadUrl: arr[2] || undefined,
+  streamUrl: arr[3] || undefined
 }));
-var headerSchema = z8.object({
-  properties: z8.object({
-    correlationId: z8.string().uuid(),
-    headers: z8.object({
-      version: z8.string(),
-      taskId: z8.string().uuid(),
-      serviceId: z8.string().uuid()
+var headerSchema = z4.object({
+  properties: z4.object({
+    correlationId: z4.uuid(),
+    headers: z4.object({
+      version: z4.string(),
+      taskId: z4.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 = z8.object({ content: z8.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z8.object({
-  context: contextSchema,
-  meta: z8.object({
-    nodes: nodesSchema,
-    state: z8.record(z8.any()),
-    options: nodeOptionsSchema
+var payloadSchema = z4.object({ content: z4.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z4.object({
+  input: z4.unknown(),
+  configuration: z4.unknown(),
+  options: z4.object({
+    uploadUrl: z4.url().optional(),
+    streamUrl: z4.url().optional()
   })
 }));
 function isMessageHandlerGenerator(handler) {
@@ -1196,50 +572,30 @@ function createConnection({
     });
   };
   channel.consume(queue, async (message) => {
-    if (message.properties.headers?.abort || message.properties.headers?.exception) {
-      channel.nack(message, false, false);
-      return;
-    }
     const donePromises = [];
     let removeActiveMessage = () => {};
+    let acked = false;
+    const ack = () => {
+      if (!acked) {
+        acked = true;
+        channel.ack(message);
+      }
+    };
     try {
       let deferred = false;
       let deferredReason = null;
-      const { messageId, serviceId, taskId } = headerSchema.parse(message);
+      const { messageId, 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);
-        }
-      };
-      let immediateUpdateState;
       const extendedContext = createContextHelper({
-        serviceId,
-        context: mapInput(payload.context),
-        nodes: mapInput(payload.meta.nodes),
         taskId,
-        state: payload.meta.state,
-        onStateChange(newState) {
-          clearImmediate(immediateUpdateState);
-          immediateUpdateState = setImmediate(() => {
-            publish({
-              messageId,
-              taskId,
-              serviceId,
-              data: clone(newState),
-              state: true
-            });
-          });
-        },
+        input: mapInput(payload.input),
+        configuration: mapInput(payload.configuration),
         onLog(debugMethod, data) {
           publish({
             messageId,
             taskId,
-            serviceId,
             data,
             debugMethod,
             debug: true
@@ -1249,7 +605,7 @@ function createConnection({
           deferred = true;
           deferredReason = reason || null;
           ack();
-          return obfuscate(taskId, serviceId, messageId, payload.meta.options.uploadUrl ?? "", payload.meta.options.streamUrl ?? "");
+          return obfuscate(taskId, messageId, payload.options.uploadUrl ?? "", payload.options.streamUrl ?? "");
         }
       });
       if (isMessageHandlerGenerator(messageHandler)) {
@@ -1263,12 +619,11 @@ function createConnection({
           }
           const donePromise = createRemotePromise();
           donePromises.push(donePromise);
-          const { value, outputName } = await unwrapResult(result, payload.meta.options, donePromise.resolve);
+          const { value, outputName } = await unwrapResult(result, payload.options, donePromise.resolve);
           if (!done || typeof value !== "undefined") {
             publish({
               messageId,
               taskId,
-              serviceId,
               data: value,
               outputName
             });
@@ -1282,7 +637,7 @@ function createConnection({
         ack();
         const donePromise = createRemotePromise();
         donePromises.push(donePromise);
-        const { value, outputName } = await unwrapResult(result, payload.meta.options, donePromise.resolve);
+        const { value, outputName } = await unwrapResult(result, payload.options, donePromise.resolve);
         if (deferred && value) {
           console.warn("returning a value in a deferred message resets the deferred status");
           deferred = false;
@@ -1291,7 +646,6 @@ function createConnection({
           publish({
             messageId,
             taskId,
-            serviceId,
             data: value,
             outputName
           });
@@ -1304,34 +658,49 @@ function createConnection({
         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);
+      const assertNack = (message2) => {
+        if (acked) {
+          console.error(message2);
+          return false;
+        }
+        return true;
+      };
+      if (error instanceof SkipError) {
+        if (assertNack("data already send, cannot skip")) {
+          channel.nack(message);
+        }
         return;
       }
+      if (error instanceof RetryError) {
+        if (assertNack("data already send, cannot retry")) {
+          const properties = {
+            ...message.properties,
+            expiration: error.delay || 1000
+          };
+          channel.publish(`${exchange}-retry`, "retry", message.content, properties);
+          ack();
+        }
+      }
       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
-          }
-        });
-        channel.ack(message);
+        if (assertNack("data already send, cannot abort")) {
+          channel.publish(`${exchange}-retry`, "operator", error.message, {
+            ...message.properties,
+            expiration: 0,
+            priority: 0,
+            contentType: "text/plain",
+            headers: {
+              ...message.properties.headers,
+              abort: true
+            }
+          });
+          ack();
+        }
         return;
       }
       if (error instanceof Error) {
@@ -1339,20 +708,24 @@ function createConnection({
           console.error(`Encountered an error inside service handler:`);
           console.error(error);
         }
-        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);
+        if (!acked) {
+          channel.publish(`${exchange}-retry`, "operator", 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;
       }
-      channel.nack(message, false, false);
+      if (!acked) {
+        channel.nack(message, false, false);
+      }
     } finally {
       removeActiveMessage();
     }
@@ -1364,7 +737,7 @@ function createConnection({
     },
     open: () => connectedPromise.then(() => api),
     async act(messageKey, actor) {
-      const { taskId, serviceId, messageId, ...options } = messageKeySchema.parse(messageKey);
+      const { taskId, messageId, ...options } = messageKeySchema.parse(messageKey);
       if (activeMessages.has(messageId)) {
         throw new Error("Cannot send deferred message while callback handler is still running");
       }
@@ -1376,7 +749,6 @@ function createConnection({
           publish({
             messageId,
             taskId,
-            serviceId,
             data: await mapOutput({
               value: data,
               options,
@@ -1391,7 +763,6 @@ function createConnection({
           publish({
             messageId,
             taskId,
-            serviceId,
             data: await mapOutput({
               value: data,
               options,
@@ -1400,14 +771,13 @@ function createConnection({
           });
         },
         abort(error) {
-          channel.publish(`${exchange}-retry`, "requeue", error instanceof Error ? error.message : error, {
+          channel.publish(`${exchange}-retry`, "operator", error instanceof Error ? error.message : error, {
             correlationId: messageId,
             expiration: 0,
             priority: 0,
             contentType: "text/plain",
             headers: {
               taskId,
-              serviceId,
               abort: true
             }
           });
@@ -1418,7 +788,6 @@ function createConnection({
         publish({
           messageId,
           taskId,
-          serviceId,
           done: true
         });
       });
@@ -1428,16 +797,16 @@ function createConnection({
 }
 
 // src/index.ts
-var connectionOptionsSchema = z9.object({
-  url: z9.union([
-    z9.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
-    z9.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+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: z9.string(),
-  silent: z9.boolean().optional(),
-  prefetch: z9.number().int().optional(),
-  connectionTimeout: z9.number().positive().default(3000),
-  connectionOptions: z9.any()
+  version: z5.string(),
+  silent: z5.boolean().optional(),
+  prefetch: z5.number().int().optional(),
+  connectionTimeout: z5.number().positive().default(3000),
+  connectionOptions: z5.any()
 });
 function createService(optionsOrVersion, optionalMessageHandler) {
   let options;
@@ -1475,5 +844,5 @@ export {
   RequenceFile
 };
 
-//# debugId=23912C23C759229364756E2164756E21
+//# debugId=C95DB017F5DE792D64756E2164756E21
 //# sourceMappingURL=index.js.map