@web-ts-toolkit/express-request-attestation 0.50.0 → 0.52.0

package/signer.js

@@ -270,6 +270,13 @@ var NONCE_HEX_PATTERN = /^[0-9a-f]{32}$/;
 var BODY_HASH_HEX_PATTERN = /^[0-9a-f]{64}$/;
 var HTTP_TOKEN_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 var HEX_BYTE_PATTERN = /^[0-9a-fA-F]{2}$/;
+function assertEncodedTransactionIdBound(value) {
+  if (value.length > MAX_ENCODED_TRANSACTION_ID_BYTES) {
+    throw new AttestationProtocolError(
+      `encoded transactionId must be at most ${MAX_ENCODED_TRANSACTION_ID_BYTES} bytes`
+    );
+  }
+}
 var RESERVED_HEADER_NAMES = /* @__PURE__ */ new Set([
   "authorization",
   "proxy-authenticate",
@@ -465,6 +472,7 @@ function extractSingleHeaderValue(raw) {
   if (typeof value !== "string" || value.length === 0) {
     return null;
   }
+  assertEncodedTransactionIdBound(value);
   if (value.includes(",")) {
     throw new AttestationProtocolError("comma-joined signature headers are not allowed");
   }
@@ -524,23 +532,18 @@ function encodeTransactionId(fields) {
   const encoded = base64urlEncode(
     canonicalJsonBytes([PROTOCOL_VERSION, fields.keyId, fields.timestampMs, fields.nonceHex, fields.mac])
   );
-  if (utf8ByteLength(encoded) > MAX_ENCODED_TRANSACTION_ID_BYTES) {
-    throw new AttestationProtocolError(
-      `encoded transactionId must be at most ${MAX_ENCODED_TRANSACTION_ID_BYTES} bytes`
-    );
-  }
+  assertEncodedTransactionIdBound(encoded);
   return encoded;
 }
 function decodeTransactionId(headerValue) {
   if (typeof headerValue !== "string" || headerValue.length === 0) {
     throw new AttestationProtocolError("transactionId must be a non-empty string");
   }
-  if (utf8ByteLength(headerValue) > MAX_ENCODED_TRANSACTION_ID_BYTES) {
-    throw new AttestationProtocolError(
-      `encoded transactionId must be at most ${MAX_ENCODED_TRANSACTION_ID_BYTES} bytes`
-    );
-  }
+  assertEncodedTransactionIdBound(headerValue);
   const bytes = base64urlDecode(headerValue);
+  if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+    throw new AttestationProtocolError("transactionId must not contain a UTF-8 BOM");
+  }
   const text = utf8Decode(bytes);
   const envelope = parseCanonicalJsonArray(text, 5);
   const [version, keyId, timestampMs, nonceHex, mac] = envelope;
@@ -809,12 +812,13 @@ function createRequestSigner(options) {
     })();
     cachedKey = pending;
     try {
-      await pending;
-    } catch {
-      cachedKey = null;
-      throw pending;
+      return await pending;
+    } catch (error) {
+      if (cachedKey === pending) {
+        cachedKey = null;
+      }
+      throw error;
     }
-    return pending;
   }
   async function sign(input) {
     if (input === null || typeof input !== "object" || Array.isArray(input)) {
@@ -869,9 +873,137 @@ function createRequestSigner(options) {
   return Object.freeze(signer);
 }
 
+// src/bounded-byte-stream.ts
+var INITIAL_CAPACITY = 1024;
+var READS_PER_TURN = 128;
+function now() {
+  return typeof globalThis.performance?.now === "function" ? globalThis.performance.now() : Date.now();
+}
+async function readBoundedByteStream(stream, options) {
+  const { maxBytes, timeoutMs, signal, error: readError } = options;
+  const started = timeoutMs === void 0 ? 0 : now();
+  let reader;
+  try {
+    reader = stream.getReader();
+  } catch (cause) {
+    throw readError("locked", cause);
+  }
+  let storage;
+  let total = 0;
+  let stopped = false;
+  let stopReason;
+  let deadlineTimer;
+  let yieldTimer;
+  let finishYield;
+  let rejectStop;
+  const stop = new Promise((_resolve, reject) => {
+    rejectStop = reject;
+  });
+  function stopWith(reason) {
+    if (stopped) return;
+    stopped = true;
+    stopReason = reason;
+    rejectStop(reason);
+  }
+  function onAbort() {
+    stopWith(readError("abort"));
+  }
+  function checkBounds() {
+    if (stopped) throw stopReason;
+    if (signal?.aborted) throw readError("abort");
+    if (timeoutMs !== void 0 && now() - started >= timeoutMs) throw readError("timeout");
+  }
+  async function readLoop() {
+    let readsThisTurn = 0;
+    for (; ; ) {
+      checkBounds();
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (cause) {
+        checkBounds();
+        throw readError("read", cause);
+      }
+      checkBounds();
+      if (chunk.done) {
+        const result = storage === void 0 ? new Uint8Array(0) : storage.length === total ? storage : storage.slice(0, total);
+        checkBounds();
+        return result;
+      }
+      const value = chunk.value;
+      if (!(value instanceof Uint8Array)) throw readError("chunk");
+      if (value.byteLength > maxBytes - total) throw readError("limit");
+      if (value.byteLength > 0) {
+        const required = total + value.byteLength;
+        if (storage === void 0 || required > storage.length) {
+          const capacity = Math.min(
+            maxBytes,
+            Math.max(required, storage === void 0 ? INITIAL_CAPACITY : storage.length * 2)
+          );
+          const grown = new Uint8Array(capacity);
+          if (storage !== void 0) grown.set(storage);
+          storage = grown;
+        }
+        storage.set(value, total);
+        total = required;
+      }
+      if (++readsThisTurn === READS_PER_TURN) {
+        readsThisTurn = 0;
+        await new Promise((resolve) => {
+          finishYield = resolve;
+          yieldTimer = setTimeout(() => {
+            yieldTimer = void 0;
+            finishYield = void 0;
+            resolve();
+          }, 0);
+        });
+      }
+    }
+  }
+  try {
+    if (signal !== null && signal !== void 0) {
+      try {
+        signal.addEventListener("abort", onAbort, { once: true });
+      } catch {
+      }
+    }
+    if (timeoutMs !== void 0) {
+      deadlineTimer = setTimeout(() => stopWith(readError("timeout")), timeoutMs);
+      const handle = deadlineTimer;
+      handle.unref?.();
+    }
+    return await Promise.race([readLoop(), stop]);
+  } catch (reason) {
+    stopped = true;
+    stopReason = reason;
+    try {
+      void reader.cancel(reason).catch(() => void 0);
+    } catch {
+    }
+    throw reason;
+  } finally {
+    stopped = true;
+    storage = void 0;
+    if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+    if (yieldTimer !== void 0) clearTimeout(yieldTimer);
+    finishYield?.();
+    if (signal !== null && signal !== void 0) {
+      try {
+        signal.removeEventListener("abort", onAbort);
+      } catch {
+      }
+    }
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+
 // src/signer-client.ts
 var SIGNER_METADATA_BYTE_CAP = 4096;
 var DEFAULT_SIGNER_LOAD_TIMEOUT_MS = 5e3;
+var SIGNER_METADATA_READ_TIMEOUT_MS = 5e3;
 var MIN_SIGNER_LOAD_TIMEOUT_MS = 1;
 var MAX_SIGNER_LOAD_TIMEOUT_MS = 6e4;
 var FETCH_BUNDLE_OPTION_KEYS = /* @__PURE__ */ new Set([
@@ -902,7 +1034,7 @@ function resolveFetch(candidate) {
         "fetch is unavailable. Signer discovery requires a fetch implementation."
       );
     }
-    return globalFetch;
+    return globalFetch.bind(globalThis);
   }
   if (typeof candidate !== "function") {
     throw new AttestationProtocolError("signer client fetch must be a function");
@@ -1033,56 +1165,46 @@ function resolveSignerModuleUrl(signerUrl, metadataUrl, apiOrigin) {
   }
   return resolved.href;
 }
-async function readBoundedMetadataDocument(response, fetchImplName) {
-  void fetchImplName;
-  let bytes = null;
-  let text = null;
-  if (typeof response.arrayBuffer === "function") {
-    let buffer;
-    try {
-      buffer = await response.arrayBuffer();
-    } catch (error) {
-      if (error instanceof SignerClientError) {
-        throw error;
-      }
-      const name = error.name;
-      if (name === "AbortError" || response.signal !== void 0) {
-        throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer discovery was aborted.");
-      }
-      throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata fetch failed.");
-    }
-    const view = new Uint8Array(buffer);
-    if (view.byteLength > SIGNER_METADATA_BYTE_CAP) {
-      throw new SignerClientError(
-        "SIGNER_LOAD_FAILED",
-        `Signer metadata exceeds the ${SIGNER_METADATA_BYTE_CAP}-byte cap.`
-      );
-    }
-    bytes = view;
-  } else if (typeof response.text === "function") {
-    try {
-      text = await response.text();
-    } catch {
-      throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata fetch failed.");
-    }
-    if (utf8ByteLength(text) > SIGNER_METADATA_BYTE_CAP) {
-      throw new SignerClientError(
-        "SIGNER_LOAD_FAILED",
-        `Signer metadata exceeds the ${SIGNER_METADATA_BYTE_CAP}-byte cap.`
-      );
-    }
-  } else {
+async function readBoundedMetadataDocument(response, signal, timeoutMs) {
+  const body = response.body;
+  if (body === void 0 || body !== null && typeof body.getReader !== "function") {
     throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata response is unreadable.");
   }
-  let raw;
-  if (text !== null) {
-    raw = text;
-  } else {
-    try {
-      raw = utf8Decode(bytes);
-    } catch {
-      throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata is not valid UTF-8.");
+  const bytes = body === null ? new Uint8Array(0) : await readBoundedByteStream(body, {
+    maxBytes: SIGNER_METADATA_BYTE_CAP,
+    signal,
+    timeoutMs,
+    error(failure, cause) {
+      switch (failure) {
+        case "abort":
+          return new SignerClientError("SIGNER_LOAD_FAILED", "Signer discovery was aborted.");
+        case "limit":
+          return new SignerClientError(
+            "SIGNER_LOAD_FAILED",
+            `Signer metadata exceeds the ${SIGNER_METADATA_BYTE_CAP}-byte cap.`
+          );
+        case "timeout":
+          return new SignerClientError(
+            "SIGNER_LOAD_FAILED",
+            `Signer metadata body read timed out after ${timeoutMs} ms.`
+          );
+        case "locked":
+        case "chunk":
+          return new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata response is unreadable.");
+        case "read":
+          if (cause instanceof SignerClientError) return cause;
+          if (cause?.name === "AbortError") {
+            return new SignerClientError("SIGNER_LOAD_FAILED", "Signer discovery was aborted.");
+          }
+          return new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata fetch failed.");
+      }
     }
+  });
+  let raw;
+  try {
+    raw = utf8Decode(bytes);
+  } catch {
+    throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata is not valid UTF-8.");
   }
   try {
     return JSON.parse(raw);
@@ -1131,7 +1253,7 @@ function validateMetadataDocument(document, expected) {
   return {
     version: 1,
     keyId: record["keyId"],
-    signerUrl: record["signerUrl"],
+    signerUrl: resolveSignerModuleUrl(record["signerUrl"], expected.metadataUrl, expected.apiOrigin),
     publicOrigin: record["publicOrigin"],
     replayNamespace: record["replayNamespace"]
   };
@@ -1193,13 +1315,14 @@ function validateSignerModule(candidate, metadata) {
   }
   return { signer };
 }
-async function fetchMetadataDocument(config) {
+async function fetchMetadataDocument(config, readTimeoutMs) {
   if (config.signal?.aborted) {
     throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer discovery was aborted.");
   }
   let response;
   try {
-    response = await config.fetchImpl(config.metadataUrl, {
+    const fetchImpl = config.fetchImpl;
+    response = await fetchImpl(config.metadataUrl, {
       cache: "no-store",
       credentials: "omit",
       redirect: "error",
@@ -1216,19 +1339,23 @@ async function fetchMetadataDocument(config) {
     throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata fetch failed.");
   }
   if (response.ok !== true) {
+    try {
+      void response.body?.cancel().catch(() => void 0);
+    } catch {
+    }
     throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer metadata fetch failed.");
   }
-  const document = await readBoundedMetadataDocument(response, "fetch");
+  const document = await readBoundedMetadataDocument(response, config.signal, readTimeoutMs);
   return validateMetadataDocument(document, {
     apiOrigin: config.apiOrigin,
-    replayNamespace: config.replayNamespace
+    replayNamespace: config.replayNamespace,
+    metadataUrl: config.metadataUrl
   });
 }
 async function importValidatedModule(config, metadata) {
-  const moduleUrl = resolveSignerModuleUrl(metadata.signerUrl, config.metadataUrl, config.apiOrigin);
   let candidate;
   try {
-    candidate = await config.loadModule(moduleUrl);
+    candidate = await config.loadModule(metadata.signerUrl);
   } catch (error) {
     if (error instanceof SignerClientError) {
       throw error;
@@ -1243,7 +1370,7 @@ async function importValidatedModule(config, metadata) {
 }
 async function fetchSignerBundle(options) {
   const config = validateBundleConfig(options);
-  const metadata = await fetchMetadataDocument(config);
+  const metadata = await fetchMetadataDocument(config, SIGNER_METADATA_READ_TIMEOUT_MS);
   return importValidatedModule(config, metadata);
 }
 function isRetirementRetryCandidate(error) {
@@ -1274,6 +1401,7 @@ function createSignerClient(options) {
   let generation = 0;
   let disposed = false;
   let currentAborter = null;
+  let awaitingReplacement = false;
   function throwIfDisposed() {
     if (disposed) {
       throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer client is disposed.");
@@ -1300,7 +1428,7 @@ function createSignerClient(options) {
         throw importError;
       }
       const second = await fetchMetadataDocument(base);
-      if (second.keyId === first.keyId) {
+      if (second.keyId === first.keyId && second.signerUrl === first.signerUrl) {
         throw importError;
       }
       if (signal.aborted) {
@@ -1335,32 +1463,34 @@ function createSignerClient(options) {
       () => void 0,
       () => void 0
     );
+    function releaseLoad() {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+      if (pending === tracked) {
+        pending = null;
+      }
+      if (currentAborter === aborter) {
+        currentAborter = null;
+      }
+    }
     const tracked = raced.then(
       (signer) => {
-        if (timer !== void 0) {
-          clearTimeout(timer);
-        }
-        if (disposed || myGeneration !== generation) {
+        const ownsGeneration = pending === tracked && myGeneration === generation;
+        releaseLoad();
+        if (disposed || !ownsGeneration) {
           throw new SignerClientError("SIGNER_LOAD_FAILED", "Signer load was superseded.");
         }
         active = signer;
-        if (pending === tracked) {
-          pending = null;
-        }
-        currentAborter = null;
+        awaitingReplacement = false;
         return signer;
       },
       (error) => {
-        if (timer !== void 0) {
-          clearTimeout(timer);
-        }
-        if (pending === tracked) {
-          pending = null;
-        }
-        if (error instanceof SignerClientError && error.code === "SIGNER_LOAD_TIMEOUT") {
+        const ownsGeneration = pending === tracked && myGeneration === generation;
+        releaseLoad();
+        if (ownsGeneration && error instanceof SignerClientError && error.code === "SIGNER_LOAD_TIMEOUT") {
           generation += 1;
         }
-        currentAborter = null;
         throw error;
       }
     );
@@ -1385,7 +1515,9 @@ function createSignerClient(options) {
       if (disposed) {
         return;
       }
-      if (typeof observedKeyId !== "string" || observedKeyId.length === 0) {
+      try {
+        validateKeyId(observedKeyId);
+      } catch {
         return;
       }
       if (active !== null) {
@@ -1398,11 +1530,11 @@ function createSignerClient(options) {
         if (!matches) {
           return;
         }
-        active = null;
-        generation += 1;
-        pending = null;
+      } else if (awaitingReplacement) {
         return;
       }
+      active = null;
+      awaitingReplacement = true;
       generation += 1;
       pending = null;
     },
@@ -1412,6 +1544,7 @@ function createSignerClient(options) {
       }
       disposed = true;
       active = null;
+      awaitingReplacement = false;
       generation += 1;
       try {
         currentAborter?.abort();
@@ -1536,165 +1669,66 @@ async function materializeRequestBodyBytes(request, options = {}) {
   if (body === null || body === void 0) {
     return new Uint8Array(0);
   }
-  let reader;
-  try {
-    reader = body.getReader();
-  } catch {
-    throw new SignerClientError(
-      "SIGNER_PREPARATION_FAILED",
-      "Request body is locked. Clone the Request before sending or pass a fresh body."
-    );
-  }
-  const chunks = [];
-  let total = 0;
-  let timer;
-  let onAbort;
-  let settled = false;
-  function cleanup() {
-    settled = true;
-    if (timer !== void 0) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-    if (onAbort !== void 0 && signal !== null && signal !== void 0) {
-      try {
-        signal.removeEventListener("abort", onAbort);
-      } catch {
-      }
-      onAbort = void 0;
-    }
-  }
-  const deadline = new Promise((_resolve, reject) => {
-    timer = setTimeout(() => {
-      if (settled) {
-        return;
-      }
-      try {
-        void reader.cancel();
-      } catch {
+  return readBoundedByteStream(body, {
+    maxBytes: maxBodyBytes,
+    timeoutMs,
+    signal,
+    error(failure, cause) {
+      switch (failure) {
+        case "abort":
+          return toAbortError(signal);
+        case "locked":
+          return new SignerClientError(
+            "SIGNER_PREPARATION_FAILED",
+            "Request body is locked. Clone the Request before sending or pass a fresh body."
+          );
+        case "chunk":
+          return new SignerClientError("SIGNER_PREPARATION_FAILED", "Request body chunk is not bytes.");
+        case "limit":
+          return new SignerClientError(
+            "SIGNER_PREPARATION_FAILED",
+            `Request body exceeds the configured ${maxBodyBytes}-byte limit.`
+          );
+        case "timeout":
+          return new SignerClientError(
+            "SIGNER_PREPARATION_FAILED",
+            `Request body read timed out after ${timeoutMs} ms.`
+          );
+        case "read":
+          return cause instanceof SignerClientError ? cause : new SignerClientError("SIGNER_PREPARATION_FAILED", "Request body read failed.");
       }
-      reject(new SignerClientError("SIGNER_PREPARATION_FAILED", `Request body read timed out after ${timeoutMs} ms.`));
-    }, timeoutMs);
-    const handle = timer;
-    if (typeof handle.unref === "function") {
-      handle.unref();
     }
   });
-  deadline.then(
-    () => void 0,
-    () => void 0
-  );
-  if (signal !== null && signal !== void 0) {
-    const abortPromise = new Promise((_resolve, reject) => {
-      onAbort = () => {
-        try {
-          void reader.cancel();
-        } catch {
-        }
-        reject(toAbortError(signal));
-      };
-      try {
-        signal.addEventListener("abort", onAbort, { once: true });
-      } catch {
-      }
-    });
-    abortPromise.then(
-      () => void 0,
-      () => void 0
-    );
-    try {
-      const result = await Promise.race([readLoop(), deadline, abortPromise]);
-      cleanup();
-      try {
-        reader.releaseLock();
-      } catch {
-      }
-      return result;
-    } catch (error) {
-      cleanup();
-      try {
-        reader.releaseLock();
-      } catch {
-      }
-      throw error;
-    }
-  }
-  async function readLoop() {
-    for (; ; ) {
-      if (signal?.aborted === true) {
-        try {
-          await reader.cancel();
-        } catch {
-        }
-        throw toAbortError(signal);
-      }
-      let chunk;
-      try {
-        chunk = await reader.read();
-      } catch (error) {
-        try {
-          await reader.cancel();
-        } catch {
-        }
-        if (error instanceof SignerClientError) {
-          throw error;
-        }
-        throw new SignerClientError("SIGNER_PREPARATION_FAILED", "Request body read failed.");
-      }
-      if (chunk.done === true) {
-        break;
-      }
-      const value = chunk.value;
-      if (!(value instanceof Uint8Array)) {
-        try {
-          await reader.cancel();
-        } catch {
-        }
-        throw new SignerClientError("SIGNER_PREPARATION_FAILED", "Request body chunk is not bytes.");
-      }
-      total += value.byteLength;
-      if (total > maxBodyBytes) {
-        try {
-          await reader.cancel();
-        } catch {
-        }
-        throw new SignerClientError(
-          "SIGNER_PREPARATION_FAILED",
-          `Request body exceeds the configured ${maxBodyBytes}-byte limit.`
-        );
-      }
-      chunks.push(value.slice());
-    }
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const part of chunks) {
-      out.set(part, offset);
-      offset += part.byteLength;
-    }
-    return out;
-  }
-  try {
-    const result = await Promise.race([readLoop(), deadline]);
-    cleanup();
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-    return result;
-  } catch (error) {
-    cleanup();
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-    throw error;
-  }
 }
 
 // src/attested-fetch.ts
 var DEFAULT_ATTESTED_FETCH_BODY_READ_TIMEOUT_MS2 = 5e3;
 var MIN_FETCH_TIMEOUT_MS = 1;
 var MAX_FETCH_TIMEOUT_MS = 6e4;
+var FORBIDDEN_FETCH_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "cookie2",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "set-cookie",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "user-agent",
+  "via"
+]);
 var FETCH_WITH_ATTESTATION_OPTION_KEYS = /* @__PURE__ */ new Set([
   "signerClient",
   "apiOrigin",
@@ -1719,7 +1753,7 @@ function resolveFetchImpl(fetchAlias, fetchFnAlias) {
         "fetch is unavailable. Prepared fetch requires a fetch implementation."
       );
     }
-    return globalFetch;
+    return globalFetch.bind(globalThis);
   }
   if (typeof candidate !== "function") {
     throw new AttestationProtocolError("fetchWithAttestation fetch must be a function");
@@ -1752,6 +1786,23 @@ function validateBodyReadTimeoutMs2(value) {
   }
   return value;
 }
+function assertFetchProofHeaderName(headerName) {
+  const lower = headerName.toLowerCase();
+  if (lower.startsWith("sec-") || lower.startsWith("proxy-") || FORBIDDEN_FETCH_HEADER_NAMES.has(lower)) {
+    throw new SignerClientError(
+      "SIGNER_PREPARATION_FAILED",
+      "Attestation headerName must be writable by browser Fetch; browser-forbidden request headers cannot carry a proof."
+    );
+  }
+}
+function assertAttestableMode(mode) {
+  if (mode === "no-cors") {
+    throw new SignerClientError(
+      "SIGNER_PREPARATION_FAILED",
+      "Request mode no-cors cannot carry an attestation proof. Use cors or same-origin."
+    );
+  }
+}
 function resolveOptions(options) {
   if (options === null || typeof options !== "object" || Array.isArray(options)) {
     throw new AttestationProtocolError("fetchWithAttestation options must be an object");
@@ -1773,10 +1824,11 @@ function resolveOptions(options) {
   );
   const headerName = options.headerName ?? DEFAULT_ATTESTATION_HEADER;
   validateHeaderName(headerName);
+  assertFetchProofHeaderName(headerName);
   const maxBodyBytes = validateMaxBodyBytes2(options.maxBodyBytes);
   const bodyReadTimeoutMs = validateBodyReadTimeoutMs2(options.bodyReadTimeoutMs);
-  const now = options.now ?? Date.now;
-  if (typeof now !== "function") {
+  const now2 = options.now ?? Date.now;
+  if (typeof now2 !== "function") {
     throw new AttestationProtocolError("fetchWithAttestation now must be a function");
   }
   return Object.freeze({
@@ -1787,13 +1839,13 @@ function resolveOptions(options) {
     headerName,
     maxBodyBytes,
     bodyReadTimeoutMs,
-    now
+    now: now2
   });
 }
-function checkedTimestampMs(now) {
+function checkedTimestampMs(now2) {
   let value;
   try {
-    value = now();
+    value = now2();
   } catch {
     throw new SignerClientError("SIGNER_PREPARATION_FAILED", "Attestation clock failed.");
   }
@@ -1919,9 +1971,18 @@ function buildSignedRequest(snapshot, headerName, transactionId) {
   if (bodyForFetch !== null) {
     init.body = bodyForFetch;
   }
+  let request;
   try {
-    return new Request(snapshot.url, init);
+    request = new Request(snapshot.url, init);
+    if (request.headers.get(headerName) !== transactionId) {
+      throw new SignerClientError(
+        "SIGNER_PREPARATION_FAILED",
+        "Prepared request did not retain the exact attestation proof header."
+      );
+    }
+    return request;
   } catch (error) {
+    cancelOwnedBody(request);
     if (error instanceof SignerClientError || error instanceof AttestationProtocolError) {
       throw error;
     }
@@ -1938,15 +1999,111 @@ function isStaleKeyRetryCandidate(response) {
     return false;
   }
 }
+function cancelOwnedBody(owner) {
+  try {
+    void owner?.body?.cancel().catch(() => void 0);
+  } catch {
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    if (signal.reason !== void 0) throw signal.reason;
+    throw new SignerClientError("SIGNER_PREPARATION_FAILED", "Request was aborted before sending.");
+  }
+}
+async function withPreparationAbort(signal, prepare) {
+  throwIfAborted(signal);
+  if (signal === null) return prepare();
+  let onAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    onAbort = () => {
+      try {
+        throwIfAborted(signal);
+      } catch (reason) {
+        reject(reason);
+      }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(prepare), aborted]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+function copyRequestWithoutBody(input) {
+  return new Request(input.url, {
+    method: input.method,
+    headers: input.headers,
+    credentials: input.credentials,
+    signal: input.signal,
+    mode: input.mode === "navigate" ? "same-origin" : input.mode,
+    cache: input.cache,
+    referrer: input.referrer,
+    referrerPolicy: input.referrerPolicy,
+    integrity: input.integrity,
+    keepalive: input.keepalive,
+    redirect: input.redirect
+  });
+}
+async function prepareSnapshot(input, init, overridingBody, config) {
+  let unreadOwner;
+  try {
+    let base;
+    try {
+      let source = input;
+      if (input instanceof Request) {
+        if (overridingBody) {
+          source = copyRequestWithoutBody(input);
+        } else if (input.body !== null) {
+          unreadOwner = input.clone();
+          source = unreadOwner;
+        }
+      }
+      base = new Request(source, init);
+      unreadOwner = base;
+    } catch (error) {
+      if (error instanceof SignerClientError || error instanceof AttestationProtocolError) throw error;
+      const message = error instanceof Error ? `: ${error.message}` : "";
+      throw new SignerClientError("SIGNER_PREPARATION_FAILED", `Request could not be prepared${message}.`);
+    }
+    assertAttestableMode(base.mode);
+    if (new URL(base.url).origin !== config.apiOrigin) {
+      throw new SignerClientError(
+        "SIGNER_ORIGIN_MISMATCH",
+        "Request origin does not match the configured API origin. Signatures are only attached to the configured API origin."
+      );
+    }
+    assertAllowedContentEncoding(base.headers);
+    throwIfAborted(base.signal);
+    unreadOwner = void 0;
+    const bodyBytes = await materializeRequestBodyBytes(base, {
+      maxBodyBytes: config.maxBodyBytes,
+      signal: base.signal,
+      timeoutMs: config.bodyReadTimeoutMs
+    });
+    return buildPreparedSnapshot(base, bodyBytes);
+  } finally {
+    cancelOwnedBody(unreadOwner);
+  }
+}
 async function fetchWithAttestation(input, init, options) {
   const config = resolveOptions(options);
   if (init !== void 0 && (init === null || typeof init !== "object" || Array.isArray(init))) {
     throw new AttestationProtocolError("fetchWithAttestation init must be an object");
   }
-  const initRecord = init ?? {};
-  if (initRecord.body !== void 0 && initRecord.body !== null) {
-    assertSupportedBodyInit(initRecord.body);
-  }
+  const initMode = init?.mode;
+  assertAttestableMode(initMode === void 0 && input instanceof Request ? input.mode : initMode);
+  const initBody = init?.body;
+  const overridingBody = initBody !== void 0 && initBody !== null;
+  if (overridingBody) assertSupportedBodyInit(initBody);
+  const stableInit = init === void 0 ? void 0 : new Proxy(init, {
+    get(target, property) {
+      if (property === "body") return initBody;
+      if (property === "mode") return initMode;
+      return Reflect.get(target, property, target);
+    }
+  });
   if (typeof input === "string") {
     if (input.length === 0) {
       throw new AttestationProtocolError("fetchWithAttestation input must be a non-empty URL or Request");
@@ -1954,78 +2111,36 @@ async function fetchWithAttestation(input, init, options) {
   } else if (!(input instanceof Request) && !(input instanceof URL)) {
     throw new AttestationProtocolError("fetchWithAttestation input must be a URL, string, or Request");
   }
-  if (input instanceof Request) {
-    if (input.bodyUsed === true) {
-      const overridingBody = initRecord.body !== void 0 && initRecord.body !== null;
-      if (!overridingBody) {
-        throw new SignerClientError(
-          "SIGNER_PREPARATION_FAILED",
-          "Request body has already been used. Clone the Request before sending or pass a fresh body."
-        );
-      }
-    }
-    try {
-      const locked = input.body?.locked;
-      if (locked === true && (initRecord.body === void 0 || initRecord.body === null)) {
-        throw new SignerClientError(
-          "SIGNER_PREPARATION_FAILED",
-          "Request body is locked. Clone the Request before sending or pass a fresh body."
-        );
-      }
-    } catch (error) {
-      if (error instanceof SignerClientError) {
-        throw error;
-      }
-    }
-  }
-  let base;
-  try {
-    base = new Request(input, init ?? {});
-  } catch (error) {
-    if (error instanceof SignerClientError || error instanceof AttestationProtocolError) {
-      throw error;
+  if (input instanceof Request && !overridingBody) {
+    if (input.bodyUsed) {
+      throw new SignerClientError(
+        "SIGNER_PREPARATION_FAILED",
+        "Request body has already been used. Clone the Request before sending or pass a fresh body."
+      );
     }
-    const message = error instanceof Error ? `: ${error.message}` : "";
-    throw new SignerClientError("SIGNER_PREPARATION_FAILED", `Request could not be prepared${message}.`);
-  }
-  let requestOrigin;
-  try {
-    requestOrigin = new URL(base.url).origin;
-  } catch {
-    throw new SignerClientError("SIGNER_PREPARATION_FAILED", "Request URL is invalid.");
-  }
-  if (requestOrigin !== config.apiOrigin) {
-    throw new SignerClientError(
-      "SIGNER_ORIGIN_MISMATCH",
-      "Request origin does not match the configured API origin. Signatures are only attached to the configured API origin."
-    );
-  }
-  assertAllowedContentEncoding(base.headers);
-  if (base.signal?.aborted === true) {
-    const reason = base.signal.reason;
-    if (reason !== void 0) {
-      throw reason;
+    if (input.body?.locked) {
+      throw new SignerClientError(
+        "SIGNER_PREPARATION_FAILED",
+        "Request body is locked. Clone the Request before sending or pass a fresh body."
+      );
     }
-    throw new SignerClientError("SIGNER_PREPARATION_FAILED", "Request was aborted before signing.");
   }
-  const bodyBytes = await materializeRequestBodyBytes(base, {
-    maxBodyBytes: config.maxBodyBytes,
-    signal: base.signal,
-    timeoutMs: config.bodyReadTimeoutMs
-  });
-  const snapshot = buildPreparedSnapshot(base, bodyBytes);
-  async function signWithFreshProof(signerKeyIdCheck) {
-    void signerKeyIdCheck;
+  const snapshot = await prepareSnapshot(input, stableInit, overridingBody, config);
+  let bodyHashHex;
+  async function signWithFreshProof() {
+    throwIfAborted(snapshot.signal);
     const signer = await config.signerClient.getSigner();
+    throwIfAborted(snapshot.signal);
     if (signer.version !== 1 || signer.publicOrigin !== config.apiOrigin || signer.replayNamespace !== config.replayNamespace) {
       throw new SignerClientError(
         "SIGNER_ORIGIN_MISMATCH",
         "Loaded signer protection space does not match the configured API origin/namespace."
       );
     }
+    bodyHashHex ??= await hashBodySha256Hex(snapshot.bodyBytes);
+    throwIfAborted(snapshot.signal);
     const timestampMs = checkedTimestampMs(config.now);
     const nonceHex = generateNonceHex();
-    const bodyHashHex = await hashBodySha256Hex(snapshot.bodyBytes);
     const transactionId = await signer.sign({
       method: snapshot.method,
       requestTarget: snapshot.requestTarget,
@@ -2034,11 +2149,22 @@ async function fetchWithAttestation(input, init, options) {
       timestampMs,
       nonceHex
     });
+    throwIfAborted(snapshot.signal);
     return { transactionId, observedKeyId: signer.keyId };
   }
-  const first = await signWithFreshProof();
+  async function send(request) {
+    try {
+      throwIfAborted(snapshot.signal);
+      const fetchImpl = config.fetchImpl;
+      return await fetchImpl(request);
+    } catch (reason) {
+      cancelOwnedBody(request);
+      throw reason;
+    }
+  }
+  const first = await withPreparationAbort(snapshot.signal, signWithFreshProof);
   const firstRequest = buildSignedRequest(snapshot, config.headerName, first.transactionId);
-  const firstResponse = await config.fetchImpl(firstRequest);
+  const firstResponse = await send(firstRequest);
   if (!isStaleKeyRetryCandidate(firstResponse)) {
     return firstResponse;
   }
@@ -2046,19 +2172,21 @@ async function fetchWithAttestation(input, init, options) {
     config.signerClient.invalidate(first.observedKeyId);
   } catch {
   }
+  let secondRequest;
   try {
-    await firstResponse.body?.cancel();
-  } catch {
-  }
-  let secondSignerTransaction;
-  try {
-    secondSignerTransaction = await signWithFreshProof();
+    const second = await withPreparationAbort(snapshot.signal, signWithFreshProof);
+    throwIfAborted(snapshot.signal);
+    if (second.transactionId === first.transactionId) {
+      return firstResponse;
+    }
+    secondRequest = buildSignedRequest(snapshot, config.headerName, second.transactionId);
   } catch {
+    if (snapshot.signal?.aborted) {
+      cancelOwnedBody(firstResponse);
+      throwIfAborted(snapshot.signal);
+    }
     return firstResponse;
   }
-  if (secondSignerTransaction.transactionId === first.transactionId) {
-    return firstResponse;
-  }
-  const secondRequest = buildSignedRequest(snapshot, config.headerName, secondSignerTransaction.transactionId);
-  return config.fetchImpl(secondRequest);
+  cancelOwnedBody(firstResponse);
+  return send(secondRequest);
 }