@requence/task 1.0.0-alpha.4 → 1.0.0-alpha.41

package/build/index.js

@@ -1,92 +1,9 @@
 import {
-  createRemotePromise,
   deobfuscate
-} from "./chunk-6pjtq0hg.js";
+} from "./chunk-y4v98p2s.js";
 
-// src/createTask.ts
-import { EventSource } from "eventsource";
-
-// src/types.ts
-import { z } from "zod";
-var serviceNodeInfoSchema = z.object({
-  id: z.string().uuid(),
-  type: z.literal("service"),
-  alias: z.string().optional(),
-  service: z.object({
-    id: z.string().uuid(),
-    name: z.string(),
-    version: z.string()
-  }).optional()
-});
-var logicNodeInfoSchema = z.object({
-  id: z.string().uuid(),
-  type: z.literal("logic"),
-  alias: z.string().optional(),
-  logic: z.object({
-    language: z.enum(["typescript", "javascript", "python"])
-  }).optional()
-});
-var nodeInfoSchema = z.discriminatedUnion("type", [
-  serviceNodeInfoSchema,
-  logicNodeInfoSchema
-]);
-var baseUpdate = z.object({
-  timestamp: z.coerce.date(),
-  taskId: z.string().uuid()
-});
-var taskStartUpdateSchema = baseUpdate.extend({
-  type: z.literal("taskStart"),
-  input: z.unknown(),
-  meta: z.unknown()
-});
-var taskErrorUpdateSchema = baseUpdate.extend({
-  type: z.literal("taskError"),
-  error: z.string()
-});
-var taskEndUpdateSchema = baseUpdate.extend({
-  type: z.literal("taskEnd"),
-  result: z.record(z.string(), z.unknown()),
-  partialResults: z.array(z.object({
-    node: nodeInfoSchema,
-    timestamp: z.coerce.date().nullable(),
-    data: z.unknown(),
-    error: z.string().optional()
-  }))
-});
-var nodeStartUpdateSchema = baseUpdate.extend({
-  type: z.literal("nodeStart"),
-  node: nodeInfoSchema
-});
-var nodeUpdateUpdateSchema = baseUpdate.extend({
-  type: z.literal("nodeUpdate"),
-  data: z.unknown()
-});
-var nodeErrorUpdateSchema = baseUpdate.extend({
-  type: z.literal("nodeError"),
-  error: z.string()
-});
-var nodeDeferUpdateSchema = baseUpdate.extend({
-  type: z.literal("nodeDefer"),
-  reason: z.string().optional()
-});
-var nodeEndUpdateSchema = baseUpdate.extend({
-  type: z.literal("nodeEnd"),
-  node: nodeInfoSchema
-});
-var updateSchema = z.discriminatedUnion("type", [
-  taskStartUpdateSchema,
-  taskErrorUpdateSchema,
-  taskEndUpdateSchema,
-  nodeStartUpdateSchema,
-  nodeUpdateUpdateSchema,
-  nodeErrorUpdateSchema,
-  nodeDeferUpdateSchema,
-  nodeEndUpdateSchema
-]);
-var eventSchema = z.object({ type: z.string(), data: z.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
-
-// src/utils/callbackToAsyncIterator.ts
-function callbackToAsyncIterator(options) {
+// ../helpers/src/utils/callbackToAsyncIterator.ts
+function callbackToAsyncIterator(subscribe) {
   const pullQueue = [];
   const pushQueue = [];
   const pushValue = (value) => {
@@ -104,34 +21,429 @@ function callbackToAsyncIterator(options) {
       pullQueue.push(resolve);
     }
   });
+  subscribe((value) => {
+    pushValue({ value });
+  }, (error) => {
+    pushValue({ error });
+  }, () => {
+    pushValue({ done: true });
+  });
+  return {
+    async next() {
+      const value = await pullValue();
+      if (value.done) {
+        return { value: undefined, done: true };
+      }
+      if (value.error) {
+        throw value.error;
+      }
+      return { value: value.value, done: false };
+    }
+  };
+}
+function callbackToAsyncIterable(...args) {
   return {
     [Symbol.asyncIterator]() {
-      let done = false;
-      const unsubscribe = options.subscribe(pushValue);
-      return {
-        async next() {
-          if (done) {
-            return { value: undefined, done: true };
+      return callbackToAsyncIterator(...args);
+    }
+  };
+}
+
+// ../helpers/src/utils/isRecord.ts
+import { z } from "zod/v4";
+var recordSchema = z.record(z.string(), z.unknown());
+function isRecord(data) {
+  return recordSchema.safeParse(data).success;
+}
+
+// ../helpers/src/utils/mapData.ts
+function resolve(value, onResolve) {
+  if (value instanceof Promise) {
+    return Promise.resolve().then(() => value).then(onResolve);
+  }
+  return onResolve(value);
+}
+function notUndefined(value, fallback) {
+  return resolve(value, (resolvedValue) => typeof resolvedValue === "undefined" ? fallback : resolvedValue);
+}
+
+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 value = await pullValue();
-          if (options.done) {
-            done = options.done(value);
+          const items = data2.map((item, index) => traverseData(item, [...path, index]));
+          if (items.some((item) => item instanceof Promise)) {
+            return Promise.all(items);
           }
-          return { value, done: false };
-        },
-        async return() {
-          unsubscribe?.();
-          return { value: undefined, done: true };
+          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/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/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(stream2, options) {
+    this.#data = stream2;
+    this.#options = options;
+  }
+  static fromStreamObject(stream2) {
+    const instance = new this(null, {
+      type: "x/x"
+    });
+    instance.#stream = stream2;
+    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 z3 } from "zod/v4";
+var streamObjectSchema = z3.object({
+  mime: z3.string(),
+  url: z3.string().url(),
+  __REQUENCE_type: z3.literal("RequenceStream")
+});
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
+function toStreamObject(streamInfo) {
+  return {
+    ...streamInfo,
+    __REQUENCE_type: "RequenceStream"
+  };
+}
+
+// ../helpers/src/files/fileObject.ts
+import { z as z4 } from "zod/v4";
+var fileObjectSchema = z4.object({
+  size: z4.int().positive(),
+  mime: z4.string(),
+  url: z4.url(),
+  __REQUENCE_type: z4.literal("RequenceFile")
+});
+function toFileObject(fileInfo) {
+  return {
+    ...fileInfo,
+    __REQUENCE_type: "RequenceFile"
   };
 }
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
+}
+
+// ../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 { createEventSource } from "eventsource-client";
 
 // src/utils/getAccessToken.ts
 import { readFileSync } from "node:fs";
 function getAccessToken(accessToken) {
-  const token = accessToken ?? process.env.REQUENCE_ACCESS_TOKEN ?? JSON.parse(readFileSync("package.json", "utf-8")).requence?.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,
@@ -140,7 +452,7 @@ in your package.json in requence.accessToken`);
   }
   const parts = deobfuscate(token);
   if (parts.length < 2 || parts[0] !== "api") {
-    throw new Error("Invalid api key");
+    throw new Error("Invalid access token");
   }
   return {
     token: parts[1],
@@ -148,203 +460,529 @@ in your package.json in requence.accessToken`);
   };
 }
 
+// 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/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()
+});
+var taskAbortUpdateSchema = baseUpdate.extend({
+  type: z5.literal("taskAborted"),
+  reason: z5.string().optional()
+});
+var taskEndUpdateSchema = baseUpdate.extend({
+  type: z5.literal("taskEnd"),
+  result: z5.record(z5.string(), z5.any()),
+  exit: z5.string().nullable()
+});
+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) => (4 - value) * 10 / 4);
+
 // src/createTask.ts
-class TaskError extends Error {
+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 startUrl = `${apiBaseUrl}/task/start/${options.taskTemplate}`;
-  const payloadPromise = createRemotePromise();
+  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 payloadPromise;
+    const payload = await payloadPromiseWithResolvers.promise;
     if (!payload.urls) {
-      resultPromise.resolve({
-        getInput() {
-          return input;
-        },
-        getMeta() {
-          return meta;
-        },
-        getError(_alias) {
+      resultPromiseWithResolvers.resolve({
+        input: options.input,
+        taskId: payload.taskId,
+        taskUrl: "",
+        result: null,
+        getNodeData(_alias) {
           return null;
         },
-        getData(_alias) {
+        getNodeError(_alias) {
           return null;
         }
       });
       return;
     }
-    const eventSource = new EventSource(payload.urls.watch, {
-      fetch: (input2, init) => fetch(input2, {
-        ...init,
-        headers: {
-          Authorization: `Bearer ${token}`
+    const taskStorage = { input: null, data: {}, errors: {}, result: null };
+    let since = 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 });
+      },
+      onScheduleReconnect() {
+        since = new Date;
+      },
+      async onDisconnect() {
+        if (lastResponse.status === 200) {
+          eventSource.close();
         }
-      })
-    });
-    const taskEvents = [
-      "taskStart",
-      "taskError",
-      "taskEnd",
-      "nodeStart",
-      "nodeUpdate",
-      "nodeDefer",
-      "nodeError",
-      "nodeEnd"
-    ];
-    let input = null;
-    let meta = null;
-    taskEvents.forEach((taskEvent) => {
-      eventSource.addEventListener(taskEvent, (event) => {
-        const updateResult = eventSchema.safeParse(event);
+      },
+      onMessage({ event, data }) {
+        const updateResult = eventSchema.safeParse({ event, data });
         if (!updateResult.success) {
           eventSource.close();
-          resultPromise.reject(new TaskError(`Invalid ${taskEvent} update received`, options.taskTemplate));
+          resultPromiseWithResolvers.reject(new TaskError(`Invalid ${event} update received`, options.taskTemplate, payload.taskId));
           return;
         }
         const update = updateResult.data;
-        if (update.type === "taskEnd" || update.type === "taskError") {
-          eventSource.close();
-        }
-        if (update.type === "taskStart") {
-          input = update.input;
-          meta = update.meta;
-        }
-        if (update.type === "taskEnd") {
-          const getPartialResult = (alias) => update.partialResults.find((partialResult) => partialResult.node.alias === alias);
-          resultPromise.resolve({
-            getInput() {
-              return input;
-            },
-            getMeta() {
-              return meta;
-            },
-            getError(alias) {
-              return getPartialResult(alias)?.error ?? null;
-            },
-            getData(alias) {
-              if (!alias) {
-                return update.result;
-              }
-              return getPartialResult(alias)?.data ?? null;
+        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();
+            break;
+          }
+          case "taskError":
+          case "taskAborted": {
+            eventSource.close();
+            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 (update.type === "taskError") {
-          resultPromise.reject(new TaskError(update.error, options.taskTemplate));
+        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(update));
-      });
+        taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
+      }
     });
   };
-  const taskIdPromise = createRemotePromise();
-  const resultPromise = createRemotePromise(startMonitoring);
+  const taskIdPromiseWithResolvers = Promise.withResolvers();
+  const taskUrlPromiseWithResolvers = Promise.withResolvers();
+  const resultPromiseWithResolvers = Promise.withResolvers();
+  let rejectTaskIdPromise = false;
+  let rejectTaskUrlPromise = false;
   (async () => {
-    const response = await fetch(startUrl, {
-      method: "post",
+    const prepareResponse = await fetch(prepareUrl, {
+      method: "POST",
       headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
         Authorization: `Bearer ${token}`
+      }
+    });
+    if (!prepareResponse.ok) {
+      const error = new TaskPrepareError(await prepareResponse.text(), options.taskTemplate);
+      if (rejectTaskIdPromise) {
+        taskIdPromiseWithResolvers.reject(error);
+      }
+      if (rejectTaskUrlPromise) {
+        taskUrlPromiseWithResolvers.reject(error);
+      }
+      resultPromiseWithResolvers.reject(error);
+      return;
+    }
+    const prepareData = await prepareResponse.json();
+    taskIdPromiseWithResolvers.resolve(prepareData.taskId);
+    const mappedParams = await mapOutput({
+      value: {
+        name: options.name,
+        input: options.input,
+        priority
       },
-      body: JSON.stringify({ input: options.input, meta: options.meta })
+      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 (!response.ok) {
-      const error = new TaskError(await response.text(), options.taskTemplate);
-      taskIdPromise.reject(error);
-      resultPromise.reject(error);
+    if (!finalizeResponse.ok) {
+      const error = new TaskError(await finalizeResponse.text(), options.taskTemplate, prepareData.taskId);
+      taskUrlPromiseWithResolvers.reject(error);
+      resultPromiseWithResolvers.reject(error);
       return;
     }
-    const payload = await response.json();
-    taskIdPromise.resolve(payload.id);
-    payloadPromise.resolve(payload);
+    const payload = await finalizeResponse.json();
+    taskUrlPromiseWithResolvers.resolve(payload.urls?.show ?? null);
+    payloadPromiseWithResolvers.resolve(payload);
     if (onUpdate) {
       taskUpdateHandlers.add(onUpdate);
       startMonitoring();
     }
   })();
-  const asyncIterable = callbackToAsyncIterator({
-    subscribe: (push) => {
-      taskUpdateHandlers.add(push);
+  const asyncIterable = callbackToAsyncIterable((push, _fail, done) => {
+    taskUpdateHandlers.add(function handleUpdate(update) {
+      push(update);
+      if (update.type === "taskEnd" || update.type === "taskError" || update.type === "taskAborted") {
+        done();
+        taskUpdateHandlers.delete(handleUpdate);
+      }
+    });
+    startMonitoring();
+  });
+  return Object.assign({}, asyncIterable, {
+    get catch() {
       startMonitoring();
-      return () => {
-        taskUpdateHandlers.delete(push);
-      };
+      return resultPromiseWithResolvers.promise.catch.bind(resultPromiseWithResolvers.promise);
     },
-    done: (value) => value.type === "taskError" || value.type === "taskEnd"
-  });
-  return Object.assign(resultPromise.promise, asyncIterable, {
-    getTaskId() {
-      return taskIdPromise;
+    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
+      });
     }
   });
 }
 // src/watchTasks.ts
-import { EventSource as EventSource2 } from "eventsource";
+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 watchUrl = new URL(`${apiBaseUrl}/task/watch-all`);
-  watchUrl.searchParams.set("since", options.since.toISOString());
-  const eventSource = new EventSource2(watchUrl, {
-    fetch: (input, init) => fetch(input, {
-      ...init,
-      headers: {
-        Authorization: `Bearer ${token}`
+  const taskStorage = new Map;
+  let startDate = options.since;
+  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(),
+        filter: options.filter
+      });
+    },
+    method: "POST",
+    onScheduleReconnect() {
+      startDate = new Date;
+      options.onReconnecting?.();
+    },
+    onConnect() {
+      options.onConnect?.();
+    },
+    async onDisconnect() {
+      if (lastResponse) {
+        options.onError?.(lastResponse.status, lastResponse.statusText);
       }
-    })
-  });
-  const asyncIterable = callbackToAsyncIterator({
-    subscribe: (push) => {
-      taskUpdateHandlers.add(push);
-      return () => {
-        taskUpdateHandlers.delete(push);
-      };
-    }
-  });
-  const taskEvents = [
-    "taskStart",
-    "taskError",
-    "taskEnd",
-    "nodeStart",
-    "nodeUpdate",
-    "nodeDefer",
-    "nodeError",
-    "nodeEnd"
-  ];
-  taskEvents.forEach((taskEvent) => {
-    eventSource.addEventListener(taskEvent, (event) => {
-      const updateResult = eventSchema.safeParse(event);
+    },
+    onMessage({ id, event, data }) {
+      const updateResult = eventSchema.safeParse({ event, data });
       if (!updateResult.success) {
         eventSource.close();
         throw new Error("invalid update");
       }
-      taskUpdateHandlers.forEach((handler) => handler(updateResult.data));
-    });
+      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);
+          break;
+        }
+        case "taskError": {
+          taskStorage.delete(update.taskId);
+          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);
   });
   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"
+  ]),
+  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(), type: z6.string() })),
+  nodesError: z6.array(z6.object({ alias: z6.string(), error: z6.string(), type: 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,
+    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,
-  createTask
+  recreateTask,
+  getTask,
+  createTask,
+  abortTask,
+  TaskError,
+  RequenceStream,
+  RequenceFile
 };
 
-//# debugId=13556CDD3F92A75464756E2164756E21
+//# debugId=BF50DC2AF74E289864756E2164756E21
 //# sourceMappingURL=index.js.map