@requence/service 0.7.1 → 0.8.2-edge.1149

package/build/index.js

@@ -1,7 +1,19 @@
 import {
+  CAPABILITY_HEADER_KEYS,
+  PayloadTooLargeError,
+  RequenceConnectionError,
+  RequenceUnreachableError,
+  UnsupportedCapabilityError,
+  assertReachable,
+  buildServiceClientProperties,
+  buildServiceIdentityHeaders,
   deobfuscate,
-  obfuscate
-} from "./chunk-6w7td62p.js";
+  isUnreachableStatus,
+  obfuscate,
+  reachableFetch,
+  readRequiredCapabilities,
+  unsupportedCapabilities
+} from "./chunk-974rc2jy.js";
 
 // src/index.ts
 import fs from "node:fs";
@@ -49,7 +61,8 @@ function mapData(data, visitors) {
       if (data2 === null) {
         return notUndefined(visitors.Null?.(data2, path), data2);
       }
-      if (typeof Buffer !== "undefined" && Buffer.isBuffer(data2)) {
+      const runtimeBuffer = globalThis.Buffer;
+      if (runtimeBuffer?.isBuffer(data2)) {
         return notUndefined(visitors.Buffer?.(data2, path), data2);
       }
       if (typeof data2 === "string") {
@@ -65,7 +78,7 @@ function mapData(data, visitors) {
         return notUndefined(visitors.Function?.(data2, path), data2);
       }
       if (isRecord(data2)) {
-        return resolve(visitors.Object?.(structuredClone(data2), path), (resolvedData) => {
+        return resolve(visitors.Object?.({ ...data2 }, path), (resolvedData) => {
           const nextData = resolvedData ?? data2;
           if (!isRecord(nextData)) {
             return nextData;
@@ -98,14 +111,66 @@ mapData.abort = () => {
   throw new AbortMapData;
 };
 
-// ../helpers/src/utils/requenceCallback.ts
+// ../helpers/src/utils/fileObject.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")
+var fileObjectSchema = z2.object({
+  size: z2.int().positive(),
+  mime: z2.string(),
+  url: z2.url(),
+  __REQUENCE_type: z2.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 z3 } from "zod/v4";
+var streamObjectSchema = z3.object({
+  mime: z3.string(),
+  url: z3.string().url(),
+  __REQUENCE_type: z3.literal("RequenceStream")
+});
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
+function toStreamObject(streamInfo) {
+  return {
+    ...streamInfo,
+    __REQUENCE_type: "RequenceStream"
+  };
+}
+
+// ../helpers/src/utils/claimCheckObject.ts
+import { z as z4 } from "zod/v4";
+var claimCheckObjectSchema = z4.object({
+  url: z4.url(),
+  size: z4.int().positive(),
+  __REQUENCE_type: z4.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 z5 } from "zod/v4";
+var callbackObjectSchema = z5.object({
+  sourceId: z5.string(),
+  outputName: z5.string().nullable(),
+  propertyPath: z5.array(z5.union([z5.string(), z5.int()])),
+  callbackId: z5.uuid(),
+  __REQUENCE_type: z5.literal("RequenceCallback")
 });
 function isCallbackObject(data) {
   return callbackObjectSchema.safeParse(data).success;
@@ -123,36 +188,270 @@ function createCallback(callback) {
   });
 }
 
-// ../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")
+// ../helpers/src/utils/amqpHeartbeat.ts
+var DEFAULT_AMQP_HEARTBEAT_SECONDS = 30;
+
+// ../helpers/src/msgpack/index.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { Packr, addExtension } from "msgpackr";
+var MSGPACK_EXTENSION_IDS = {
+  referenceCounter: 1,
+  nodeTree: 2,
+  url: 3
+};
+var packingForWire = false;
+addExtension({
+  Class: URL,
+  get type() {
+    return packingForWire ? undefined : MSGPACK_EXTENSION_IDS.url;
+  },
+  write: (v) => v.href,
+  read: (href) => new URL(href)
 });
-function toFileObject(fileInfo) {
+var packr = new Packr({ structuredClone: true });
+var wirePackr = new Packr({
+  useRecords: false,
+  structuredClone: false,
+  encodeUndefinedAsNil: true,
+  mapAsEmptyObject: true,
+  setAsEmptyObject: true,
+  int64AsType: "number"
+});
+function packWire(value) {
+  packingForWire = true;
+  try {
+    return wirePackr.pack(value);
+  } finally {
+    packingForWire = false;
+  }
+}
+function unpackWire(buffer) {
+  return wirePackr.unpack(buffer);
+}
+function wireByteLength(value) {
+  return wirePackr.pack(value).length;
+}
+var WIRE_CONTENT_TYPES = {
+  json: "application/json",
+  msgpack: "application/msgpack"
+};
+function wireCodecFromContentType(contentType) {
+  return contentType === WIRE_CONTENT_TYPES.msgpack ? "msgpack" : "json";
+}
+function encodeWireBody(value, codec) {
   return {
-    ...fileInfo,
-    __REQUENCE_type: "RequenceFile"
+    body: codec === "msgpack" ? packWire(value) : Buffer2.from(JSON.stringify(value ?? null)),
+    contentType: WIRE_CONTENT_TYPES[codec]
   };
 }
-function isFileObject(data) {
-  return fileObjectSchema.safeParse(data).success;
+function decodeWireBody(content, contentType) {
+  return wireCodecFromContentType(contentType) === "msgpack" ? unpackWire(content) : JSON.parse(Buffer2.from(content).toString());
+}
+function wireBodyByteLength(value, codec) {
+  if (codec === "msgpack") {
+    return wireByteLength(value);
+  }
+  const json = JSON.stringify(value);
+  return json === undefined ? 0 : Buffer2.byteLength(json);
+}
+
+// src/createAmqpConnection.ts
+import { connect } from "amqp-connection-manager";
+import { z as z6 } from "zod/v4";
+
+// ../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 (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;
+      }
+      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;
+        }
+        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}`);
+          }
+        }
+      }
+    },
+    flush(controller) {
+      if (!terminal) {
+        controller.error(new RequenceStreamTruncatedError("connection closed before terminal frame"));
+      }
+    }
+  });
+}
+
+// ../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;
+    }
+  };
+  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
+      });
+    }
+  }
+  const armTimer = () => {
+    if (timeoutMs <= 0) {
+      return;
+    }
+    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 (!response.ok) {
+        await response.body?.cancel();
+        cleanup();
+        streamController.error(new Error(`remote read failed: ${response.status} ${response.statusText}`));
+        return;
+      }
+      if (!response.body) {
+        cleanup();
+        streamController.error(new Error("remote read response has no body"));
+        return;
+      }
+      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;
+      }
+      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);
+      }
+    },
+    async cancel(reason) {
+      cleanup();
+      controller.abort(reason);
+      await reader?.cancel(reason);
+    }
+  });
+}
+
+// ../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;
   }
@@ -168,39 +467,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;
@@ -209,13 +543,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;
   }
@@ -229,12 +567,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();
@@ -248,6 +588,11 @@ class RequenceStream {
             reader.cancel();
             reader.releaseLock();
             return { done: true, value: null };
+          },
+          async throw() {
+            reader.cancel();
+            reader.releaseLock();
+            return { done: true, value: null };
           }
         };
       }
@@ -256,163 +601,564 @@ class RequenceStream {
   toString() {
     return `RequenceStream<${this.mimeType}>`;
   }
-  toJSON() {
-    return `RequenceStream<${this.mimeType}>`;
-  }
 }
-
-// ../helpers/src/files/streamObject.ts
-import { z as z4 } from "zod/v4";
-var streamObjectSchema = z4.object({
-  mime: z4.string(),
-  url: z4.string().url(),
-  __REQUENCE_type: z4.literal("RequenceStream")
-});
-function isStreamObject(data) {
-  return streamObjectSchema.safeParse(data).success;
-}
-function toStreamObject(streamInfo) {
-  return {
-    ...streamInfo,
-    __REQUENCE_type: "RequenceStream"
-  };
+// ../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}` : ""}`);
 }
 
-// ../helpers/src/files/mapOutput.ts
-async function upload(uploadUrl, body, signal, contentType) {
-  const uploadResponse = await fetch(uploadUrl, {
+// ../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];
-}
-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 (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 };
+}
+function createRequenceStreamHandler() {
+  return {
+    tag: "RequenceStream",
+    canHandle: (value) => RequenceStream.canHandle(value),
+    async serialize(value, ctx) {
+      if (value instanceof RequenceStream && value.streamObject) {
+        return value.streamObject;
+      }
+      if (!ctx.streamUrl) {
+        ctx.onOffloadSkip?.();
+        return null;
+      }
+      const body = value instanceof Response ? value.body ?? new ReadableStream({
+        start(controller) {
+          controller.close();
         }
-        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;
+      }) : 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;
         }
-      }
-      if (obj instanceof Response || obj instanceof RequenceStream) {
-        if (obj instanceof RequenceStream && obj.streamObject) {
-          return obj.streamObject;
+        return ref;
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
         }
-        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?.();
+        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 as Buffer3 } from "node:buffer";
+var DEFAULT_MAX_PAYLOAD_SIZE = 4 * 1024 * 1024;
+function isRecord2(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) {
+function jsonByteLength(value) {
+  const json = JSON.stringify(value);
+  return json === undefined ? 0 : Buffer3.byteLength(json);
+}
+function createMessageHandler() {
+  return {
+    async wrapOutbound(body, ctx) {
+      const maxBytes = ctx.maxPayloadSize ?? DEFAULT_MAX_PAYLOAD_SIZE;
+      if (maxBytes <= 0 || body === undefined) {
+        return body;
+      }
+      const measure = ctx.measure ?? jsonByteLength;
+      if (measure(body) <= maxBytes) {
+        return body;
+      }
+      const { uploadUrl } = ctx;
+      if (!uploadUrl) {
+        ctx.onOffloadSkip?.();
+        return body;
+      }
+      if (!isRecord2(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()
+  };
+}
+// ../files/src/sanitizeLogData.ts
+function sanitizeLogData(data) {
   return mapData(data, {
+    Function: () => "[Function]",
+    Symbol: (sym) => String(sym),
     Object(obj) {
-      if (isFileObject(obj)) {
-        return RequenceFile.fromFileObject(obj);
+      if (RequenceFile.canHandle(obj) || RequenceStream.canHandle(obj)) {
+        return;
       }
-      if (isStreamObject(obj)) {
-        return RequenceStream.fromStreamObject(obj);
+      const proto = Object.getPrototypeOf(obj);
+      if (proto === null || proto === Object.prototype) {
+        return;
       }
-      if (isCallbackObject(obj)) {
-        return (arg) => {
-          onCallback?.({ ...obj, arg });
-        };
+      if (typeof obj.toJSON === "function") {
+        return;
       }
+      return String(obj);
     }
   });
 }
+// ../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;
+}
 
-// src/createAmqpConnection.ts
-import { connect } from "amqp-connection-manager";
-import { z as z5 } from "zod/v4";
+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/transformer.ts
+var transformer = createTransformer().withHandler(createRequenceFileHandler()).withHandler(createRequenceStreamHandler()).withHandler(createRequenceCallbackHandler()).withHandler(createClaimCheckHandler());
+var passthroughHandler = (handler) => ({
+  tag: handler.tag,
+  passthrough: true,
+  canHandle: () => false,
+  serialize() {
+    throw new Error(`passthrough handler "${handler.tag}" is inbound-only`);
+  },
+  isReference: (value) => handler.isReference(value),
+  deserialize(ref) {
+    return ref;
+  }
+});
+var passthroughInboundTransformer = createTransformer().withHandler(passthroughHandler(createRequenceFileHandler())).withHandler(passthroughHandler(createRequenceStreamHandler())).withHandler(passthroughHandler(createRequenceCallbackHandler())).withHandler(createClaimCheckHandler());
 
-// src/errors.ts
-class RequenceConnectionError extends Error {
+// src/boundary.ts
+function createOutboundBoundary(base) {
+  const warn = base.warn ?? ((message, error) => error === undefined ? console.warn(message) : console.warn(message, error));
+  const ledger = [];
+  const errors = [];
+  const codec = base.wireCodec ?? "json";
+  const measure = (value) => wireBodyByteLength(value, codec);
+  const track = (promise) => {
+    ledger.push(promise.then(() => {}, (error) => {
+      errors.push(error instanceof Error ? error : new Error(String(error)));
+    }));
+  };
+  return {
+    track,
+    async send(data, opts = {}) {
+      const ctx = {
+        fetch: base.fetch ?? globalThis.fetch,
+        signal: base.signal,
+        uploadUrl: base.uploadUrl,
+        streamUrl: base.streamUrl,
+        maxPayloadSize: base.maxPayloadSize,
+        maxFileSize: base.maxFileSize,
+        measure,
+        outputName: opts.outputName ?? null,
+        onCallback: opts.onCallback,
+        ...opts.bestEffort ? {
+          onOffloadFail: (error) => warn("offload failed (best-effort log path):", error),
+          onOffloadSkip: () => warn("offload skipped: no upload transport configured")
+        } : {}
+      };
+      if (opts.bestEffort) {
+        try {
+          const { value: value2, done: done2 } = await withRequenceStreams(() => transformer.outbound(sanitizeLogData(data), ctx));
+          ledger.push(done2.then(() => {}, (error) => warn("log stream upload failed:", error)));
+          return value2;
+        } catch (error) {
+          warn("log offload errored:", error);
+          return;
+        }
+      }
+      const { value, done } = await withRequenceStreams(() => transformer.outbound(data, ctx));
+      track(done);
+      return value;
+    },
+    async settle() {
+      for (;; ) {
+        const count = ledger.length;
+        await Promise.all(ledger);
+        if (count === ledger.length) {
+          break;
+        }
+      }
+      if (errors.length > 0) {
+        const failed = errors.splice(0);
+        throw new AggregateError(failed, failed[0].message);
+      }
+    }
+  };
+}
+function createInboundBoundary(base = {}) {
+  return (data, opts = {}) => {
+    const timeout = base.timeoutMs && base.timeoutMs > 0 ? AbortSignal.timeout(base.timeoutMs) : undefined;
+    const signal = base.signal && timeout ? AbortSignal.any([base.signal, timeout]) : timeout ?? base.signal;
+    const ctx = {
+      fetch: base.fetch ?? globalThis.fetch,
+      signal,
+      onCallbackInvoke: opts.onCallbackInvoke ?? base.onCallbackInvoke
+    };
+    return (base.transformer ?? transformer).inbound(data, ctx);
+  };
 }
 
 // src/helpers.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 class RetryError extends Error {
   delay;
   constructor(delay) {
@@ -430,124 +1176,87 @@ var OUTPUT_VALUE = Symbol("output_value");
 function isOutputValue(value) {
   return value !== null && typeof value === "object" && OUTPUT_VALUE in value;
 }
-function processData(params) {
-  return mapOutput({
-    value: mapData(params.data, {
-      Function(data, path) {
-        return {
-          ...params.onCallback(data),
-          outputName: params.outputName,
-          propertyPath: path,
-          __REQUENCE_type: "RequenceCallback"
-        };
-      }
-    }),
-    options: params.options,
-    onDone: params.onDone
-  });
-}
-async function unwrapResult(params) {
-  if (isOutputValue(params.result)) {
-    return {
-      value: await processData({
-        outputName: params.result[OUTPUT_VALUE],
-        data: params.result.value,
-        options: params.options,
-        onDone: params.onDone,
-        onCallback: params.onCallback
-      }),
-      outputName: params.result[OUTPUT_VALUE]
-    };
+function unwrapOutputValue(result) {
+  if (isOutputValue(result)) {
+    return { value: result.value, outputName: result[OUTPUT_VALUE] };
   }
-  return {
-    value: await processData({
-      outputName: null,
-      data: params.result,
-      options: params.options,
-      onDone: params.onDone,
-      onCallback: params.onCallback
-    }),
-    outputName: null
-  };
+  return { value: result, outputName: null };
 }
-function createContextHelper(options) {
+async function createContextHelper(options) {
   const terminatePromise = Promise.withResolvers();
-  const abortController = new AbortController;
+  const abortController = options.abortController ?? new AbortController;
   terminatePromise.promise.then(() => abortController.abort());
   const terminated = Object.assign(terminatePromise.promise, {
     signal: abortController.signal
   });
-  return [
-    {
-      taskId: options.taskId,
-      input: resolveRequenceTypes(options.input, options.onCallback),
-      configuration: resolveRequenceTypes(options.configuration, () => {
+  const inbound = createInboundBoundary({
+    signal: abortController.signal,
+    ...options.passthroughByteReferences ? { transformer: passthroughInboundTransformer } : {}
+  });
+  const [input, configuration] = await Promise.all([
+    inbound(options.input, { onCallbackInvoke: options.onCallback }),
+    inbound(options.configuration, {
+      onCallbackInvoke: () => {
         throw new Error("configuration may not have callbacks");
-      }),
-      toOutput(name, value) {
-        return {
-          [OUTPUT_VALUE]: name,
-          value
-        };
-      },
-      defer: options.onDefer,
-      debug: {
-        log(...data) {
-          options.onLog("log", data);
-        },
-        info(...data) {
-          options.onLog("info", data);
-        },
-        warn(...data) {
-          options.onLog("warn", data);
-        },
-        error(...data) {
-          options.onLog("error", data);
-        }
-      },
-      retry(delay) {
-        throw new RetryError(delay);
+      }
+    })
+  ]);
+  const context = {
+    taskId: options.taskId,
+    input,
+    configuration,
+    toOutput(name, value) {
+      return {
+        [OUTPUT_VALUE]: name,
+        value
+      };
+    },
+    defer: options.onDefer,
+    debug: {
+      log(...data) {
+        options.onLog("log", data);
       },
-      abort(reason) {
-        throw new AbortError(reason);
+      info(...data) {
+        options.onLog("info", data);
       },
-      skip() {
-        throw new SkipError;
+      warn(...data) {
+        options.onLog("warn", data);
       },
-      terminated
-    },
-    terminatePromise
-  ];
-}
-var handlerStorage = new AsyncLocalStorage;
-
-// src/mapInput.ts
-function mapInput(data) {
-  return mapData(data, {
-    Object(obj) {
-      if (isFileObject(obj)) {
-        return RequenceFile.fromFileObject(obj);
+      error(...data) {
+        options.onLog("error", data);
       }
-      if (isStreamObject(obj)) {
-        return RequenceStream.fromStreamObject(obj);
-      }
-    }
-  });
+    },
+    retry(delay) {
+      throw new RetryError(delay);
+    },
+    abort(reason) {
+      throw new AbortError(reason);
+    },
+    skip() {
+      throw new SkipError;
+    },
+    terminated
+  };
+  Object.assign(context, options.sends);
+  return [context, terminatePromise];
 }
+var handlerStorage = new AsyncLocalStorage2;
 
 // src/createAmqpConnection.ts
-var messageKeySchema = z5.string().transform((str) => deobfuscate(str)).pipe(z5.tuple([z5.uuid(), z5.uuid()]).rest(z5.string())).transform((arr) => ({
+var messageKeySchema = z6.string().transform((str) => deobfuscate(str)).pipe(z6.tuple([z6.uuid(), z6.uuid()]).rest(z6.string())).transform((arr) => ({
   taskId: arr[0],
   messageId: arr[1],
   uploadUrl: arr[2] || undefined,
-  streamUrl: arr[3] || undefined
+  streamUrl: arr[3] || undefined,
+  maxPayloadSize: arr[4] && Number.isFinite(Number(arr[4])) ? Number(arr[4]) : undefined,
+  maxFileSize: arr[5] && Number.isFinite(Number(arr[5])) ? Number(arr[5]) : undefined
 }));
-var headerSchema = z5.object({
-  properties: z5.object({
-    correlationId: z5.uuid(),
-    headers: z5.object({
-      taskId: z5.uuid(),
-      mode: z5.enum(["LINEAR", "CONTINUOUS"]).default("LINEAR")
+var headerSchema = z6.object({
+  properties: z6.object({
+    correlationId: z6.uuid(),
+    headers: z6.object({
+      taskId: z6.uuid(),
+      mode: z6.enum(["LINEAR", "CONTINUOUS"]).default("LINEAR")
     })
   })
 }).transform((msg) => ({
@@ -555,62 +1264,136 @@ var headerSchema = z5.object({
   taskId: msg.properties.headers.taskId,
   mode: msg.properties.headers.mode
 }));
-var payloadSchema = z5.object({ content: z5.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z5.object({
-  input: z5.unknown(),
-  configuration: z5.unknown(),
-  options: z5.object({
-    uploadUrl: z5.url().optional(),
-    streamUrl: z5.url().optional()
+var payloadSchema = z6.object({
+  content: z6.instanceof(Buffer),
+  properties: z6.object({ contentType: z6.string().optional() })
+}).transform((msg) => decodeWireBody(msg.content, msg.properties.contentType)).pipe(z6.object({
+  input: z6.unknown(),
+  configuration: z6.unknown(),
+  options: z6.object({
+    uploadUrl: z6.url().optional(),
+    streamUrl: z6.url().optional(),
+    maxPayloadSize: z6.number().optional(),
+    maxFileSize: z6.number().optional()
   })
 }));
-var backchannelMessageSchema = z5.object({
-  content: z5.instanceof(Buffer).transform((content) => JSON.parse(content.toString())).pipe(z5.discriminatedUnion("type", [
-    z5.object({
-      type: z5.literal("stop")
+var backchannelMessageSchema = z6.object({
+  content: z6.instanceof(Buffer),
+  properties: z6.object({
+    correlationId: z6.string(),
+    contentType: z6.string().optional()
+  })
+}).transform((message) => ({
+  ...message,
+  content: decodeWireBody(message.content, message.properties.contentType)
+})).pipe(z6.object({
+  content: z6.discriminatedUnion("type", [
+    z6.object({
+      type: z6.literal("stop")
     }),
-    z5.object({
-      type: z5.literal("callback"),
-      callbackId: z5.uuid(),
-      arg: z5.any()
+    z6.object({
+      type: z6.literal("callback"),
+      callbackId: z6.uuid(),
+      arg: z6.any()
     })
-  ])),
-  properties: z5.object({
-    correlationId: z5.string()
+  ]),
+  properties: z6.object({
+    correlationId: z6.string()
   })
-}).transform((message) => ({
+})).transform((message) => ({
   payload: message.content,
   messageId: message.properties.correlationId
 }));
 var abortSymbol = Symbol();
-var connectionOptionsSchema = z5.object({
-  url: z5.union([
-    z5.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
-    z5.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+var connectionOptionsSchema = z6.object({
+  url: z6.union([
+    z6.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
+    z6.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
   ]),
-  version: z5.string(),
-  devOverlay: z5.string().optional(),
-  silent: z5.boolean().optional(),
-  prefetch: z5.number().int().optional(),
-  connectionTimeout: z5.number().positive().default(3000),
-  connectionOptions: z5.any().optional()
+  version: z6.string(),
+  name: z6.string().optional(),
+  devOverlay: z6.string().optional(),
+  silent: z6.boolean().optional(),
+  prefetch: z6.number().int().optional(),
+  connectionTimeout: z6.number().positive().default(3000),
+  heartbeatInterval: z6.number().int().positive().optional(),
+  connectionOptions: z6.any().optional(),
+  maxMessageSize: z6.number().int().positive().default(128 * 1024 * 1024),
+  passthroughByteReferences: z6.boolean().optional()
 });
 function isMessageHandlerGenerator(handler) {
   return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
 }
 var activeMessages = new Map;
+var messageCodecs = new Map;
+function isChannelClosedError(error) {
+  return error instanceof Error && error.name === "IllegalOperationError";
+}
+function safeAck(channel, message) {
+  try {
+    channel.ack(message);
+  } catch (error) {
+    if (!isChannelClosedError(error)) {
+      throw error;
+    }
+  }
+}
+function safeNack(channel, message) {
+  try {
+    channel.nack(message);
+  } catch (error) {
+    if (!isChannelClosedError(error)) {
+      throw error;
+    }
+  }
+}
 function createConnection({
   url,
   version,
   prefetch = 1,
   silent = false,
   connectionTimeout,
+  heartbeatInterval = DEFAULT_AMQP_HEARTBEAT_SECONDS,
   connectionOptions,
-  devOverlay = ""
+  name,
+  devOverlay = "",
+  maxMessageSize,
+  onConnectionStateChange,
+  ...rest
 }, messageHandler) {
+  const passthroughByteReferences = rest.passthroughByteReferences ?? false;
   const baseQueue = `${url.username}@${version}`;
   const queue = devOverlay ? `${baseQueue}-dev-overlay-${devOverlay}` : baseQueue;
   const exchange = url.username;
-  const connection = connect(url.toString(), { connectionOptions });
+  const connection = connect(url.toString(), {
+    connectionOptions: {
+      ...connectionOptions,
+      clientProperties: {
+        ...connectionOptions?.clientProperties,
+        ...buildServiceClientProperties({
+          libVersion: "javascript@0.8.2-edge.1149",
+          serviceVersion: version,
+          name,
+          devOverlay: Boolean(devOverlay)
+        })
+      }
+    },
+    heartbeatIntervalInSeconds: heartbeatInterval
+  });
+  connection.on("disconnect", ({ err }) => {
+    if (!silent && err) {
+      console.error("Requence AMQP connection lost:", err.message);
+    }
+    onConnectionStateChange?.({ connected: false, err });
+  });
+  let hasConnected = false;
+  connection.on("connect", () => {
+    if (hasConnected && !silent) {
+      console.info("Requence AMQP reconnected");
+    }
+    hasConnected = true;
+    onConnectionStateChange?.({ connected: true });
+  });
   const connectedPromise = new Promise((resolve2, reject) => {
     const unsubscribe = () => {
       clearTimeout(timeout);
@@ -641,6 +1424,7 @@ function createConnection({
   const backchannelQueue = `${baseQueue}-backchannel-${connectionId}`;
   const generatorTerminators = new Map;
   const callbacks = new Map;
+  const backchannelInbound = createInboundBoundary(passthroughByteReferences ? { transformer: passthroughInboundTransformer } : {});
   const channelWrapper = connection.createChannel({
     async setup(channel) {
       if (devOverlay) {
@@ -667,7 +1451,20 @@ function createConnection({
             break;
           }
           case "callback": {
-            callbacks.get(backchannelMessage.payload.callbackId)?.(backchannelMessage.payload.arg);
+            const entry = callbacks.get(backchannelMessage.payload.callbackId);
+            if (!entry) {
+              break;
+            }
+            let arg;
+            try {
+              arg = await backchannelInbound(backchannelMessage.payload.arg, {
+                onCallbackInvoke: entry.onCallbackInvoke
+              });
+            } catch (error) {
+              console.warn(`dropped callback invocation |${backchannelMessage.payload.callbackId}|: argument rehydration failed`, error instanceof Error ? error.message : error);
+              break;
+            }
+            entry.callback(arg);
             break;
           }
         }
@@ -676,24 +1473,85 @@ function createConnection({
       });
     }
   });
+  channelWrapper.on("error", (err) => {
+    if (!silent) {
+      console.error("Requence AMQP channel error:", err.message);
+    }
+  });
   const publish = ({
     data,
     outputName,
     messageId,
     priority,
     ...headers
-  }) => channelWrapper.publish(exchange, "", Buffer.from(JSON.stringify(data ?? null)), {
-    correlationId: messageId,
-    contentType: "application/json",
-    persistent: true,
-    priority,
-    headers: {
-      outputName: outputName ?? null,
-      connectionId,
-      libVersion: "javascript@0.7.1",
-      ...headers
+  }) => {
+    const { body, contentType } = encodeWireBody(data ?? null, messageCodecs.get(messageId) ?? "json");
+    if (body.byteLength > maxMessageSize) {
+      return Promise.reject(new PayloadTooLargeError(body.byteLength, maxMessageSize));
     }
-  });
+    return channelWrapper.publish(exchange, "", body, {
+      correlationId: messageId,
+      contentType,
+      persistent: true,
+      priority,
+      headers: {
+        outputName: outputName ?? null,
+        connectionId,
+        ...headers
+      }
+    });
+  };
+  const buildSendApi = (deps) => {
+    const base = {
+      ...deps.epoch === undefined ? {} : { epoch: deps.epoch },
+      ...deps.priority === undefined ? {} : { priority: deps.priority }
+    };
+    return {
+      async sendToOutput(outputName, data, options) {
+        await deps.gate?.();
+        deps.outbound.track(publish({
+          index: deps.nextIndex(),
+          version,
+          messageId: deps.messageId,
+          taskId: deps.taskId,
+          data: await deps.outbound.send(data, {
+            outputName,
+            onCallback: deps.registerCallback
+          }),
+          outputName,
+          ...options?.overwrite ? { overwrite: true } : {},
+          ...base
+        }));
+      },
+      async send(data, options) {
+        await deps.gate?.();
+        deps.outbound.track(publish({
+          index: deps.nextIndex(),
+          version,
+          messageId: deps.messageId,
+          taskId: deps.taskId,
+          data: await deps.outbound.send(data, {
+            outputName: null,
+            onCallback: deps.registerCallback
+          }),
+          ...options?.overwrite ? { overwrite: true } : {},
+          ...base
+        }));
+      },
+      async sendState(state) {
+        await deps.gate?.();
+        deps.outbound.track(publish({
+          index: 0,
+          version,
+          messageId: deps.messageId,
+          taskId: deps.taskId,
+          data: await deps.outbound.send(state, { outputName: null }),
+          state: true,
+          ...base
+        }));
+      }
+    };
+  };
   channelWrapper.addSetup(async (channel) => {
     channel.consume(queue, async (message) => {
       if (!message) {
@@ -702,11 +1560,19 @@ function createConnection({
       let publishIndex = 0;
       let acked = false;
       let terminated = false;
-      const donePromises = [];
       const registeredCallbackIds = new Set;
       let resolveActiveMessage = () => {};
-      const { messageId, taskId, mode } = headerSchema.parse(message);
+      let messageIdForCleanup;
+      const epoch = crypto.randomUUID();
       try {
+        const { messageId, taskId, mode } = headerSchema.parse(message);
+        messageIdForCleanup = messageId;
+        const unsupported = unsupportedCapabilities(readRequiredCapabilities(message.properties.headers));
+        if (unsupported.length > 0) {
+          throw new UnsupportedCapabilityError(unsupported);
+        }
+        const dispatchCodec = wireCodecFromContentType(message.properties.contentType);
+        messageCodecs.set(messageId, dispatchCodec);
         let deferred = false;
         let deferredReason = null;
         const messageExecution = Promise.withResolvers();
@@ -718,40 +1584,91 @@ function createConnection({
           messageExecution.resolve();
         };
         const payload = payloadSchema.parse(message);
-        const [extendedContext, terminatePromise] = createContextHelper({
+        const abortController = new AbortController;
+        const registerCallback = (callback) => {
+          const callbackId = crypto.randomUUID();
+          registeredCallbackIds.add(callbackId);
+          callbacks.set(callbackId, {
+            callback,
+            onCallbackInvoke: dispatchInvocation
+          });
+          return { sourceId: connectionId, callbackId };
+        };
+        const outbound = createOutboundBoundary({
+          uploadUrl: payload.options.uploadUrl,
+          streamUrl: payload.options.streamUrl,
+          maxPayloadSize: payload.options.maxPayloadSize,
+          maxFileSize: payload.options.maxFileSize,
+          wireCodec: dispatchCodec,
+          signal: abortController.signal,
+          warn: (msg, error) => console.warn(`${msg} (task ${taskId})`, error instanceof Error ? error.message : error ?? "")
+        });
+        const dispatchInvocation = (params) => {
+          outbound.track(outbound.send(params.arg, {
+            outputName: params.outputName,
+            onCallback: registerCallback
+          }).then((data) => publish({
+            index: 0,
+            version,
+            taskId,
+            messageId,
+            data,
+            outputName: params.outputName,
+            connectionId: params.sourceId,
+            callbackId: params.callbackId,
+            propertyPath: params.propertyPath,
+            epoch
+          })));
+        };
+        const [extendedContext, terminatePromise] = await createContextHelper({
           taskId,
-          input: mapInput(payload.input),
-          configuration: mapInput(payload.configuration),
-          onLog(debugMethod, data) {
-            publish({
-              index: publishIndex++,
-              version,
-              messageId,
+          input: payload.input,
+          configuration: payload.configuration,
+          abortController,
+          passthroughByteReferences,
+          sends: {
+            ...buildSendApi({
+              outbound,
+              registerCallback,
               taskId,
-              data,
-              debugMethod,
-              priority: message.properties.priority,
-              debug: true
+              messageId,
+              nextIndex: () => publishIndex++,
+              epoch,
+              priority: message.properties.priority
+            }),
+            invokeCallback: (ref, arg) => dispatchInvocation({
+              sourceId: ref.sourceId,
+              callbackId: ref.callbackId,
+              outputName: ref.outputName,
+              propertyPath: ref.propertyPath,
+              arg
+            }),
+            options: payload.options
+          },
+          onLog(debugMethod, data) {
+            outbound.send(data, { bestEffort: true }).then((mapped) => {
+              if (mapped === undefined) {
+                return;
+              }
+              publish({
+                index: publishIndex++,
+                version,
+                messageId,
+                taskId,
+                data: mapped,
+                debugMethod,
+                priority: message.properties.priority,
+                debug: true,
+                epoch
+              });
             });
           },
           onDefer(reason) {
             deferred = true;
             deferredReason = reason || null;
-            return obfuscate(taskId, messageId, payload.options.uploadUrl ?? "", payload.options.streamUrl ?? "");
+            return obfuscate(taskId, messageId, payload.options.uploadUrl ?? "", payload.options.streamUrl ?? "", payload.options.maxPayloadSize?.toString() ?? "", payload.options.maxFileSize?.toString() ?? "");
           },
-          onCallback(params) {
-            publish({
-              index: 0,
-              version,
-              taskId,
-              messageId,
-              data: params.arg,
-              outputName: params.outputName,
-              connectionId: params.sourceId,
-              callbackId: params.callbackId,
-              propertyPath: params.propertyPath
-            });
-          }
+          onCallback: dispatchInvocation
         });
         await publish({
           index: publishIndex++,
@@ -759,11 +1676,18 @@ function createConnection({
           messageId,
           taskId,
           priority: message.properties.priority,
-          begin: true
+          begin: true,
+          epoch,
+          ...buildServiceIdentityHeaders({
+            libVersion: "javascript@0.8.2-edge.1149",
+            name
+          })
         });
-        if (isMessageHandlerGenerator(messageHandler) && mode === "CONTINUOUS") {
-          channel.ack(message);
-          acked = true;
+        if (isMessageHandlerGenerator(messageHandler)) {
+          if (mode === "CONTINUOUS") {
+            safeAck(channel, message);
+            acked = true;
+          }
           const generator = messageHandler(extendedContext);
           const terminationPromise = Promise.withResolvers();
           generatorTerminators.set(messageId, (reason) => {
@@ -797,31 +1721,21 @@ function createConnection({
                 deferred = false;
                 console.warn("returning a value in a deferred message resets the deferred status");
               }
-              const donePromise = Promise.withResolvers();
-              donePromises.push(donePromise.promise);
-              const { value, outputName } = await unwrapResult({
-                result,
-                options: payload.options,
-                onDone: donePromise.resolve,
-                onCallback: (callback) => {
-                  const callbackId = crypto.randomUUID();
-                  registeredCallbackIds.add(callbackId);
-                  callbacks.set(callbackId, callback);
-                  return {
-                    sourceId: connectionId,
-                    callbackId
-                  };
-                }
+              const { value: rawValue, outputName } = unwrapOutputValue(result);
+              const value = await outbound.send(rawValue, {
+                outputName,
+                onCallback: registerCallback
               });
               if (!done || typeof value !== "undefined") {
-                publish({
+                await publish({
                   index: publishIndex++,
                   version,
                   messageId,
                   taskId,
                   data: value,
                   priority: message.properties.priority,
-                  outputName
+                  outputName,
+                  epoch
                 });
               }
               if (done) {
@@ -831,12 +1745,9 @@ function createConnection({
           });
         } else {
           const result = await handlerStorage.run(extendedContext, () => messageHandler(extendedContext));
-          const donePromise = Promise.withResolvers();
-          donePromises.push(donePromise.promise);
-          const { value, outputName } = await unwrapResult({
-            result,
-            options: payload.options,
-            onDone: donePromise.resolve,
+          const { value: rawValue, outputName } = unwrapOutputValue(result);
+          const value = await outbound.send(rawValue, {
+            outputName,
             onCallback: () => {
               throw new Error("callbacks can only be used in generator functions");
             }
@@ -846,59 +1757,92 @@ function createConnection({
             deferred = false;
           }
           if (!deferred || value) {
-            publish({
+            await publish({
               index: publishIndex++,
               version,
               messageId,
               taskId,
               data: value,
               priority: message.properties.priority,
-              outputName
+              outputName,
+              epoch
             });
           }
         }
-        await new Promise((resolve2) => {
+        await new Promise((resolve2, reject) => {
           setImmediate(async () => {
-            if (!deferred) {
-              await Promise.allSettled(donePromises);
-            }
-            await publish({
-              index: publishIndex++,
-              version,
-              messageId,
-              taskId,
-              data: deferredReason,
-              priority: message.properties.priority,
-              deferred,
-              done: !deferred
-            });
-            if (!acked) {
-              channel.ack(message);
+            try {
+              if (!deferred) {
+                await outbound.settle();
+              }
+              await publish({
+                index: publishIndex++,
+                version,
+                messageId,
+                taskId,
+                data: deferredReason,
+                priority: message.properties.priority,
+                deferred,
+                done: !deferred,
+                epoch
+              });
+              if (!acked) {
+                safeAck(channel, message);
+              }
+              resolve2();
+            } catch (error) {
+              reject(error);
             }
-            resolve2();
           });
         });
       } catch (error) {
         if (error instanceof SkipError) {
           if (!acked) {
-            channel.nack(message);
+            safeNack(channel, message);
           }
           return;
         }
         if (error instanceof RetryError) {
           if (!acked) {
-            channel.ack(message);
+            safeAck(channel, message);
           }
           const properties = {
             ...message.properties,
             expiration: error.delay || 1000
           };
-          channel.publish(`${exchange}-retry`, version, message.content, properties);
+          channelWrapper.publish(`${exchange}-retry`, version, message.content, properties).catch((publishError) => {
+            if (!silent) {
+              console.error("Failed to republish message for retry:", publishError);
+            }
+          });
+          return;
+        }
+        if (error instanceof UnsupportedCapabilityError) {
+          if (!silent) {
+            console.error(error.message);
+          }
+          if (!acked) {
+            safeAck(channel, message);
+          }
+          channelWrapper.publish(`${exchange}-retry`, "operator", message.content, {
+            ...message.properties,
+            headers: {
+              ...message.properties.headers,
+              version,
+              [CAPABILITY_HEADER_KEYS.mismatch]: true,
+              index: publishIndex++,
+              "error-message": error.message
+            }
+          }).catch((publishError) => {
+            if (!silent) {
+              console.error("Failed to publish capability mismatch message:", publishError);
+            }
+          });
           return;
         }
         if (error instanceof AbortError && error.message.length > 0) {
           if (!acked) {
-            channelWrapper.ack(message);
+            safeAck(channel, message);
           }
           channelWrapper.publish(`${exchange}-retry`, "operator", error.message, {
             ...message.properties,
@@ -906,15 +1850,18 @@ function createConnection({
             headers: {
               ...message.properties.headers,
               index: publishIndex++,
-              libVersion: "javascript@0.7.1",
               abort: true
             }
+          }).catch((publishError) => {
+            if (!silent) {
+              console.error("Failed to publish abort message:", publishError);
+            }
           });
           return;
         }
         if (terminated && error instanceof Error && error.name === "AbortError" && !(error instanceof AbortError)) {
           if (!acked) {
-            channel.ack(message);
+            safeAck(channel, message);
           }
           return;
         }
@@ -924,23 +1871,29 @@ function createConnection({
             console.error(error);
           }
           if (!acked) {
-            channel.ack(message);
+            safeAck(channel, message);
           }
-          channel.publish(`${exchange}-retry`, "operator", message.content, {
+          channelWrapper.publish(`${exchange}-retry`, "operator", message.content, {
             ...message.properties,
             headers: {
               ...message.properties.headers,
               version,
               exception: true,
               index: publishIndex++,
-              libVersion: "javascript@0.7.1",
               "error-message": error.message || "error in service handler"
             }
+          }).catch((publishError) => {
+            if (!silent) {
+              console.error("Failed to publish exception message:", publishError);
+            }
           });
           return;
         }
       } finally {
-        generatorTerminators.delete(messageId);
+        if (messageIdForCleanup) {
+          generatorTerminators.delete(messageIdForCleanup);
+          messageCodecs.delete(messageIdForCleanup);
+        }
         registeredCallbackIds.forEach((id) => callbacks.delete(id));
         resolveActiveMessage();
       }
@@ -966,61 +1919,41 @@ function createConnection({
         }
       };
       const registeredCallbackIds = new Set;
-      const donePromises = [];
+      const outbound = createOutboundBoundary(options);
+      const registerCallback = (callback) => {
+        const callbackId = crypto.randomUUID();
+        registeredCallbackIds.add(callbackId);
+        callbacks.set(callbackId, {
+          callback,
+          onCallbackInvoke: dispatchInvocation
+        });
+        return { sourceId: connectionId, callbackId };
+      };
+      const dispatchInvocation = (params) => {
+        outbound.track(outbound.send(params.arg, {
+          outputName: params.outputName,
+          onCallback: registerCallback
+        }).then((data) => publish({
+          index: 0,
+          version,
+          taskId,
+          messageId,
+          data,
+          outputName: params.outputName,
+          connectionId: params.sourceId,
+          callbackId: params.callbackId,
+          propertyPath: params.propertyPath
+        })));
+      };
       const sendApi = {
-        async sendToOutput(outputName, data) {
-          await activeMessage();
-          const donePromise = Promise.withResolvers();
-          donePromises.push(donePromise.promise);
-          donePromises.push(publish({
-            index: publishIndex++,
-            version,
-            messageId,
-            taskId,
-            data: await processData({
-              outputName,
-              data,
-              options,
-              onDone: donePromise.resolve,
-              onCallback: (callback) => {
-                const callbackId = crypto.randomUUID();
-                registeredCallbackIds.add(callbackId);
-                callbacks.set(callbackId, callback);
-                return {
-                  sourceId: connectionId,
-                  callbackId
-                };
-              }
-            }),
-            outputName
-          }));
-        },
-        async send(data) {
-          await activeMessage();
-          const donePromise = Promise.withResolvers();
-          donePromises.push(donePromise.promise);
-          donePromises.push(publish({
-            index: publishIndex++,
-            version,
-            messageId,
-            taskId,
-            data: await processData({
-              outputName: null,
-              data,
-              options,
-              onDone: donePromise.resolve,
-              onCallback: (callback) => {
-                const callbackId = crypto.randomUUID();
-                registeredCallbackIds.add(callbackId);
-                callbacks.set(callbackId, callback);
-                return {
-                  sourceId: connectionId,
-                  callbackId
-                };
-              }
-            })
-          }));
-        },
+        ...buildSendApi({
+          outbound,
+          registerCallback,
+          taskId,
+          messageId,
+          nextIndex: () => publishIndex++,
+          gate: activeMessage
+        }),
         async abort(error) {
           await activeMessage();
           channelWrapper.publish(`${exchange}-retry`, "operator", error instanceof Error ? error.message : error, {
@@ -1031,7 +1964,6 @@ function createConnection({
             contentType: "text/plain",
             headers: {
               taskId,
-              libVersion: "javascript@0.7.1",
               index: publishIndex++,
               abort: true
             }
@@ -1051,12 +1983,14 @@ function createConnection({
       }
       await new Promise((resolve2) => setImmediate(resolve2));
       await activeMessage();
-      while (true) {
-        const promiseCount = donePromises.length;
-        await Promise.allSettled(donePromises);
-        if (promiseCount === donePromises.length) {
-          break;
-        }
+      try {
+        await outbound.settle();
+      } catch (error) {
+        registeredCallbackIds.forEach((id) => callbacks.delete(id));
+        const first = error instanceof AggregateError && error.errors[0] instanceof Error ? error.errors[0] : error instanceof Error ? error : new Error(String(error));
+        await sendApi.abort(first);
+        activeMessageKeys.delete(messageKey);
+        throw error;
       }
       registeredCallbackIds.forEach((id) => callbacks.delete(id));
       await publish({
@@ -1157,6 +2091,24 @@ function asyncEventEmitter(initial = []) {
 }
 
 // src/index.ts
+function resolveConnectionOptions(connectionOptions) {
+  const rejectEnv = process.env.REJECT_UNAUTHORIZED;
+  const caEnv = process.env.CA;
+  const caFileEnv = process.env.CA_FILE;
+  const tlsDefaults = {};
+  if (rejectEnv !== undefined) {
+    tlsDefaults.rejectUnauthorized = !/^(false|0|no)$/i.test(rejectEnv.trim());
+  }
+  if (caEnv) {
+    tlsDefaults.ca = caEnv;
+  } else if (caFileEnv) {
+    tlsDefaults.ca = fs.readFileSync(caFileEnv);
+  }
+  if (Object.keys(tlsDefaults).length === 0) {
+    return connectionOptions;
+  }
+  return { ...tlsDefaults, ...connectionOptions };
+}
 var pkgJson;
 function loadPkgJson() {
   if (!pkgJson) {
@@ -1209,21 +2161,33 @@ function createService(optionsOrVersion, optionalMessageHandler) {
     }
     devOverlay = devParts[1];
   }
-  return createConnection(connectionOptionsSchema.parse({
-    ...options,
-    url,
-    devOverlay
-  }), messageHandler);
+  const envMaxMessageSize = process.env.REQUENCE_MAX_MESSAGE_SIZE ? Number(process.env.REQUENCE_MAX_MESSAGE_SIZE) : undefined;
+  return createConnection({
+    ...connectionOptionsSchema.parse({
+      ...options,
+      connectionOptions: resolveConnectionOptions(options.connectionOptions),
+      maxMessageSize: options.maxMessageSize ?? envMaxMessageSize,
+      url,
+      devOverlay
+    }),
+    onConnectionStateChange: options.onConnectionStateChange
+  }, messageHandler);
 }
 export {
   wrapIterable,
+  reachableFetch,
+  isUnreachableStatus,
   createService,
   createCallback,
   asyncEventEmitter,
+  assertReachable,
+  UnsupportedCapabilityError,
+  RequenceUnreachableError,
   RequenceStream,
   RequenceFile,
-  RequenceConnectionError
+  RequenceConnectionError,
+  PayloadTooLargeError
 };
 
-//# debugId=DF5C6A6E1370BBD564756E2164756E21
+//# debugId=339E2FADB6C273CF64756E2164756E21
 //# sourceMappingURL=index.js.map