@requence/task 0.7.1

package/build/index.js

@@ -0,0 +1,1134 @@
+import {
+  deobfuscate
+} from "./chunk-b4h2we9a.js";
+
+// ../helpers/src/utils/callbackToAsyncIterator.ts
+function callbackToAsyncIterator(subscribe) {
+  const pullQueue = [];
+  const pushQueue = [];
+  let done = false;
+  const pushValue = (value) => {
+    if (pullQueue.length !== 0) {
+      const resolver = pullQueue.shift();
+      resolver(value);
+    } else {
+      pushQueue.push(value);
+    }
+  };
+  const pullValue = () => new Promise((resolve) => {
+    if (pushQueue.length !== 0) {
+      resolve(pushQueue.shift());
+    } else {
+      pullQueue.push(resolve);
+    }
+  });
+  const cleanup = subscribe((value) => {
+    if (!done) {
+      pushValue({ value });
+    }
+  }, (error) => {
+    if (!done) {
+      pushValue({ error });
+    }
+  }, () => {
+    if (!done) {
+      pushValue({ done: true });
+    }
+  });
+  return {
+    async next() {
+      if (done) {
+        return { value: undefined, done: true };
+      }
+      const value = await pullValue();
+      if (value.done) {
+        done = true;
+        return { value: undefined, done: true };
+      }
+      if (value.error) {
+        done = true;
+        throw value.error;
+      }
+      return { value: value.value, done: false };
+    },
+    async return() {
+      if (!done) {
+        done = true;
+        if (typeof cleanup === "function") {
+          cleanup();
+        }
+        while (pullQueue.length > 0) {
+          const resolver = pullQueue.shift();
+          resolver({ done: true });
+        }
+      }
+      return { value: undefined, done: true };
+    }
+  };
+}
+function callbackToAsyncIterable(...args) {
+  let iterator;
+  return {
+    [Symbol.asyncIterator]() {
+      iterator ??= callbackToAsyncIterator(...args);
+      return iterator;
+    }
+  };
+}
+
+// ../helpers/src/utils/guards.ts
+import { z } from "zod/v4";
+var recordSchema = z.record(z.string(), z.unknown());
+function isRecord(data) {
+  return recordSchema.safeParse(data).success;
+}
+var uuidSchema = z.uuid();
+
+// ../helpers/src/utils/mapData.ts
+function resolve(value, onResolve) {
+  if (value instanceof Promise) {
+    return Promise.resolve().then(() => value).then(onResolve);
+  }
+  return onResolve(value);
+}
+function notUndefined(value, fallback) {
+  return resolve(value, (resolvedValue) => typeof resolvedValue === "undefined" ? fallback : resolvedValue);
+}
+
+class AbortMapData extends Error {
+}
+function mapData(data, visitors) {
+  let aborted = false;
+  const traverseData = (data2, path) => {
+    if (aborted) {
+      return data2;
+    }
+    try {
+      if (Array.isArray(data2)) {
+        return resolve(visitors.Array?.(data2, path), (resolvedData) => {
+          if (resolvedData) {
+            return resolvedData;
+          }
+          const items = data2.map((item, index) => traverseData(item, [...path, index]));
+          if (items.some((item) => item instanceof Promise)) {
+            return Promise.all(items);
+          }
+          return items;
+        });
+      }
+      if (data2 === null) {
+        return notUndefined(visitors.Null?.(data2, path), data2);
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(data2)) {
+        return notUndefined(visitors.Buffer?.(data2, path), data2);
+      }
+      if (typeof data2 === "string") {
+        return notUndefined(visitors.String?.(data2, path), data2);
+      }
+      if (typeof data2 === "number") {
+        return notUndefined(visitors.Number?.(data2, path), data2);
+      }
+      if (typeof data2 === "symbol") {
+        return notUndefined(visitors.Symbol?.(data2, path), data2);
+      }
+      if (typeof data2 === "function") {
+        return notUndefined(visitors.Function?.(data2, path), data2);
+      }
+      if (isRecord(data2)) {
+        return resolve(visitors.Object?.(structuredClone(data2), path), (resolvedData) => {
+          const nextData = resolvedData ?? data2;
+          if (!isRecord(nextData)) {
+            return nextData;
+          }
+          const entries = Object.entries(nextData).map(([key, value]) => [
+            key,
+            traverseData(value, [...path, key])
+          ]);
+          if (entries.some(([, value]) => value instanceof Promise)) {
+            return Promise.all(entries.map(([key, value]) => Promise.resolve().then(() => value).then((resolvedValue) => [key, resolvedValue]))).then((entries2) => Object.fromEntries(entries2));
+          }
+          return Object.fromEntries(entries);
+        });
+      }
+      if (typeof data2 === "object" && data2) {
+        return notUndefined(visitors.Object?.(data2, path), data2);
+      }
+      return data2;
+    } catch (error) {
+      if (error instanceof AbortMapData) {
+        aborted = true;
+        return data2;
+      }
+      throw error;
+    }
+  };
+  return traverseData(data, []);
+}
+mapData.abort = () => {
+  throw new AbortMapData;
+};
+
+// ../helpers/src/utils/requenceCallback.ts
+import { z as z2 } from "zod/v4";
+var callbackObjectSchema = z2.object({
+  sourceId: z2.string(),
+  outputName: z2.string().nullable(),
+  propertyPath: z2.array(z2.union([z2.string(), z2.int()])),
+  callbackId: z2.uuid(),
+  __REQUENCE_type: z2.literal("RequenceCallback")
+});
+function isCallbackObject(data) {
+  return callbackObjectSchema.safeParse(data).success;
+}
+
+// ../helpers/src/files/fileObject.ts
+import { z as z3 } from "zod/v4";
+var fileObjectSchema = z3.object({
+  size: z3.int().positive(),
+  mime: z3.string(),
+  url: z3.url(),
+  __REQUENCE_type: z3.literal("RequenceFile")
+});
+function toFileObject(fileInfo) {
+  return {
+    ...fileInfo,
+    __REQUENCE_type: "RequenceFile"
+  };
+}
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
+}
+
+// ../helpers/src/files/RequenceFile.ts
+class RequenceFile {
+  #data;
+  #file = null;
+  constructor(blobParts, options) {
+    this.#data = new Blob(blobParts, options);
+  }
+  static fromFileObject(file) {
+    const instance = new this([], { type: "x/x" });
+    instance.#file = file;
+    return instance;
+  }
+  get fileObject() {
+    return this.#file;
+  }
+  get size() {
+    return this.#file?.size ?? this.#data.size;
+  }
+  get mimeType() {
+    return this.#file?.mime ?? this.#data.type;
+  }
+  get mainMimeType() {
+    return this.mimeType.split("/")[0];
+  }
+  get subMimeType() {
+    return this.mimeType.split("/")[1];
+  }
+  async text() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.text());
+    }
+    return this.#data.text();
+  }
+  async json() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.json());
+    }
+    return JSON.parse(await this.text());
+  }
+  async blob() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.blob());
+    }
+    return this.#data;
+  }
+  async arrayBuffer() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.arrayBuffer());
+    }
+    return this.#data.arrayBuffer();
+  }
+  toString() {
+    return `RequenceFile<${this.mimeType}>`;
+  }
+  toJSON() {
+    return `RequenceFile<${this.mimeType}>`;
+  }
+}
+
+// ../helpers/src/files/RequenceStream.ts
+class RequenceStream {
+  #data;
+  #stream = null;
+  #options;
+  constructor(stream, options) {
+    this.#data = stream;
+    this.#options = options;
+  }
+  static fromStreamObject(stream) {
+    const instance = new this(null, {
+      type: "x/x"
+    });
+    instance.#stream = stream;
+    return instance;
+  }
+  get streamObject() {
+    return this.#stream;
+  }
+  get mimeType() {
+    return this.#stream?.mime ?? this.#options.type;
+  }
+  get mainMimeType() {
+    return this.mimeType.split("/")[0];
+  }
+  get subMimeType() {
+    return this.mimeType.split("/")[1];
+  }
+  stream() {
+    if (this.#stream) {
+      const { readable, writable } = new TransformStream;
+      fetch(this.#stream.url).then((response) => response.body?.pipeTo(writable));
+      return readable;
+    }
+    return this.#data;
+  }
+  asyncIterable() {
+    const reader = this.stream().getReader();
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            return reader.read();
+          },
+          async return() {
+            reader.cancel();
+            reader.releaseLock();
+            return { done: true, value: null };
+          }
+        };
+      }
+    };
+  }
+  toString() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
+  toJSON() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
+}
+
+// ../helpers/src/files/streamObject.ts
+import { z as z4 } from "zod/v4";
+var streamObjectSchema = z4.object({
+  mime: z4.string(),
+  url: z4.string().url(),
+  __REQUENCE_type: z4.literal("RequenceStream")
+});
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
+function toStreamObject(streamInfo) {
+  return {
+    ...streamInfo,
+    __REQUENCE_type: "RequenceStream"
+  };
+}
+
+// ../helpers/src/files/mapOutput.ts
+async function upload(uploadUrl, body, signal, contentType) {
+  const uploadResponse = await fetch(uploadUrl, {
+    method: "POST",
+    signal,
+    headers: contentType ? {
+      "Content-Type": contentType
+    } : {},
+    body
+  });
+  const data = await uploadResponse.json();
+  if (!data || typeof data !== "object") {
+    throw new Error("invalid upload response");
+  }
+  return toFileObject(data);
+}
+async function stream(streamUrl, stream2, signal, contentType) {
+  const [testStream, dataStream] = stream2.tee();
+  const reader = testStream.getReader();
+  const dataPromise = reader.read().then(({ done: done2 }) => {
+    if (done2) {
+      throw new Error("No streaming date received");
+    }
+    reader.cancel();
+  });
+  const streamResponse = await fetch(streamUrl, {
+    method: "POST",
+    signal,
+    headers: contentType ? { "Content-Type": contentType } : {}
+  });
+  const data = await streamResponse.json();
+  if (!data || typeof data !== "object") {
+    throw new Error("invalid stream response");
+  }
+  const { mime, url } = data;
+  await dataPromise;
+  const done = fetch(url, {
+    method: "POST",
+    signal,
+    duplex: "half",
+    body: dataStream
+  });
+  return [toStreamObject({ mime, url }), done];
+}
+async function mapOutput(params) {
+  const streamPromises = [];
+  const mapped = await mapData(params.value, {
+    async Object(obj) {
+      if (obj instanceof Blob || obj instanceof RequenceFile) {
+        if (obj instanceof RequenceFile && obj.fileObject) {
+          return obj.fileObject;
+        }
+        if (params.options.uploadUrl) {
+          try {
+            if (obj instanceof Blob) {
+              return await upload(params.options.uploadUrl, obj, params.signal, obj.type);
+            }
+            if (obj instanceof RequenceFile) {
+              return await upload(params.options.uploadUrl, await obj.blob(), params.signal, obj.mimeType);
+            }
+          } catch (error) {
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            params.onFail?.(error);
+            return null;
+          }
+        } else {
+          params.onSkip?.();
+          return null;
+        }
+      }
+      if (obj instanceof Response || obj instanceof RequenceStream) {
+        if (obj instanceof RequenceStream && obj.streamObject) {
+          return obj.streamObject;
+        }
+        if (params.options.streamUrl) {
+          try {
+            if (obj instanceof Response && obj.body) {
+              const [streamObject, streamPromise] = await stream(params.options.streamUrl, obj.body, params.signal, obj.headers.get("Content-Type"));
+              streamPromises.push(streamPromise);
+              return streamObject;
+            }
+            if (obj instanceof RequenceStream) {
+              const [streamObject, streamPromise] = await stream(params.options.streamUrl, obj.stream(), params.signal, obj.mimeType);
+              streamPromises.push(streamPromise);
+              return streamObject;
+            }
+          } catch (error) {
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            params.onFail?.(error);
+            return null;
+          }
+        } else {
+          params.onSkip?.();
+          return null;
+        }
+      }
+    }
+  });
+  Promise.allSettled(streamPromises).then(() => params.onDone?.());
+  return mapped;
+}
+
+// ../helpers/src/utils/resolveRequenceTypes.ts
+function resolveRequenceTypes(data, onCallback) {
+  return mapData(data, {
+    Object(obj) {
+      if (isFileObject(obj)) {
+        return RequenceFile.fromFileObject(obj);
+      }
+      if (isStreamObject(obj)) {
+        return RequenceStream.fromStreamObject(obj);
+      }
+      if (isCallbackObject(obj)) {
+        return (arg) => {
+          onCallback?.({ ...obj, arg });
+        };
+      }
+    }
+  });
+}
+
+// src/createTask.ts
+import chalk from "chalk";
+import { createEventSource } from "eventsource-client";
+
+// src/utils/getAccessToken.ts
+import { readFileSync } from "node:fs";
+function getAccessToken(accessToken) {
+  let token = accessToken ?? process.env.REQUENCE_TASK_ACCESS_TOKEN ?? process.env.REQUENCE_ACCESS_TOKEN;
+  if (!token) {
+    const pkgJson = JSON.parse(readFileSync("package.json", "utf-8"));
+    token = pkgJson.requence?.task?.accessToken ?? pkgJson.requence?.accessToken;
+  }
+  if (!token) {
+    throw new Error(`No access token found
+You can provide the access token as argument to createTask,
+as environment variable REQUENCE_ACCESS_TOKEN or
+in your package.json in requence.accessToken`);
+  }
+  const parts = deobfuscate(token);
+  if (parts.length < 2 || parts[0] !== "api") {
+    throw new Error("Invalid access token");
+  }
+  return {
+    token: parts[1],
+    apiBaseUrl: parts[2]
+  };
+}
+
+// src/abortTask.ts
+class TaskAbortError extends Error {
+  taskId;
+  constructor(message, taskId) {
+    super(message);
+    this.taskId = taskId;
+  }
+}
+async function abortTask(options) {
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const abortUrl = `${apiBaseUrl}/task/abort/${options.taskId}`;
+  const response = await fetch(abortUrl, {
+    method: "POST",
+    body: options.reason ?? "",
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new TaskAbortError(await response.text(), options.taskId);
+  }
+}
+
+// src/ackTask.ts
+async function ackTask(options) {
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const response = await fetch(`${apiBaseUrl}/task/ack/${options.taskId}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to acknowledge task delivery: ${await response.text()}`);
+  }
+}
+
+// src/protectTask.ts
+class TaskProtectError extends Error {
+  taskId;
+  constructor(message, taskId) {
+    super(message);
+    this.taskId = taskId;
+  }
+}
+async function protectTask(options) {
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const protectUrl = `${apiBaseUrl}/task/protect/${options.taskId}`;
+  const response = await fetch(protectUrl, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new TaskProtectError(await response.text(), options.taskId);
+  }
+}
+
+// src/types.ts
+import { z as z5 } from "zod/v4";
+var nodeInfoSchema = z5.object({
+  id: z5.uuid(),
+  type: z5.literal(["service", "logic", "or", "reference"]),
+  alias: z5.string().optional()
+});
+var baseUpdate = z5.object({
+  timestamp: z5.coerce.date(),
+  taskId: z5.uuid(),
+  name: z5.string(),
+  updateId: z5.uuid()
+});
+var taskStartUpdateSchema = baseUpdate.extend({
+  type: z5.literal("taskStart"),
+  input: z5.unknown(),
+  rootTaskId: z5.uuid().nullable().default(null)
+});
+var taskErrorUpdateSchema = baseUpdate.extend({
+  type: z5.literal("taskError"),
+  reason: z5.string().optional(),
+  requireAck: z5.boolean().optional()
+});
+var taskAbortUpdateSchema = baseUpdate.extend({
+  type: z5.literal("taskAborted"),
+  reason: z5.string().optional(),
+  requireAck: z5.boolean().optional()
+});
+var taskEndUpdateSchema = baseUpdate.extend({
+  type: z5.literal("taskEnd"),
+  result: z5.record(z5.string(), z5.any()),
+  exit: z5.string().nullable(),
+  requireAck: z5.boolean().optional()
+});
+var nodeStartUpdateSchema = baseUpdate.extend({
+  type: z5.literal("nodeStart"),
+  node: nodeInfoSchema
+});
+var nodeUpdateUpdateSchema = baseUpdate.extend({
+  type: z5.literal("nodeUpdate"),
+  node: nodeInfoSchema,
+  data: z5.unknown(),
+  output: z5.union([z5.null(), z5.string()])
+});
+var nodeErrorUpdateSchema = baseUpdate.extend({
+  type: z5.literal("nodeError"),
+  node: nodeInfoSchema,
+  error: z5.string()
+});
+var nodeDeferUpdateSchema = baseUpdate.extend({
+  type: z5.literal("nodeDefer"),
+  node: nodeInfoSchema,
+  reason: z5.string().optional()
+});
+var nodeEndUpdateSchema = baseUpdate.extend({
+  type: z5.literal("nodeEnd"),
+  node: nodeInfoSchema
+});
+var updateSchema = z5.discriminatedUnion("type", [
+  taskStartUpdateSchema,
+  taskErrorUpdateSchema,
+  taskAbortUpdateSchema,
+  taskEndUpdateSchema,
+  nodeStartUpdateSchema,
+  nodeUpdateUpdateSchema,
+  nodeErrorUpdateSchema,
+  nodeDeferUpdateSchema,
+  nodeEndUpdateSchema
+]);
+var eventSchema = z5.object({ event: z5.string(), data: z5.string() }).transform((event) => ({ type: event.event, ...JSON.parse(event.data) })).pipe(updateSchema);
+var prioritySchema = z5.int("priority has to be an integer").min(0, "min priority is 0").max(4, "max priority is 4").default(2).transform((value) => Math.round((4 - value) * 10 / 4));
+
+// src/createTask.ts
+class TaskPrepareError extends Error {
+  taskTemplate;
+  constructor(message, taskTemplate) {
+    super(message);
+    this.taskTemplate = taskTemplate;
+  }
+}
+
+class TaskError extends TaskPrepareError {
+  taskTemplate;
+  taskId;
+  constructor(message, taskTemplate, taskId) {
+    super(message, taskTemplate);
+    this.taskTemplate = taskTemplate;
+    this.taskId = taskId;
+  }
+}
+function createTask(options, onUpdate) {
+  const taskUpdateHandlers = new Set;
+  const priority = prioritySchema.parse(options.priority);
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const prepareUrl = `${apiBaseUrl}/task/prepare/${options.taskTemplate}`;
+  const payloadPromiseWithResolvers = Promise.withResolvers();
+  let isMonitoring = false;
+  const startMonitoring = async () => {
+    if (isMonitoring) {
+      return;
+    }
+    isMonitoring = true;
+    const payload = await payloadPromiseWithResolvers.promise;
+    if (!payload.urls) {
+      resultPromiseWithResolvers.resolve({
+        input: options.input,
+        taskId: payload.taskId,
+        taskUrl: "",
+        result: null,
+        getNodeData(_alias) {
+          return null;
+        },
+        getNodeError(_alias) {
+          return null;
+        }
+      });
+      return;
+    }
+    const taskStorage = { input: null, data: {}, errors: {}, result: null };
+    let since = null;
+    let lastPosition = null;
+    let lastResponse;
+    const customFetch = async (url, init) => {
+      const response = await fetch(url, init);
+      lastResponse = response;
+      return response;
+    };
+    const eventSource = createEventSource({
+      method: "POST",
+      fetch: customFetch,
+      url: payload.urls.watch,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      get body() {
+        return JSON.stringify({
+          since: since ? since.toISOString() : null,
+          lastPosition
+        });
+      },
+      onScheduleReconnect() {
+        if (lastPosition === null) {
+          since = new Date;
+        }
+      },
+      async onDisconnect() {
+        if (lastResponse.status === 200) {
+          eventSource.close();
+        }
+      },
+      onMessage({ id, event, data }) {
+        if (id) {
+          lastPosition = Number(id);
+        }
+        const updateResult = eventSchema.safeParse({ event, data });
+        if (!updateResult.success) {
+          eventSource.close();
+          resultPromiseWithResolvers.reject(new TaskError(`Invalid ${event} update received`, options.taskTemplate, payload.taskId));
+          return;
+        }
+        const update = updateResult.data;
+        switch (update.type) {
+          case "taskStart": {
+            taskStorage.input = resolveRequenceTypes(update.input, () => {
+              throw new Error("input may not have callbacks");
+            });
+            break;
+          }
+          case "nodeUpdate": {
+            if (update.node.alias) {
+              taskStorage.data[update.node.alias] = resolveRequenceTypes(update.data);
+            }
+            break;
+          }
+          case "nodeError": {
+            if (update.node.alias) {
+              taskStorage.errors[update.node.alias] = update.error;
+            }
+            break;
+          }
+          case "taskEnd": {
+            taskStorage.result = resolveRequenceTypes(update.result);
+            eventSource.close();
+            if (update.requireAck) {
+              ackTask({
+                taskId: payload.taskId,
+                accessToken: options.accessToken
+              }).catch(() => {});
+            }
+            break;
+          }
+          case "taskError":
+          case "taskAborted": {
+            eventSource.close();
+            if (update.requireAck) {
+              ackTask({
+                taskId: payload.taskId,
+                accessToken: options.accessToken
+              }).catch(() => {});
+            }
+            break;
+          }
+        }
+        const context = {
+          taskId: update.taskId,
+          input: taskStorage.input,
+          getNodeData(alias) {
+            return taskStorage.data[alias] ?? null;
+          },
+          getNodeError(alias) {
+            return taskStorage.errors[alias] ?? null;
+          },
+          result: taskStorage.result
+        };
+        const contextUpdate = {
+          ...update,
+          context
+        };
+        if (contextUpdate.type === "taskEnd") {
+          resultPromiseWithResolvers.resolve({
+            ...context,
+            taskUrl: payload.urls?.show ?? ""
+          });
+        }
+        if (contextUpdate.type === "taskError" || contextUpdate.type === "taskAborted") {
+          resultPromiseWithResolvers.reject(new TaskError(contextUpdate.reason ?? (contextUpdate.type === "taskError" ? "Task failed" : "Task aborted"), options.taskTemplate, payload.taskId));
+        }
+        taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
+      }
+    });
+  };
+  const taskIdPromiseWithResolvers = Promise.withResolvers();
+  const taskUrlPromiseWithResolvers = Promise.withResolvers();
+  const resultPromiseWithResolvers = Promise.withResolvers();
+  const finalizedPromiseWithResolvers = Promise.withResolvers();
+  finalizedPromiseWithResolvers.promise.catch(() => {});
+  let rejectTaskIdPromise = false;
+  let rejectTaskUrlPromise = false;
+  (async () => {
+    const prepareResponse = await fetch(prepareUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!prepareResponse.ok) {
+      const error = new TaskPrepareError(await prepareResponse.text(), options.taskTemplate);
+      finalizedPromiseWithResolvers.reject(error);
+      if (rejectTaskIdPromise) {
+        taskIdPromiseWithResolvers.reject(error);
+      }
+      if (rejectTaskUrlPromise) {
+        taskUrlPromiseWithResolvers.reject(error);
+      }
+      if (isMonitoring) {
+        resultPromiseWithResolvers.reject(error);
+      }
+      return;
+    }
+    const prepareData = await prepareResponse.json();
+    if (prepareData.branch !== "live" && !options.suppressBranchWarning) {
+      console.warn(chalk.hex("#eab308")("task is executed in", chalk.bold(prepareData.branch), "branch"));
+    }
+    taskIdPromiseWithResolvers.resolve(prepareData.taskId);
+    const mappedParams = await mapOutput({
+      value: {
+        name: options.name,
+        input: options.input,
+        priority,
+        requireAck: options.requireAck ?? false
+      },
+      options: {
+        uploadUrl: prepareData.fileUrls?.uploadUrl,
+        streamUrl: prepareData.fileUrls?.streamUrl
+      }
+    });
+    const finalizeResponse = await fetch(prepareData.finalizeUrl, {
+      method: "POST",
+      body: JSON.stringify(mappedParams),
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!finalizeResponse.ok) {
+      const error = new TaskError(await finalizeResponse.text(), options.taskTemplate, prepareData.taskId);
+      finalizedPromiseWithResolvers.reject(error);
+      if (rejectTaskUrlPromise) {
+        taskUrlPromiseWithResolvers.reject(error);
+      }
+      if (isMonitoring) {
+        resultPromiseWithResolvers.reject(error);
+      }
+      return;
+    }
+    const payload = await finalizeResponse.json();
+    finalizedPromiseWithResolvers.resolve(prepareData.taskId);
+    taskUrlPromiseWithResolvers.resolve(payload.urls?.show ?? null);
+    payloadPromiseWithResolvers.resolve(payload);
+    if (onUpdate) {
+      taskUpdateHandlers.add(onUpdate);
+      startMonitoring();
+    }
+  })();
+  const asyncIterable = callbackToAsyncIterable((push, _fail, done) => {
+    const handleUpdate = (update) => {
+      push(update);
+      if (update.type === "taskEnd" || update.type === "taskError" || update.type === "taskAborted") {
+        done();
+        taskUpdateHandlers.delete(handleUpdate);
+      }
+    };
+    taskUpdateHandlers.add(handleUpdate);
+    startMonitoring();
+    return () => {
+      taskUpdateHandlers.delete(handleUpdate);
+    };
+  });
+  const methods = {
+    get catch() {
+      startMonitoring();
+      return resultPromiseWithResolvers.promise.catch.bind(resultPromiseWithResolvers.promise);
+    },
+    get finally() {
+      startMonitoring();
+      return resultPromiseWithResolvers.promise.finally.bind(resultPromiseWithResolvers.promise);
+    },
+    get then() {
+      startMonitoring();
+      return resultPromiseWithResolvers.promise.then.bind(resultPromiseWithResolvers.promise);
+    },
+    async getTaskId() {
+      rejectTaskIdPromise = true;
+      return taskIdPromiseWithResolvers.promise;
+    },
+    async getTaskUrl() {
+      rejectTaskUrlPromise = true;
+      return taskUrlPromiseWithResolvers.promise;
+    },
+    async abort(reason) {
+      const taskId = await taskIdPromiseWithResolvers.promise;
+      await abortTask({
+        taskId,
+        accessToken: options.accessToken,
+        reason
+      });
+    },
+    async protect() {
+      const taskId = await taskIdPromiseWithResolvers.promise;
+      await protectTask({
+        taskId,
+        accessToken: options.accessToken
+      });
+    },
+    async finalized() {
+      return finalizedPromiseWithResolvers.promise;
+    }
+  };
+  return Object.defineProperties(asyncIterable, Object.getOwnPropertyDescriptors(methods));
+}
+// src/watchTasks.ts
+import { createEventSource as createEventSource2 } from "eventsource-client";
+function watchTasks(options) {
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const taskUpdateHandlers = new Set;
+  if (options.onUpdate) {
+    taskUpdateHandlers.add(options.onUpdate);
+  }
+  const taskStorage = new Map;
+  let startDate = options.since;
+  let lastPosition = null;
+  let lastResponse;
+  const customFetch = async (url, init) => {
+    const response = await fetch(url, init);
+    lastResponse = response;
+    return response;
+  };
+  const eventSource = createEventSource2({
+    url: new URL(`${apiBaseUrl}/task/watch-all`),
+    fetch: customFetch,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    get body() {
+      return JSON.stringify({
+        since: startDate.toISOString(),
+        lastPosition,
+        filter: options.filter
+      });
+    },
+    method: "POST",
+    onScheduleReconnect() {
+      if (lastPosition === null) {
+        startDate = new Date;
+      }
+      options.onReconnecting?.();
+    },
+    onConnect() {
+      options.onConnect?.();
+    },
+    async onDisconnect() {
+      if (lastResponse) {
+        options.onError?.(lastResponse.status, lastResponse.statusText);
+      }
+    },
+    onMessage({ id, event, data }) {
+      if (id) {
+        lastPosition = Number(id);
+      }
+      const updateResult = eventSchema.safeParse({ event, data });
+      if (!updateResult.success) {
+        eventSource.close();
+        throw new Error("invalid update");
+      }
+      const update = updateResult.data;
+      if (!taskStorage.has(update.taskId)) {
+        taskStorage.set(update.taskId, {
+          input: null,
+          data: {},
+          errors: {},
+          result: null,
+          incomplete: true,
+          rootTaskId: null
+        });
+      }
+      const storageEntry = taskStorage.get(update.taskId);
+      switch (update.type) {
+        case "taskStart": {
+          storageEntry.input = resolveRequenceTypes(update.input, () => {
+            throw new Error("input may not have callbacks");
+          });
+          storageEntry.incomplete = false;
+          storageEntry.rootTaskId = update.rootTaskId;
+          break;
+        }
+        case "nodeUpdate": {
+          if (update.node.alias) {
+            storageEntry.data[update.node.alias] = resolveRequenceTypes(update.data);
+          }
+          break;
+        }
+        case "nodeError": {
+          if (update.node.alias) {
+            storageEntry.errors[update.node.alias] = update.error;
+          }
+          break;
+        }
+        case "taskEnd": {
+          storageEntry.result = resolveRequenceTypes(update.result);
+          taskStorage.delete(update.taskId);
+          if (update.requireAck) {
+            ackTask({
+              taskId: update.taskId,
+              accessToken: options.accessToken
+            }).catch(() => {});
+          }
+          break;
+        }
+        case "taskError":
+        case "taskAborted": {
+          taskStorage.delete(update.taskId);
+          if (update.requireAck) {
+            ackTask({
+              taskId: update.taskId,
+              accessToken: options.accessToken
+            }).catch(() => {});
+          }
+          break;
+        }
+      }
+      const context = {
+        taskId: update.taskId,
+        input: storageEntry.input,
+        getNodeData(alias) {
+          return storageEntry.data[alias] ?? null;
+        },
+        getNodeError(alias) {
+          return storageEntry.errors[alias] ?? null;
+        },
+        result: storageEntry.result
+      };
+      const contextUpdate = {
+        ...update,
+        context,
+        updateId: id,
+        incomplete: storageEntry.incomplete,
+        rootTaskId: storageEntry.rootTaskId
+      };
+      taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
+    }
+  });
+  const asyncIterable = callbackToAsyncIterable((push) => {
+    taskUpdateHandlers.add(push);
+    return () => {
+      taskUpdateHandlers.delete(push);
+    };
+  });
+  const stopWatching = () => {
+    eventSource.close();
+  };
+  return Object.assign(stopWatching, asyncIterable);
+}
+// src/getTask.ts
+import { z as z6 } from "zod/v4";
+var taskSchema = z6.object({
+  status: z6.literal([
+    "SUCCESSFUL",
+    "FAILED",
+    "IDLE",
+    "PENDING",
+    "RUNNING",
+    "STOPPED",
+    "AWAITING_DELIVERY"
+  ]),
+  statusText: z6.string().nullable(),
+  input: z6.unknown(),
+  result: z6.unknown(),
+  taskTemplate: z6.string(),
+  name: z6.string(),
+  nodesData: z6.array(z6.object({ alias: z6.string(), data: z6.unknown() })),
+  nodesError: z6.array(z6.object({ alias: z6.string(), error: z6.string() })),
+  branch: z6.union([z6.literal("live"), z6.string()])
+});
+async function getTask(taskIdOrOptions) {
+  const taskId = typeof taskIdOrOptions === "string" ? taskIdOrOptions : taskIdOrOptions.taskId;
+  const { apiBaseUrl, token } = getAccessToken(typeof taskIdOrOptions === "string" ? undefined : taskIdOrOptions.accessToken);
+  const response = await fetch(new URL(`${apiBaseUrl}/task/${taskId}`), {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error("Task not found");
+  }
+  const taskData = taskSchema.parse(await response.json());
+  const context = {
+    taskId,
+    input: resolveRequenceTypes(taskData.input, () => {
+      throw new Error("input may not have callbacks");
+    }),
+    getNodeData(alias) {
+      return resolveRequenceTypes(taskData.nodesData.find((d) => d.alias === alias)?.data);
+    },
+    getNodeError(alias) {
+      return taskData.nodesError.find((d) => d.alias === alias)?.error ?? null;
+    },
+    result: resolveRequenceTypes(taskData.result)
+  };
+  return {
+    status: taskData.status,
+    statusText: taskData.statusText,
+    taskTemplate: taskData.taskTemplate,
+    name: taskData.name,
+    branch: taskData.branch,
+    context
+  };
+}
+// src/recreateTask.ts
+async function recreateTask(options, onUpdate) {
+  const task = await getTask(options.taskId);
+  return createTask({
+    taskTemplate: task.taskTemplate,
+    accessToken: options.accessToken,
+    name: options.name ?? task.name,
+    priority: options.priority,
+    input: task.context.input
+  }, onUpdate);
+}
+export {
+  watchTasks,
+  recreateTask,
+  protectTask,
+  getTask,
+  createTask,
+  abortTask,
+  TaskError,
+  RequenceStream,
+  RequenceFile
+};
+
+//# debugId=72085AB5595C0E1D64756E2164756E21
+//# sourceMappingURL=index.js.map