@requence/task 1.0.0-alpha.2 → 1.0.0-alpha.20

package/build/index.js

@@ -1,85 +1,620 @@
 import {
-  createRemotePromise,
   deobfuscate
-} from "./chunk-s4kgf465.js";
+} from "./chunk-4r30g3ha.js";
 
-// src/index.ts
-import { readFileSync } from "node:fs";
-import { EventSource } from "eventsource";
+// ../helpers/src/utils/createRemotePromise.ts
+function createRemotePromise(onAwait) {
+  let resolvePromise;
+  let rejectPromise;
+  const internalPromise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  let isAwaited = false;
+  const wrappedPromise = new Proxy(internalPromise, {
+    get(target, property) {
+      if (property === "then" || property === "catch" || property === "finally") {
+        if (!isAwaited && onAwait) {
+          isAwaited = true;
+          onAwait(resolvePromise, rejectPromise);
+        }
+        return target[property].bind(target);
+      }
+      return target[property];
+    }
+  });
+  return Object.assign(wrappedPromise, {
+    resolve: resolvePromise,
+    reject: rejectPromise,
+    promise: wrappedPromise
+  });
+}
+
+// ../helpers/src/utils/callbackToAsyncIterator.ts
+function callbackToAsyncIterator(subscribe) {
+  const pullQueue = [];
+  const pushQueue = [];
+  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);
+    }
+  });
+  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]() {
+      return callbackToAsyncIterator(...args);
+    }
+  };
+}
+
+// ../helpers/src/utils/isRecord.ts
+import { z } from "zod";
+var recordSchema = z.record(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);
+}
+function mapData(data, visitors) {
+  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 (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);
+      });
+    }
+    return data2;
+  };
+  return traverseData(data, []);
+}
+
+// ../helpers/src/context/context.ts
+import { z as z3 } from "zod";
+
+// ../helpers/src/files/index.ts
 import { z as z2 } from "zod";
 
+// ../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/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;
+}
+var streamObjectSchema = z2.object({
+  mime: z2.string(),
+  url: z2.string().url(),
+  __REQUENCE_type: z2.literal("RequenceStream")
+});
+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())
+});
+var internalKey = Symbol.for("internal");
+function resolveRequenceTypes(data) {
+  return mapData(data, {
+    Object(obj) {
+      if (isFileObject(obj)) {
+        return RequenceFile.fromFileObject(obj);
+      }
+      if (isStreamObject(obj)) {
+        return RequenceStream.fromStreamObject(obj);
+      }
+    }
+  });
+}
+function createContextHelper(context, nodes) {
+  const input = resolveRequenceTypes(context.input);
+  const meta = resolveRequenceTypes(context.meta);
+  const results = new Map(nodes.map((node) => [
+    node.id,
+    {
+      node,
+      executionDate: node.id in context.dates ? new Date(context.dates[node.id]) : null,
+      data: resolveRequenceTypes(context.data[node.id] ?? null),
+      error: context.errors[node.id] ?? null
+    }
+  ]));
+  const lookUpMap = new Map;
+  for (const node of nodes) {
+    const alias = typeof node.meta?.mapAlias === "string" ? node.meta.mapAlias : ("alias" in node) && node.alias;
+    if (alias) {
+      if (lookUpMap.has(alias)) {
+        lookUpMap.get(alias).push(node.id);
+      } else {
+        lookUpMap.set(alias, [node.id]);
+      }
+    }
+    const name = typeof node.meta?.mapName === "string" ? node.meta.mapName : node.type === "service" && node.name;
+    if (name) {
+      if (lookUpMap.has(name)) {
+        lookUpMap.get(name).push(node.id);
+      } else {
+        lookUpMap.set(name, [node.id]);
+      }
+    }
+  }
+  return {
+    [internalKey]: {
+      results
+    },
+    getInput() {
+      return input;
+    },
+    getMeta() {
+      return meta;
+    },
+    getData(alias) {
+      if (alias) {
+        const nodeIds = lookUpMap.get(alias);
+        if (!nodeIds) {
+          return null;
+        }
+        const uniqueNodeIds = Array.from(new Set(nodeIds));
+        const combinedData = uniqueNodeIds.map((nodeId) => results.get(nodeId)?.data).filter(Boolean);
+        if (combinedData.length === 0) {
+          return null;
+        }
+        if (combinedData.length === 1) {
+          return combinedData[0];
+        }
+        if (combinedData.every(isRecord)) {
+          return combinedData.reduce((acc, data) => ({ ...acc, ...data }), {});
+        }
+        return combinedData;
+      }
+      return Array.from(results.values()).filter((result) => result.executionDate && isRecord(result.data)).toSorted((a, b) => a.executionDate.getTime() - b.executionDate.getTime()).reduce((acc, result) => ({
+        ...acc,
+        ...result.data
+      }), isRecord(input) ? input : {});
+    },
+    getError(alias) {
+      const nodeIds = lookUpMap.get(alias);
+      if (!nodeIds) {
+        return null;
+      }
+      return nodeIds.map((nodeId) => results.get(nodeId)?.error).filter((str) => typeof str === "string").join(`
+`);
+    }
+  };
+}
+
+// src/createTask.ts
+import { EventSource } from "eventsource";
+
+// 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/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()
+import { z as z4 } from "zod";
+var serviceNodeInfoSchema = z4.object({
+  id: z4.string().uuid(),
+  type: z4.literal("service"),
+  alias: z4.string().optional(),
+  service: z4.object({
+    id: z4.string().uuid(),
+    name: z4.string(),
+    version: z4.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"])
+var logicNodeInfoSchema = z4.object({
+  id: z4.string().uuid(),
+  type: z4.literal("logic"),
+  alias: z4.string().optional(),
+  logic: z4.object({
+    language: z4.enum(["typescript", "javascript", "python"])
   }).optional()
 });
-var nodeInfoSchema = z.discriminatedUnion("type", [
+var nodeInfoSchema = z4.discriminatedUnion("type", [
   serviceNodeInfoSchema,
   logicNodeInfoSchema
 ]);
-var taskStartUpdateSchema = z.object({
-  type: z.literal("taskStart"),
-  timestamp: z.coerce.date(),
-  input: z.unknown(),
-  meta: z.unknown()
+var baseUpdate = z4.object({
+  timestamp: z4.coerce.date(),
+  taskId: z4.string().uuid(),
+  updateId: z4.string().uuid(),
+  context: contextSchema,
+  nodes: z4.custom((data) => Array.isArray(data))
 });
-var taskErrorUpdateSchema = z.object({
-  type: z.literal("taskError"),
-  timestamp: z.coerce.date(),
-  error: z.string()
+var taskStartUpdateSchema = baseUpdate.extend({
+  type: z4.literal("taskStart")
 });
-var taskEndUpdateSchema = z.object({
-  type: z.literal("taskEnd"),
-  timestamp: z.coerce.date(),
-  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 taskErrorUpdateSchema = baseUpdate.extend({
+  type: z4.literal("taskError"),
+  error: z4.string()
 });
-var nodeStartUpdateSchema = z.object({
-  type: z.literal("nodeStart"),
-  timestamp: z.coerce.date(),
+var taskEndUpdateSchema = baseUpdate.extend({
+  type: z4.literal("taskEnd")
+});
+var nodeStartUpdateSchema = baseUpdate.extend({
+  type: z4.literal("nodeStart"),
   node: nodeInfoSchema
 });
-var nodeUpdateUpdateSchema = z.object({
-  type: z.literal("nodeUpdate"),
-  timestamp: z.coerce.date(),
-  data: z.unknown()
+var nodeUpdateUpdateSchema = baseUpdate.extend({
+  type: z4.literal("nodeUpdate"),
+  node: nodeInfoSchema,
+  data: z4.unknown(),
+  output: z4.union([z4.null(), z4.string()])
 });
-var nodeErrorUpdateSchema = z.object({
-  type: z.literal("nodeError"),
-  timestamp: z.coerce.date(),
-  error: z.string()
+var nodeErrorUpdateSchema = baseUpdate.extend({
+  type: z4.literal("nodeError"),
+  node: nodeInfoSchema,
+  error: z4.string()
 });
-var nodeDeferUpdateSchema = z.object({
-  type: z.literal("nodeDefer"),
-  timestamp: z.coerce.date(),
-  reason: z.string().optional()
+var nodeDeferUpdateSchema = baseUpdate.extend({
+  type: z4.literal("nodeDefer"),
+  node: nodeInfoSchema,
+  reason: z4.string().optional()
 });
-var nodeEndUpdateSchema = z.object({
-  type: z.literal("nodeEnd"),
-  timestamp: z.coerce.date(),
+var nodeEndUpdateSchema = baseUpdate.extend({
+  type: z4.literal("nodeEnd"),
   node: nodeInfoSchema
 });
-var updateSchema = z.discriminatedUnion("type", [
+var updateSchema = z4.discriminatedUnion("type", [
   taskStartUpdateSchema,
   taskErrorUpdateSchema,
   taskEndUpdateSchema,
@@ -89,49 +624,23 @@ var updateSchema = z.discriminatedUnion("type", [
   nodeDeferUpdateSchema,
   nodeEndUpdateSchema
 ]);
+var eventSchema = z4.object({ type: z4.string(), data: z4.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
 
-// src/utils/callbackToAsyncIterator.ts
-function callbackToAsyncIterator(options) {
-  const pullQueue = [];
-  const pushQueue = [];
-  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);
+// src/utils/mapOutput.ts
+function mapOutput3(data) {
+  return mapData(data, {
+    Object(obj) {
+      if (isFileObject(obj)) {
+        return RequenceFile.fromFileObject(obj);
+      }
+      if (isStreamObject(obj)) {
+        return RequenceStream.fromStreamObject(obj);
+      }
     }
   });
-  return {
-    [Symbol.asyncIterator]() {
-      let done = false;
-      const unsubscribe = options.subscribe(pushValue);
-      return {
-        async next() {
-          if (done) {
-            return { value: undefined, done: true };
-          }
-          const value = await pullValue();
-          done = options.done(value);
-          return { value, done: false };
-        },
-        async return() {
-          unsubscribe?.();
-          return { value: undefined, done: true };
-        }
-      };
-    }
-  };
 }
 
-// src/index.ts
+// src/createTask.ts
 class TaskError extends Error {
   taskTemplate;
   constructor(message, taskTemplate) {
@@ -139,22 +648,10 @@ class TaskError extends Error {
     this.taskTemplate = taskTemplate;
   }
 }
-var eventSchema = z2.object({ type: z2.string(), data: z2.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
-function createTask(params, onUpdate) {
+function createTask(options, onUpdate) {
   const taskUpdateHandlers = new Set;
-  const accessKey = params.accessToken ?? process.env.REQUENCE_ACCESS_TOKEN ?? JSON.parse(readFileSync("package.json", "utf-8")).requence?.accessToken;
-  if (!accessKey) {
-    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(accessKey);
-  if (parts.length < 2 || parts[0] !== "api") {
-    throw new Error("Invalid api key");
-  }
-  const [, token, apiBaseUrl] = parts;
-  const startUrl = `${apiBaseUrl}/task/start/${params.taskTemplate}`;
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const prepareUrl = `${apiBaseUrl}/task/prepare/${options.taskTemplate}`;
   const payloadPromise = createRemotePromise();
   let isMonitoring = false;
   const startMonitoring = async () => {
@@ -163,8 +660,31 @@ in your package.json in requence.accessToken`);
     }
     isMonitoring = true;
     const payload = await payloadPromise;
+    if (!payload.urls) {
+      resultPromise.resolve({
+        getInput() {
+          return options.input;
+        },
+        getMeta() {
+          return options.meta;
+        },
+        getError(_alias) {
+          return null;
+        },
+        getData(_alias) {
+          return null;
+        },
+        getTaskId() {
+          return payload.taskId;
+        },
+        getTaskUrl() {
+          return "";
+        }
+      });
+      return;
+    }
     const eventSource = new EventSource(payload.urls.watch, {
-      fetch: (input2, init) => fetch(input2, {
+      fetch: (input, init) => fetch(input, {
         ...init,
         headers: {
           Authorization: `Bearer ${token}`
@@ -181,94 +701,199 @@ in your package.json in requence.accessToken`);
       "nodeError",
       "nodeEnd"
     ];
-    let input = null;
-    let meta = null;
     taskEvents.forEach((taskEvent) => {
       eventSource.addEventListener(taskEvent, (event) => {
         const updateResult = eventSchema.safeParse(event);
         if (!updateResult.success) {
           eventSource.close();
-          resultPromise.reject(new TaskError(`Invalid ${taskEvent} update received`, params.taskTemplate));
+          resultPromise.reject(new TaskError(`Invalid ${taskEvent} update received`, options.taskTemplate));
           return;
         }
         const update = updateResult.data;
         if (update.type === "taskEnd" || update.type === "taskError") {
           eventSource.close();
         }
-        if (update.type === "taskStart") {
-          input = update.input;
-          meta = update.meta;
+        const context = update.context;
+        if (update.type === "nodeUpdate") {
+          context.dates[update.node.id] = update.timestamp.toISOString();
+          context.data[update.node.id] = update.data;
         }
-        if (update.type === "taskEnd") {
-          const getPartialResult = (alias) => update.partialResults.find((partialResult) => partialResult.node.alias === alias);
+        const contextUpdate = {
+          ...update,
+          context: createContextHelper(context, update.nodes)
+        };
+        if (contextUpdate.type === "taskEnd") {
           resultPromise.resolve({
-            getInput() {
-              return input;
-            },
-            getMeta() {
-              return meta;
+            ...contextUpdate.context,
+            getTaskId() {
+              return payload.taskId;
             },
-            getError(alias) {
-              return getPartialResult(alias)?.error ?? null;
-            },
-            getData(alias) {
-              if (!alias) {
-                return update.result;
-              }
-              return getPartialResult(alias)?.data ?? null;
+            getTaskUrl() {
+              return payload.urls?.show ?? "";
             }
           });
         }
-        if (update.type === "taskError") {
-          resultPromise.reject(new TaskError(update.error, params.taskTemplate));
+        if (contextUpdate.type === "taskError") {
+          resultPromise.reject(new TaskError(contextUpdate.error, options.taskTemplate));
         }
-        taskUpdateHandlers.forEach((handler) => handler(update));
+        const extendedUpdate = contextUpdate.type === "nodeUpdate" ? {
+          ...contextUpdate,
+          output: contextUpdate.output === "__default__" ? null : contextUpdate.output,
+          data: mapOutput3(contextUpdate.data)
+        } : contextUpdate;
+        taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
       });
     });
   };
-  const taskIdPromise = createRemotePromise();
+  const taskMetaPromise = createRemotePromise();
   const resultPromise = createRemotePromise(startMonitoring);
   (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 TaskError(await prepareResponse.text(), options.taskTemplate);
+      taskMetaPromise.reject(error);
+      resultPromise.reject(error);
+      return;
+    }
+    const prepareData = await prepareResponse.json();
+    const mappedParams = await mapOutput({
+      value: {
+        name: options.name,
+        input: options.input,
+        meta: options.meta
       },
-      body: JSON.stringify({ input: params.input, meta: params.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(), params.taskTemplate);
-      taskIdPromise.reject(error);
+    if (!finalizeResponse.ok) {
+      const error = new TaskError(await prepareResponse.text(), options.taskTemplate);
+      taskMetaPromise.reject(error);
       resultPromise.reject(error);
       return;
     }
-    const payload = await response.json();
-    taskIdPromise.resolve(payload.id);
+    const payload = await finalizeResponse.json();
+    taskMetaPromise.resolve({
+      id: payload.taskId,
+      showUrl: payload.urls?.show ?? null
+    });
     payloadPromise.resolve(payload);
     if (onUpdate) {
       taskUpdateHandlers.add(onUpdate);
       startMonitoring();
     }
   })();
-  const asyncIterable = callbackToAsyncIterator({
-    subscribe: (push) => {
-      taskUpdateHandlers.add(push);
-      startMonitoring();
-    },
-    done: (value) => value.type === "taskError" || value.type === "taskEnd"
+  const asyncIterable = callbackToAsyncIterable((push, _fail, done) => {
+    taskUpdateHandlers.add(function handleUpdate(update) {
+      push(update);
+      if (update.type === "taskEnd" || update.type === "taskError") {
+        done();
+        taskUpdateHandlers.delete(handleUpdate);
+      }
+    });
+    startMonitoring();
   });
   return Object.assign(resultPromise.promise, asyncIterable, {
-    getTaskId() {
-      return taskIdPromise;
+    async getTaskId() {
+      const meta = await taskMetaPromise;
+      return meta.id;
+    },
+    async getTaskUrl() {
+      const meta = await taskMetaPromise;
+      return meta.showUrl;
+    },
+    async abort(reason) {
+      const meta = await taskMetaPromise;
+      await abortTask({
+        taskId: meta.id,
+        accessToken: options.accessToken,
+        reason
+      });
     }
   });
 }
+// src/watchTasks.ts
+import { EventSource as EventSource2 } from "eventsource";
+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 asyncIterable = callbackToAsyncIterable((push) => {
+    taskUpdateHandlers.add(push);
+  });
+  const taskEvents = [
+    "taskStart",
+    "taskError",
+    "taskEnd",
+    "nodeStart",
+    "nodeUpdate",
+    "nodeDefer",
+    "nodeError",
+    "nodeEnd"
+  ];
+  taskEvents.forEach((taskEvent) => {
+    eventSource.addEventListener(taskEvent, (event) => {
+      const updateResult = eventSchema.safeParse(event);
+      if (!updateResult.success) {
+        eventSource.close();
+        throw new Error("invalid update");
+      }
+      const update = updateResult.data;
+      const context = update.context;
+      if (update.type === "nodeUpdate") {
+        context.dates[update.node.id] = update.timestamp.toISOString();
+        context.data[update.node.id] = update.data;
+      }
+      const contextUpdate = {
+        ...update,
+        context: createContextHelper(context, update.nodes)
+      };
+      const extendedUpdate = contextUpdate.type === "nodeUpdate" ? {
+        ...contextUpdate,
+        output: contextUpdate.output === "__default__" ? null : contextUpdate.output,
+        data: mapOutput3(contextUpdate.data)
+      } : contextUpdate;
+      taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
+    });
+  });
+  const stopWatching = () => {
+    eventSource.close();
+  };
+  return Object.assign(stopWatching, asyncIterable);
+}
 export {
+  watchTasks,
   createTask,
-  TaskError
+  abortTask,
+  RequenceStream,
+  RequenceFile
 };
 
-//# debugId=1F3F1932800384D964756E2164756E21
+//# debugId=1ABBB576345EB61164756E2164756E21
 //# sourceMappingURL=index.js.map