@requence/task 0.7.1 → 0.8.2-edge.1149

package/build/index.js

@@ -1,216 +1,203 @@
 import {
-  deobfuscate
-} from "./chunk-b4h2we9a.js";
+  RequenceUnreachableError,
+  deobfuscate,
+  isUnreachableStatus,
+  reachableFetch
+} from "./chunk-f7g9gsa0.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 };
+// ../files/src/errors.ts
+class RequenceStreamTruncatedError extends Error {
+  constructor(message = "stream truncated") {
+    super(message);
+    this.name = "RequenceStreamTruncatedError";
+  }
+}
+
+// ../files/src/streamFraming.ts
+var STREAM_PROTOCOL_HEADER = "x-requence-stream-protocol";
+var STREAM_PROTOCOL_FRAMED = "framed";
+var DATA = 0;
+var END = 1;
+var TRUNCATED = 2;
+var HEADER_BYTES = 5;
+var END_FRAME = new Uint8Array([END, 0, 0, 0, 0]);
+function createFrameDecoder() {
+  let buffer = new Uint8Array(0);
+  let terminal = false;
+  return new TransformStream({
+    transform(chunk, controller) {
+      if (terminal) {
+        if (chunk.byteLength > 0) {
+          throw new Error("stream protocol error: bytes after terminal frame");
+        }
+        return;
       }
-      if (value.error) {
-        done = true;
-        throw value.error;
+      if (buffer.byteLength === 0) {
+        buffer = chunk;
+      } else {
+        const merged = new Uint8Array(buffer.byteLength + chunk.byteLength);
+        merged.set(buffer, 0);
+        merged.set(chunk, buffer.byteLength);
+        buffer = merged;
       }
-      return { value: value.value, done: false };
-    },
-    async return() {
-      if (!done) {
-        done = true;
-        if (typeof cleanup === "function") {
-          cleanup();
+      while (buffer.byteLength >= HEADER_BYTES) {
+        const type = buffer[0];
+        const length = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getUint32(1, false);
+        if (buffer.byteLength < HEADER_BYTES + length) {
+          break;
         }
-        while (pullQueue.length > 0) {
-          const resolver = pullQueue.shift();
-          resolver({ done: true });
+        const payload = buffer.slice(HEADER_BYTES, HEADER_BYTES + length);
+        buffer = buffer.subarray(HEADER_BYTES + length);
+        switch (type) {
+          case DATA: {
+            if (payload.byteLength > 0) {
+              controller.enqueue(payload);
+            }
+            break;
+          }
+          case END: {
+            terminal = true;
+            if (buffer.byteLength > 0) {
+              throw new Error("stream protocol error: bytes after terminal frame");
+            }
+            controller.terminate();
+            return;
+          }
+          case TRUNCATED: {
+            terminal = true;
+            controller.error(new RequenceStreamTruncatedError(new TextDecoder().decode(payload) || undefined));
+            return;
+          }
+          default: {
+            throw new Error(`stream protocol error: unknown frame type ${type}`);
+          }
         }
       }
-      return { value: undefined, done: true };
+    },
+    flush(controller) {
+      if (!terminal) {
+        controller.error(new RequenceStreamTruncatedError("connection closed before terminal frame"));
+      }
     }
-  };
+  });
 }
-function callbackToAsyncIterable(...args) {
-  let iterator;
-  return {
-    [Symbol.asyncIterator]() {
-      iterator ??= callbackToAsyncIterator(...args);
-      return iterator;
+
+// ../files/src/remoteBody.ts
+function remoteBody(url, options = {}) {
+  const externalSignal = options.signal;
+  const timeoutMs = options.stallTimeoutMs && options.stallTimeoutMs > 0 ? options.stallTimeoutMs : 0;
+  const controller = new AbortController;
+  let reader = null;
+  let timer;
+  let onExternalAbort;
+  const clearTimer = () => {
+    if (timer !== undefined) {
+      clearTimeout(timer);
+      timer = undefined;
     }
   };
-}
-
-// ../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);
+  const cleanup = () => {
+    clearTimer();
+    if (externalSignal && onExternalAbort) {
+      externalSignal.removeEventListener("abort", onExternalAbort);
+    }
+  };
+  if (externalSignal) {
+    if (externalSignal.aborted) {
+      controller.abort(externalSignal.reason);
+    } else {
+      onExternalAbort = () => controller.abort(externalSignal.reason);
+      externalSignal.addEventListener("abort", onExternalAbort, {
+        once: true
+      });
+    }
   }
-  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;
+  const armTimer = () => {
+    if (timeoutMs <= 0) {
+      return;
     }
-    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;
+    clearTimer();
+    timer = setTimeout(() => {
+      controller.abort(new Error(`remote read stalled: no data for ${timeoutMs}ms`));
+    }, timeoutMs);
+  };
+  return new ReadableStream({
+    async start(streamController) {
+      let response;
+      try {
+        response = await fetch(url, {
+          signal: controller.signal,
+          headers: options.framed ? { [STREAM_PROTOCOL_HEADER]: STREAM_PROTOCOL_FRAMED } : undefined
         });
+      } catch (error) {
+        cleanup();
+        streamController.error(error);
+        return;
       }
-      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 (!response.ok) {
+        await response.body?.cancel();
+        cleanup();
+        streamController.error(new Error(`remote read failed: ${response.status} ${response.statusText}`));
+        return;
       }
-      if (typeof data2 === "function") {
-        return notUndefined(visitors.Function?.(data2, path), data2);
+      if (!response.body) {
+        cleanup();
+        streamController.error(new Error("remote read response has no body"));
+        return;
       }
-      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);
+      const framed = options.framed && response.headers.get(STREAM_PROTOCOL_HEADER) === STREAM_PROTOCOL_FRAMED;
+      reader = framed ? response.body.pipeThrough(createFrameDecoder()).getReader() : response.body.getReader();
+    },
+    async pull(streamController) {
+      if (!reader) {
+        return;
       }
-      return data2;
-    } catch (error) {
-      if (error instanceof AbortMapData) {
-        aborted = true;
-        return data2;
+      armTimer();
+      try {
+        const { done, value } = await reader.read();
+        clearTimer();
+        if (done) {
+          cleanup();
+          streamController.close();
+          return;
+        }
+        streamController.enqueue(value);
+      } catch (error) {
+        clearTimer();
+        cleanup();
+        streamController.error(error);
       }
-      throw error;
+    },
+    async cancel(reason) {
+      cleanup();
+      controller.abort(reason);
+      await reader?.cancel(reason);
     }
-  };
-  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;
+// ../files/src/RequenceFile.ts
+function stallTimeoutMs() {
+  const raw = typeof process !== "undefined" ? Number(process.env?.REQUENCE_FILE_STALL_TIMEOUT_MS) : Number.NaN;
+  return Number.isFinite(raw) && raw > 0 ? raw : 0;
 }
 
-// ../helpers/src/files/RequenceFile.ts
 class RequenceFile {
   #data;
   #file = null;
+  #signal;
   constructor(blobParts, options) {
     this.#data = new Blob(blobParts, options);
   }
-  static fromFileObject(file) {
+  static fromFileObject(file, signal) {
     const instance = new this([], { type: "x/x" });
     instance.#file = file;
+    instance.#signal = signal;
     return instance;
   }
+  static canHandle(value) {
+    return value instanceof RequenceFile || value instanceof Blob;
+  }
   get fileObject() {
     return this.#file;
   }
@@ -226,39 +213,74 @@ class RequenceFile {
   get subMimeType() {
     return this.mimeType.split("/")[1];
   }
+  stream() {
+    if (!this.#file) {
+      return this.#data.stream();
+    }
+    return remoteBody(this.#file.url, {
+      signal: this.#signal,
+      stallTimeoutMs: stallTimeoutMs()
+    });
+  }
+  async#bytes() {
+    const reader = this.stream().getReader();
+    const chunks = [];
+    let total = 0;
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      chunks.push(value);
+      total += value.byteLength;
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return out;
+  }
   async text() {
     if (this.#file) {
-      return fetch(this.#file.url).then((response) => response.text());
+      return new TextDecoder().decode(await this.#bytes());
     }
     return this.#data.text();
   }
   async json() {
     if (this.#file) {
-      return fetch(this.#file.url).then((response) => response.json());
+      const text = await this.text();
+      try {
+        return JSON.parse(text);
+      } catch (error) {
+        throw new Error(`RequenceFile JSON parse failed for ${this.#file.url}`, { cause: error });
+      }
     }
     return JSON.parse(await this.text());
   }
   async blob() {
     if (this.#file) {
-      return fetch(this.#file.url).then((response) => response.blob());
+      return new Blob([await this.#bytes()], { type: this.#file.mime });
     }
     return this.#data;
   }
   async arrayBuffer() {
     if (this.#file) {
-      return fetch(this.#file.url).then((response) => response.arrayBuffer());
+      return (await this.#bytes()).buffer;
     }
     return this.#data.arrayBuffer();
   }
   toString() {
     return `RequenceFile<${this.mimeType}>`;
   }
-  toJSON() {
-    return `RequenceFile<${this.mimeType}>`;
-  }
+}
+// ../files/src/RequenceStream.ts
+function stallTimeoutMs2() {
+  const raw = typeof process !== "undefined" ? Number(process.env?.REQUENCE_STREAM_STALL_TIMEOUT_MS) : Number.NaN;
+  return Number.isFinite(raw) && raw > 0 ? raw : 0;
 }
 
-// ../helpers/src/files/RequenceStream.ts
 class RequenceStream {
   #data;
   #stream = null;
@@ -267,13 +289,17 @@ class RequenceStream {
     this.#data = stream;
     this.#options = options;
   }
-  static fromStreamObject(stream) {
+  static fromStreamObject(stream, signal) {
     const instance = new this(null, {
-      type: "x/x"
+      type: "x/x",
+      signal
     });
     instance.#stream = stream;
     return instance;
   }
+  static canHandle(value) {
+    return value instanceof RequenceStream || value instanceof Response;
+  }
   get streamObject() {
     return this.#stream;
   }
@@ -287,12 +313,14 @@ class RequenceStream {
     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;
+    if (!this.#stream) {
+      return this.#data;
     }
-    return this.#data;
+    return remoteBody(this.#stream.url, {
+      signal: this.#options.signal,
+      stallTimeoutMs: stallTimeoutMs2(),
+      framed: true
+    });
   }
   asyncIterable() {
     const reader = this.stream().getReader();
@@ -306,6 +334,11 @@ class RequenceStream {
             reader.cancel();
             reader.releaseLock();
             return { done: true, value: null };
+          },
+          async throw() {
+            reader.cancel();
+            reader.releaseLock();
+            return { done: true, value: null };
           }
         };
       }
@@ -314,17 +347,105 @@ class RequenceStream {
   toString() {
     return `RequenceStream<${this.mimeType}>`;
   }
-  toJSON() {
-    return `RequenceStream<${this.mimeType}>`;
-  }
+}
+// ../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/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")
+// ../helpers/src/utils/fileObject.ts
+import { z } from "zod/v4";
+var fileObjectSchema = z.object({
+  size: z.int().positive(),
+  mime: z.string(),
+  url: z.url(),
+  __REQUENCE_type: z.literal("RequenceFile")
+});
+function toFileObject(fileInfo) {
+  return {
+    ...fileInfo,
+    __REQUENCE_type: "RequenceFile"
+  };
+}
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
+}
+
+// ../helpers/src/utils/streamObject.ts
+import { z as z2 } from "zod/v4";
+var streamObjectSchema = z2.object({
+  mime: z2.string(),
+  url: z2.string().url(),
+  __REQUENCE_type: z2.literal("RequenceStream")
 });
 function isStreamObject(data) {
   return streamObjectSchema.safeParse(data).success;
@@ -336,131 +457,292 @@ function toStreamObject(streamInfo) {
   };
 }
 
-// ../helpers/src/files/mapOutput.ts
-async function upload(uploadUrl, body, signal, contentType) {
-  const uploadResponse = await fetch(uploadUrl, {
+// ../helpers/src/utils/claimCheckObject.ts
+import { z as z3 } from "zod/v4";
+var claimCheckObjectSchema = z3.object({
+  url: z3.url(),
+  size: z3.int().positive(),
+  __REQUENCE_type: z3.literal("ClaimCheck")
+});
+function toClaimCheckObject(info) {
+  return {
+    ...info,
+    __REQUENCE_type: "ClaimCheck"
+  };
+}
+function isClaimCheckObject(data) {
+  return claimCheckObjectSchema.safeParse(data).success;
+}
+
+// ../helpers/src/utils/requenceCallback.ts
+import { z as z4 } from "zod/v4";
+var callbackObjectSchema = z4.object({
+  sourceId: z4.string(),
+  outputName: z4.string().nullable(),
+  propertyPath: z4.array(z4.union([z4.string(), z4.int()])),
+  callbackId: z4.uuid(),
+  __REQUENCE_type: z4.literal("RequenceCallback")
+});
+function isCallbackObject(data) {
+  return callbackObjectSchema.safeParse(data).success;
+}
+
+// ../files/src/handlers/transport.ts
+async function assertOk(res, url, phase) {
+  if (res.ok) {
+    return;
+  }
+  const detail = await res.text().catch(() => "");
+  throw new Error(`${phase} failed: ${res.status} ${res.statusText} (${url})${detail ? ` — ${detail}` : ""}`);
+}
+
+// ../files/src/handlers/fileHandler.ts
+async function upload(ctx, uploadUrl, body, contentType, maxFileSize) {
+  const uploadResponse = await ctx.fetch(uploadUrl, {
     method: "POST",
-    signal,
-    headers: contentType ? {
-      "Content-Type": contentType
-    } : {},
+    signal: ctx.signal,
+    headers: {
+      ...contentType ? { "Content-Type": contentType } : {},
+      ...maxFileSize !== undefined ? { "file-size": String(maxFileSize) } : {}
+    },
     body
   });
+  await assertOk(uploadResponse, uploadUrl, "upload");
   const data = await uploadResponse.json();
-  if (!data || typeof data !== "object") {
-    throw new Error("invalid upload response");
+  if (!data || typeof data !== "object" || typeof data.url !== "string" || !data.url || typeof data.mime !== "string" || typeof data.size !== "number") {
+    throw new Error(`malformed upload response (${uploadUrl})`);
   }
   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");
+function createRequenceFileHandler() {
+  return {
+    tag: "RequenceFile",
+    canHandle: (value) => RequenceFile.canHandle(value),
+    async serialize(value, ctx) {
+      if (value instanceof RequenceFile && value.fileObject) {
+        return value.fileObject;
+      }
+      if (!ctx.uploadUrl) {
+        ctx.onOffloadSkip?.();
+        return null;
+      }
+      try {
+        if (value instanceof RequenceFile) {
+          return await upload(ctx, ctx.uploadUrl, await value.blob(), value.mimeType, ctx.maxFileSize);
+        }
+        return await upload(ctx, ctx.uploadUrl, value, value.type, ctx.maxFileSize);
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+        if (ctx.onOffloadFail) {
+          ctx.onOffloadFail(error);
+          return null;
+        }
+        throw error;
+      }
+    },
+    isReference: (value) => isFileObject(value),
+    deserialize(ref, ctx) {
+      return RequenceFile.fromFileObject(ref, ctx.signal);
     }
-    reader.cancel();
-  });
-  const streamResponse = await fetch(streamUrl, {
+  };
+}
+// ../files/src/withRequenceStreams.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var pendingUploads = new AsyncLocalStorage;
+async function withRequenceStreams(fn) {
+  const uploads = [];
+  const value = await pendingUploads.run(uploads, fn);
+  return { value, done: Promise.all(uploads).then(() => {
+    return;
+  }) };
+}
+function registerPendingUpload(work) {
+  const store = pendingUploads.getStore();
+  if (!store) {
+    return false;
+  }
+  store.push(work);
+  return true;
+}
+
+// ../files/src/handlers/streamHandler.ts
+async function registerAndUpload(ctx, streamUrl, stream, contentType, maxFileSize) {
+  const [testStream, dataStream] = stream.tee();
+  const reader = testStream.getReader();
+  const { done: isEmpty } = await reader.read();
+  reader.cancel();
+  const streamResponse = await ctx.fetch(streamUrl, {
     method: "POST",
-    signal,
-    headers: contentType ? { "Content-Type": contentType } : {}
+    signal: ctx.signal,
+    headers: {
+      ...contentType ? { "Content-Type": contentType } : {},
+      ...maxFileSize !== undefined ? { "file-size": String(maxFileSize) } : {}
+    }
   });
+  await assertOk(streamResponse, streamUrl, "stream registration");
   const data = await streamResponse.json();
-  if (!data || typeof data !== "object") {
-    throw new Error("invalid stream response");
+  if (!isStreamObject(toStreamObject(data))) {
+    throw new Error(`malformed stream registration response (${streamUrl})`);
   }
   const { mime, url } = data;
-  await dataPromise;
-  const done = fetch(url, {
-    method: "POST",
-    signal,
-    duplex: "half",
-    body: dataStream
-  });
-  return [toStreamObject({ mime, url }), done];
+  if (isEmpty) {
+    const emptyResponse = await ctx.fetch(url, {
+      method: "POST",
+      signal: ctx.signal,
+      headers: contentType ? { "Content-Type": contentType } : {},
+      body: new Uint8Array(0)
+    });
+    await assertOk(emptyResponse, url, "stream body upload");
+    await emptyResponse.body?.cancel();
+    return { ref: toStreamObject({ mime, url }) };
+  }
+  const bodyUpload = (async () => {
+    const bodyResponse = await ctx.fetch(url, {
+      method: "POST",
+      signal: ctx.signal,
+      duplex: "half",
+      body: dataStream
+    });
+    await assertOk(bodyResponse, url, "stream body upload");
+    await bodyResponse.body?.cancel();
+  })();
+  return { ref: toStreamObject({ mime, url }), bodyUpload };
 }
-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;
-        }
+function createRequenceStreamHandler() {
+  return {
+    tag: "RequenceStream",
+    canHandle: (value) => RequenceStream.canHandle(value),
+    async serialize(value, ctx) {
+      if (value instanceof RequenceStream && value.streamObject) {
+        return value.streamObject;
       }
-      if (obj instanceof Response || obj instanceof RequenceStream) {
-        if (obj instanceof RequenceStream && obj.streamObject) {
-          return obj.streamObject;
+      if (!ctx.streamUrl) {
+        ctx.onOffloadSkip?.();
+        return null;
+      }
+      const body = value instanceof Response ? value.body ?? new ReadableStream({
+        start(controller) {
+          controller.close();
         }
-        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?.();
+      }) : value.stream();
+      const contentType = value instanceof Response ? value.headers.get("Content-Type") : value.mimeType;
+      try {
+        const { ref, bodyUpload } = await registerAndUpload(ctx, ctx.streamUrl, body, contentType, ctx.maxFileSize);
+        if (bodyUpload && !registerPendingUpload(bodyUpload)) {
+          await bodyUpload;
+        }
+        return ref;
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+        if (ctx.onOffloadFail) {
+          ctx.onOffloadFail(error);
           return null;
         }
+        throw error;
       }
+    },
+    isReference: (value) => isStreamObject(value),
+    deserialize(ref, ctx) {
+      return RequenceStream.fromStreamObject(ref, ctx.signal);
     }
+  };
+}
+// ../files/src/handlers/claimCheckHandler.ts
+import { Buffer } from "node:buffer";
+var DEFAULT_MAX_PAYLOAD_SIZE = 4 * 1024 * 1024;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function offload(ctx, uploadUrl, json) {
+  const response = await ctx.fetch(uploadUrl, {
+    method: "POST",
+    signal: ctx.signal,
+    headers: { "Content-Type": "application/json" },
+    body: json
   });
-  Promise.allSettled(streamPromises).then(() => params.onDone?.());
-  return mapped;
+  await assertOk(response, uploadUrl, "claim-check offload");
+  const data = await response.json();
+  if (!data || typeof data !== "object" || typeof data.url !== "string" || !data.url || typeof data.size !== "number") {
+    throw new Error(`malformed claim-check offload response (${uploadUrl})`);
+  }
+  return toClaimCheckObject({ url: data.url, size: data.size });
 }
-
-// ../helpers/src/utils/resolveRequenceTypes.ts
-function resolveRequenceTypes(data, onCallback) {
-  return mapData(data, {
-    Object(obj) {
-      if (isFileObject(obj)) {
-        return RequenceFile.fromFileObject(obj);
+function jsonByteLength(value) {
+  const json = JSON.stringify(value);
+  return json === undefined ? 0 : Buffer.byteLength(json);
+}
+function createMessageHandler() {
+  return {
+    async wrapOutbound(body, ctx) {
+      const maxBytes = ctx.maxPayloadSize ?? DEFAULT_MAX_PAYLOAD_SIZE;
+      if (maxBytes <= 0 || body === undefined) {
+        return body;
       }
-      if (isStreamObject(obj)) {
-        return RequenceStream.fromStreamObject(obj);
+      const measure = ctx.measure ?? jsonByteLength;
+      if (measure(body) <= maxBytes) {
+        return body;
       }
-      if (isCallbackObject(obj)) {
-        return (arg) => {
-          onCallback?.({ ...obj, arg });
-        };
+      const { uploadUrl } = ctx;
+      if (!uploadUrl) {
+        ctx.onOffloadSkip?.();
+        return body;
+      }
+      if (!isRecord(body)) {
+        const json = JSON.stringify(body);
+        if (json === undefined) {
+          return body;
+        }
+        return offload(ctx, uploadUrl, json);
+      }
+      const entries = Object.entries(body).map(([key, value]) => ({
+        key,
+        valueJson: JSON.stringify(value),
+        size: measure(value)
+      })).sort((a, b) => b.size - a.size);
+      const wrapped = { ...body };
+      let total = measure(body);
+      for (const entry of entries) {
+        if (total <= maxBytes || entry.valueJson === undefined || entry.size <= 256) {
+          break;
+        }
+        const ref = await offload(ctx, uploadUrl, entry.valueJson);
+        wrapped[entry.key] = ref;
+        total += measure(ref) - entry.size;
       }
+      return wrapped;
     }
-  });
+  };
+}
+function createValueHandler() {
+  return {
+    tag: "ClaimCheck",
+    canHandle: () => false,
+    serialize() {
+      throw new Error("ClaimCheck egress is the bundled MessageHandler (wrapOutbound); it never reaches the value walk");
+    },
+    isReference: (value) => isClaimCheckObject(value),
+    async deserialize(ref, ctx) {
+      const response = await ctx.fetch(ref.url, { signal: ctx.signal });
+      await assertOk(response, ref.url, "claim-check fetch");
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        throw new Error(`malformed claim-check payload (${ref.url})`);
+      }
+    }
+  };
+}
+function createClaimCheckHandler() {
+  return {
+    valueHandler: createValueHandler(),
+    messageHandler: createMessageHandler()
+  };
 }
-
 // src/createTask.ts
 import chalk from "chalk";
 import { createEventSource } from "eventsource-client";
@@ -500,7 +782,7 @@ class TaskAbortError extends Error {
 async function abortTask(options) {
   const { apiBaseUrl, token } = getAccessToken(options.accessToken);
   const abortUrl = `${apiBaseUrl}/task/abort/${options.taskId}`;
-  const response = await fetch(abortUrl, {
+  const response = await reachableFetch(abortUrl, {
     method: "POST",
     body: options.reason ?? "",
     headers: {
@@ -515,7 +797,7 @@ async function abortTask(options) {
 // src/ackTask.ts
 async function ackTask(options) {
   const { apiBaseUrl, token } = getAccessToken(options.accessToken);
-  const response = await fetch(`${apiBaseUrl}/task/ack/${options.taskId}`, {
+  const response = await reachableFetch(`${apiBaseUrl}/task/ack/${options.taskId}`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`
@@ -526,6 +808,214 @@ async function ackTask(options) {
   }
 }
 
+// ../callbacks/src/handler.ts
+function createRequenceCallbackHandler() {
+  return {
+    tag: "RequenceCallback",
+    canHandle: (value) => typeof value === "function",
+    serialize(callback, ctx, path) {
+      if (!ctx.onCallback) {
+        throw new Error(`functions are not serializable on this boundary (no ctx.onCallback) at path "${path.join(".")}"`);
+      }
+      return {
+        ...ctx.onCallback(callback),
+        outputName: ctx.outputName ?? null,
+        propertyPath: [...path],
+        __REQUENCE_type: "RequenceCallback"
+      };
+    },
+    isReference: (value) => isCallbackObject(value),
+    deserialize(ref, ctx) {
+      return (arg) => {
+        ctx.onCallbackInvoke?.({ ...ref, arg });
+      };
+    }
+  };
+}
+// ../transformer/src/errors.ts
+function formatPath(path) {
+  if (path.length === 0) {
+    return "<root>";
+  }
+  let out = "";
+  for (const segment of path) {
+    out += typeof segment === "number" ? `[${segment}]` : out ? `.${segment}` : segment;
+  }
+  return out;
+}
+
+class TransformError extends Error {
+  path;
+  detail;
+  constructor(detail, path) {
+    super(`${detail} at ${formatPath(path)}`);
+    this.name = "TransformError";
+    this.path = path;
+    this.detail = detail;
+  }
+}
+
+// ../transformer/src/guards.ts
+var REFERENCE_TAG_KEY = "__REQUENCE_type";
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function isComplexValue(value) {
+  if (value === null) {
+    return false;
+  }
+  const type = typeof value;
+  if (type === "object") {
+    return !Array.isArray(value) && !isPlainObject(value);
+  }
+  return type === "function" || type === "symbol" || type === "bigint";
+}
+function hasReferenceTag(value) {
+  return isPlainObject(value) && REFERENCE_TAG_KEY in value;
+}
+
+// ../transformer/src/walk.ts
+var recurse = { kind: "recurse" };
+var replaceWith = (value) => ({
+  kind: "replace",
+  value
+});
+var MAX_REPLACE_DEPTH = 100;
+async function walk(root, visit) {
+  const go = async (value, path, replaceDepth) => {
+    let node = value;
+    if (Array.isArray(node)) {
+      node = await Promise.all(node.map((item, index) => go(item, [...path, index], 0)));
+    } else if (isPlainObject(node)) {
+      const entries = await Promise.all(Object.entries(node).map(async ([key, item]) => [key, await go(item, [...path, key], 0)]));
+      node = Object.fromEntries(entries);
+    }
+    const verdict = await visit(node, path);
+    if (verdict.kind === "replace") {
+      if (replaceDepth >= MAX_REPLACE_DEPTH) {
+        throw new TransformError("transform did not reach a fixpoint (a handler keeps producing handleable output)", path);
+      }
+      return go(verdict.value, path, replaceDepth + 1);
+    }
+    return node;
+  };
+  return go(root, [], 0);
+}
+
+// ../transformer/src/transform.ts
+function createTransformer() {
+  return build([], []);
+}
+function build(valueHandlers, messageHandlers) {
+  const transformer = {
+    withHandler(handler) {
+      const bundle = "tag" in handler ? { valueHandler: handler } : handler;
+      if (!bundle.valueHandler && !bundle.messageHandler) {
+        throw new Error("withHandler: bundle provides neither a valueHandler nor a messageHandler");
+      }
+      if (bundle.valueHandler) {
+        const { tag } = bundle.valueHandler;
+        if (valueHandlers.some((existing) => existing.tag === tag)) {
+          throw new Error(`withHandler: a ValueHandler with tag "${tag}" is already composed`);
+        }
+      }
+      return build(bundle.valueHandler ? [...valueHandlers, bundle.valueHandler] : valueHandlers, bundle.messageHandler ? [...messageHandlers, bundle.messageHandler] : messageHandlers);
+    },
+    async outbound(value, ctx) {
+      const seen = new Map;
+      const visit = (node, path) => {
+        if (!isComplexValue(node)) {
+          return recurse;
+        }
+        const handler = valueHandlers.find((candidate) => candidate.canHandle(node));
+        if (!handler) {
+          const withToJSON = node;
+          if (typeof node === "object" && typeof withToJSON.toJSON === "function") {
+            return replaceWith(withToJSON.toJSON());
+          }
+          const label = node?.constructor?.name ?? (typeof node === "function" ? "function" : typeof node);
+          throw new TransformError(`no composed ValueHandler for complex value of type ${label}`, path);
+        }
+        if (typeof node === "object" && node !== null) {
+          const cached = seen.get(node);
+          if (cached) {
+            return cached.then(replaceWith);
+          }
+          const pending = Promise.resolve(handler.serialize(node, ctx, path));
+          seen.set(node, pending);
+          return pending.then(replaceWith);
+        }
+        return Promise.resolve(handler.serialize(node, ctx, path)).then(replaceWith);
+      };
+      const valueTransformed = await walk(value, visit);
+      let body = valueTransformed;
+      for (const [index, handler] of messageHandlers.entries()) {
+        const wrapped = await handler.wrapOutbound(body, ctx);
+        assertTopLevelKeysPreserved(body, wrapped, index);
+        body = wrapped;
+      }
+      return body;
+    },
+    async inbound(value, ctx) {
+      const visit = (node, path) => {
+        if (!isPlainObject(node)) {
+          return recurse;
+        }
+        const handler = valueHandlers.find((candidate) => candidate.isReference(node));
+        if (handler) {
+          if (handler.passthrough) {
+            return recurse;
+          }
+          return Promise.resolve(handler.deserialize(node, ctx, path)).then(replaceWith);
+        }
+        if (hasReferenceTag(node)) {
+          const tag = node.__REQUENCE_type;
+          throw new TransformError(`no composed ValueHandler owns reference tag ${JSON.stringify(tag)}`, path);
+        }
+        return recurse;
+      };
+      return walk(value, visit);
+    }
+  };
+  return transformer;
+}
+function assertTopLevelKeysPreserved(body, wrapped, handlerIndex) {
+  if (!isPlainObject(body)) {
+    return;
+  }
+  const label = `MessageHandler #${handlerIndex}`;
+  if (!isPlainObject(wrapped)) {
+    throw new TransformError(`${label} replaced a record body wholesale — wrapOutbound must preserve a record's top-level keys`, []);
+  }
+  const before = Object.keys(body);
+  const after = new Set(Object.keys(wrapped));
+  const removed = before.filter((key) => !after.has(key));
+  const added = [...after].filter((key) => !before.includes(key));
+  if (removed.length > 0 || added.length > 0) {
+    throw new TransformError(`${label} changed a record body's top-level keys (removed: [${removed.join(", ")}], added: [${added.join(", ")}]) — wrapOutbound must preserve them`, []);
+  }
+}
+// src/ingress.ts
+var transformer = createTransformer().withHandler(createRequenceFileHandler()).withHandler(createRequenceStreamHandler()).withHandler(createRequenceCallbackHandler()).withHandler(createClaimCheckHandler());
+var inbound = (data, opts = {}) => transformer.inbound(data, {
+  fetch: globalThis.fetch,
+  onCallbackInvoke: opts.onCallbackInvoke
+});
+var forbidCallbacks = {
+  onCallbackInvoke: () => {
+    throw new Error("input may not have callbacks");
+  }
+};
+var observeOnlyCallbacks = {
+  onCallbackInvoke: () => {
+    throw new Error("callbacks in watched data cannot be invoked from a task client");
+  }
+};
+
 // src/protectTask.ts
 class TaskProtectError extends Error {
   taskId;
@@ -537,7 +1027,7 @@ class TaskProtectError extends Error {
 async function protectTask(options) {
   const { apiBaseUrl, token } = getAccessToken(options.accessToken);
   const protectUrl = `${apiBaseUrl}/task/protect/${options.taskId}`;
-  const response = await fetch(protectUrl, {
+  const response = await reachableFetch(protectUrl, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`
@@ -670,6 +1160,7 @@ function createTask(options, onUpdate) {
     let since = null;
     let lastPosition = null;
     let lastResponse;
+    let processing = Promise.resolve();
     const customFetch = async (url, init) => {
       const response = await fetch(url, init);
       lastResponse = response;
@@ -695,8 +1186,13 @@ function createTask(options, onUpdate) {
         }
       },
       async onDisconnect() {
-        if (lastResponse.status === 200) {
+        if (lastResponse?.status === 200) {
           eventSource.close();
+          return;
+        }
+        if (lastResponse && isUnreachableStatus(lastResponse.status)) {
+          eventSource.close();
+          resultPromiseWithResolvers.reject(new RequenceUnreachableError(lastResponse.status));
         }
       },
       onMessage({ id, event, data }) {
@@ -710,147 +1206,200 @@ function createTask(options, onUpdate) {
           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;
+        processing = processing.then(() => applyUpdate(update)).catch((error) => {
+          eventSource.close();
+          resultPromiseWithResolvers.reject(new TaskError(error instanceof Error ? error.message : String(error), options.taskTemplate, payload.taskId));
+        });
+      }
+    });
+    async function applyUpdate(update) {
+      switch (update.type) {
+        case "taskStart": {
+          taskStorage.input = await inbound(update.input, forbidCallbacks);
+          break;
+        }
+        case "nodeUpdate": {
+          if (update.node.alias) {
+            taskStorage.data[update.node.alias] = await inbound(update.data, observeOnlyCallbacks);
           }
-          case "taskError":
-          case "taskAborted": {
-            eventSource.close();
-            if (update.requireAck) {
-              ackTask({
-                taskId: payload.taskId,
-                accessToken: options.accessToken
-              }).catch(() => {});
-            }
-            break;
+          break;
+        }
+        case "nodeError": {
+          if (update.node.alias) {
+            taskStorage.errors[update.node.alias] = update.error;
           }
+          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 ?? ""
-          });
+        case "taskEnd": {
+          taskStorage.result = await inbound(update.result, observeOnlyCallbacks);
+          eventSource.close();
+          if (update.requireAck) {
+            ackTask({
+              taskId: payload.taskId,
+              accessToken: options.accessToken
+            }).catch(() => {});
+          }
+          break;
         }
-        if (contextUpdate.type === "taskError" || contextUpdate.type === "taskAborted") {
-          resultPromiseWithResolvers.reject(new TaskError(contextUpdate.reason ?? (contextUpdate.type === "taskError" ? "Task failed" : "Task aborted"), options.taskTemplate, payload.taskId));
+        case "taskError":
+        case "taskAborted": {
+          eventSource.close();
+          if (update.requireAck) {
+            ackTask({
+              taskId: payload.taskId,
+              accessToken: options.accessToken
+            }).catch(() => {});
+          }
+          break;
         }
-        taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
       }
-    });
+      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 preparedTaskIdPromiseWithResolvers = Promise.withResolvers();
+  preparedTaskIdPromiseWithResolvers.promise.catch(() => {});
   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}`
+    try {
+      const prepareResponse = await reachableFetch(prepareUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+      if (!prepareResponse.ok) {
+        const error = new TaskPrepareError(await prepareResponse.text(), options.taskTemplate);
+        preparedTaskIdPromiseWithResolvers.reject(error);
+        if (rejectTaskIdPromise) {
+          taskIdPromiseWithResolvers.reject(error);
+        }
+        if (rejectTaskUrlPromise) {
+          taskUrlPromiseWithResolvers.reject(error);
+        }
+        if (isMonitoring) {
+          resultPromiseWithResolvers.reject(error);
+        }
+        return;
       }
-    });
-    if (!prepareResponse.ok) {
-      const error = new TaskPrepareError(await prepareResponse.text(), options.taskTemplate);
-      finalizedPromiseWithResolvers.reject(error);
-      if (rejectTaskIdPromise) {
-        taskIdPromiseWithResolvers.reject(error);
+      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"));
       }
-      if (rejectTaskUrlPromise) {
-        taskUrlPromiseWithResolvers.reject(error);
+      preparedTaskIdPromiseWithResolvers.resolve(prepareData.taskId);
+      const streamDone = Promise.withResolvers();
+      streamDone.promise.catch(() => {});
+      let mappedParams;
+      try {
+        const { value, done } = await withRequenceStreams(() => transformer.outbound({
+          name: options.name,
+          input: options.input,
+          priority,
+          requireAck: options.requireAck ?? false
+        }, {
+          fetch: globalThis.fetch,
+          uploadUrl: prepareData.fileUrls?.uploadUrl,
+          streamUrl: prepareData.fileUrls?.streamUrl,
+          maxPayloadSize: prepareData.limits?.maxPayloadSize,
+          maxFileSize: prepareData.limits?.maxFileSize
+        }));
+        mappedParams = value;
+        done.then(() => streamDone.resolve(), (error) => streamDone.reject(error instanceof Error ? error : new Error(String(error))));
+      } catch (error) {
+        const taskError = new TaskError(error instanceof Error ? error.message : String(error), options.taskTemplate, prepareData.taskId);
+        if (rejectTaskIdPromise) {
+          taskIdPromiseWithResolvers.reject(taskError);
+        }
+        if (rejectTaskUrlPromise) {
+          taskUrlPromiseWithResolvers.reject(taskError);
+        }
+        if (isMonitoring) {
+          resultPromiseWithResolvers.reject(taskError);
+        }
+        return;
       }
-      if (isMonitoring) {
-        resultPromiseWithResolvers.reject(error);
+      const finalizeResponse = await reachableFetch(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);
+        if (rejectTaskIdPromise) {
+          taskIdPromiseWithResolvers.reject(error);
+        }
+        if (rejectTaskUrlPromise) {
+          taskUrlPromiseWithResolvers.reject(error);
+        }
+        if (isMonitoring) {
+          resultPromiseWithResolvers.reject(error);
+        }
+        return;
       }
-      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
+      try {
+        await streamDone.promise;
+      } catch (error) {
+        const taskError = new TaskError(error instanceof Error ? error.message : String(error), options.taskTemplate, prepareData.taskId);
+        if (rejectTaskIdPromise) {
+          taskIdPromiseWithResolvers.reject(taskError);
+        }
+        if (rejectTaskUrlPromise) {
+          taskUrlPromiseWithResolvers.reject(taskError);
+        }
+        if (isMonitoring) {
+          resultPromiseWithResolvers.reject(taskError);
+        }
+        return;
       }
-    });
-    const finalizeResponse = await fetch(prepareData.finalizeUrl, {
-      method: "POST",
-      body: JSON.stringify(mappedParams),
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
+      const payload = await finalizeResponse.json();
+      taskIdPromiseWithResolvers.resolve(prepareData.taskId);
+      taskUrlPromiseWithResolvers.resolve(payload.urls?.show ?? null);
+      payloadPromiseWithResolvers.resolve(payload);
+      if (onUpdate) {
+        taskUpdateHandlers.add(onUpdate);
+        startMonitoring();
+      }
+    } catch (error) {
+      preparedTaskIdPromiseWithResolvers.reject(error);
+      if (rejectTaskIdPromise) {
+        taskIdPromiseWithResolvers.reject(error);
       }
-    });
-    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) => {
@@ -889,7 +1438,7 @@ function createTask(options, onUpdate) {
       return taskUrlPromiseWithResolvers.promise;
     },
     async abort(reason) {
-      const taskId = await taskIdPromiseWithResolvers.promise;
+      const taskId = await preparedTaskIdPromiseWithResolvers.promise;
       await abortTask({
         taskId,
         accessToken: options.accessToken,
@@ -897,14 +1446,11 @@ function createTask(options, onUpdate) {
       });
     },
     async protect() {
-      const taskId = await taskIdPromiseWithResolvers.promise;
+      const taskId = await preparedTaskIdPromiseWithResolvers.promise;
       await protectTask({
         taskId,
         accessToken: options.accessToken
       });
-    },
-    async finalized() {
-      return finalizedPromiseWithResolvers.promise;
     }
   };
   return Object.defineProperties(asyncIterable, Object.getOwnPropertyDescriptors(methods));
@@ -921,6 +1467,7 @@ function watchTasks(options) {
   let startDate = options.since;
   let lastPosition = null;
   let lastResponse;
+  let processing = Promise.resolve();
   const customFetch = async (url, init) => {
     const response = await fetch(url, init);
     lastResponse = response;
@@ -952,6 +1499,9 @@ function watchTasks(options) {
     },
     async onDisconnect() {
       if (lastResponse) {
+        if (isUnreachableStatus(lastResponse.status)) {
+          options.onUnreachable?.(new RequenceUnreachableError(lastResponse.status));
+        }
         options.onError?.(lastResponse.status, lastResponse.statusText);
       }
     },
@@ -965,82 +1515,85 @@ function watchTasks(options) {
         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
-        });
+      processing = processing.then(() => applyUpdate(update, id)).catch(() => {
+        eventSource.close();
+      });
+    }
+  });
+  async function applyUpdate(update, updateId) {
+    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 = await inbound(update.input, forbidCallbacks);
+        storageEntry.incomplete = false;
+        storageEntry.rootTaskId = update.rootTaskId;
+        break;
       }
-      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 "nodeUpdate": {
+        if (update.node.alias) {
+          storageEntry.data[update.node.alias] = await inbound(update.data, observeOnlyCallbacks);
         }
-        case "nodeError": {
-          if (update.node.alias) {
-            storageEntry.errors[update.node.alias] = update.error;
-          }
-          break;
+        break;
+      }
+      case "nodeError": {
+        if (update.node.alias) {
+          storageEntry.errors[update.node.alias] = update.error;
         }
-        case "taskEnd": {
-          storageEntry.result = resolveRequenceTypes(update.result);
-          taskStorage.delete(update.taskId);
-          if (update.requireAck) {
-            ackTask({
-              taskId: update.taskId,
-              accessToken: options.accessToken
-            }).catch(() => {});
-          }
-          break;
+        break;
+      }
+      case "taskEnd": {
+        storageEntry.result = await inbound(update.result, observeOnlyCallbacks);
+        taskStorage.delete(update.taskId);
+        if (update.requireAck) {
+          ackTask({
+            taskId: update.taskId,
+            accessToken: options.accessToken
+          }).catch(() => {});
         }
-        case "taskError":
-        case "taskAborted": {
-          taskStorage.delete(update.taskId);
-          if (update.requireAck) {
-            ackTask({
-              taskId: update.taskId,
-              accessToken: options.accessToken
-            }).catch(() => {});
-          }
-          break;
+        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 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,
+      incomplete: storageEntry.incomplete,
+      rootTaskId: storageEntry.rootTaskId
+    };
+    taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
+  }
   const asyncIterable = callbackToAsyncIterable((push) => {
     taskUpdateHandlers.add(push);
     return () => {
@@ -1076,7 +1629,7 @@ var taskSchema = z6.object({
 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}`), {
+  const response = await reachableFetch(new URL(`${apiBaseUrl}/task/${taskId}`), {
     headers: {
       Authorization: `Bearer ${token}`
     }
@@ -1085,18 +1638,24 @@ async function getTask(taskIdOrOptions) {
     throw new Error("Task not found");
   }
   const taskData = taskSchema.parse(await response.json());
+  const [input, result, nodesData] = await Promise.all([
+    inbound(taskData.input, forbidCallbacks),
+    inbound(taskData.result, observeOnlyCallbacks),
+    Promise.all(taskData.nodesData.map(async ({ alias, data }) => ({
+      alias,
+      data: await inbound(data, observeOnlyCallbacks)
+    })))
+  ]);
   const context = {
     taskId,
-    input: resolveRequenceTypes(taskData.input, () => {
-      throw new Error("input may not have callbacks");
-    }),
+    input,
     getNodeData(alias) {
-      return resolveRequenceTypes(taskData.nodesData.find((d) => d.alias === alias)?.data);
+      return nodesData.find((d) => d.alias === alias)?.data ?? null;
     },
     getNodeError(alias) {
       return taskData.nodesError.find((d) => d.alias === alias)?.error ?? null;
     },
-    result: resolveRequenceTypes(taskData.result)
+    result
   };
   return {
     status: taskData.status,
@@ -1126,9 +1685,10 @@ export {
   createTask,
   abortTask,
   TaskError,
+  RequenceUnreachableError,
   RequenceStream,
   RequenceFile
 };
 
-//# debugId=72085AB5595C0E1D64756E2164756E21
+//# debugId=F96A579BA4EB8E1D64756E2164756E21
 //# sourceMappingURL=index.js.map