@web-ts-toolkit/express-request-attestation 0.48.0

package/index.js

@@ -0,0 +1,2881 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ATTESTATION_ERROR_RESPONSE_HEADER: () => ATTESTATION_ERROR_RESPONSE_HEADER,
+  AttestationCapacityError: () => AttestationCapacityError,
+  AttestationError: () => AttestationError,
+  AttestationMongoStoreError: () => AttestationMongoStoreError,
+  AttestationProtocolError: () => AttestationProtocolError,
+  AttestationRedisStoreError: () => AttestationRedisStoreError,
+  DEFAULT_ATTESTATION_HEADER: () => DEFAULT_ATTESTATION_HEADER,
+  DEFAULT_CLOCK_SKEW_MS: () => DEFAULT_CLOCK_SKEW_MS,
+  DEFAULT_CLUSTER_CLOCK_GUARD_MS: () => DEFAULT_CLUSTER_CLOCK_GUARD_MS,
+  DEFAULT_MAX_AGE_MS: () => DEFAULT_MAX_AGE_MS,
+  DEFAULT_MAX_BODY_BYTES: () => DEFAULT_MAX_BODY_BYTES,
+  EMPTY_BODY_SHA256_HEX: () => EMPTY_BODY_SHA256_HEX,
+  GLOBAL_MAX_RETENTION_MS: () => GLOBAL_MAX_RETENTION_MS,
+  KEY_BYTES_LENGTH: () => KEY_BYTES_LENGTH,
+  MAC_BYTES_LENGTH: () => MAC_BYTES_LENGTH,
+  MAC_INPUT_LABEL: () => MAC_INPUT_LABEL,
+  MAX_BODY_BYTES_HARD_CAP: () => MAX_BODY_BYTES_HARD_CAP,
+  MAX_CLOCK_SKEW_MS: () => MAX_CLOCK_SKEW_MS,
+  MAX_CLUSTER_CLOCK_GUARD_MS: () => MAX_CLUSTER_CLOCK_GUARD_MS,
+  MAX_CONTENT_TYPE_BYTES: () => MAX_CONTENT_TYPE_BYTES,
+  MAX_ENCODED_TRANSACTION_ID_BYTES: () => MAX_ENCODED_TRANSACTION_ID_BYTES,
+  MAX_HEADER_NAME_BYTES: () => MAX_HEADER_NAME_BYTES,
+  MAX_KEY_ID_LENGTH: () => MAX_KEY_ID_LENGTH,
+  MAX_MAX_AGE_MS: () => MAX_MAX_AGE_MS,
+  MAX_PUBLIC_ORIGIN_BYTES: () => MAX_PUBLIC_ORIGIN_BYTES,
+  MAX_REPLAY_KEY_BYTES: () => MAX_REPLAY_KEY_BYTES,
+  MAX_REPLAY_NAMESPACE_LENGTH: () => MAX_REPLAY_NAMESPACE_LENGTH,
+  MAX_REQUEST_TARGET_BYTES: () => MAX_REQUEST_TARGET_BYTES,
+  MIN_CLOCK_SKEW_MS: () => MIN_CLOCK_SKEW_MS,
+  MIN_CLUSTER_CLOCK_GUARD_MS: () => MIN_CLUSTER_CLOCK_GUARD_MS,
+  MIN_MAX_AGE_MS: () => MIN_MAX_AGE_MS,
+  MIN_REPLAY_KEY_BYTES: () => MIN_REPLAY_KEY_BYTES,
+  MONGO_ATTESTATION_STORE_DEFAULT_CAPACITY_COLLECTION: () => MONGO_ATTESTATION_STORE_DEFAULT_CAPACITY_COLLECTION,
+  MONGO_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES: () => MONGO_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES,
+  MONGO_ATTESTATION_STORE_DEFAULT_PROOFS_COLLECTION: () => MONGO_ATTESTATION_STORE_DEFAULT_PROOFS_COLLECTION,
+  NONCE_BYTES_LENGTH: () => NONCE_BYTES_LENGTH,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  REDIS_ATTESTATION_STORE_DEFAULT_KEY_PREFIX: () => REDIS_ATTESTATION_STORE_DEFAULT_KEY_PREFIX,
+  REDIS_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES: () => REDIS_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES,
+  REPLAY_KEY_PREFIX: () => REPLAY_KEY_PREFIX,
+  assertAllowedContentEncoding: () => assertAllowedContentEncoding,
+  assertTimestampMs: () => assertTimestampMs,
+  base64urlDecode: () => base64urlDecode,
+  base64urlEncode: () => base64urlEncode,
+  buildMacInputBytes: () => buildMacInputBytes,
+  buildReplayKeyPreimageBytes: () => buildReplayKeyPreimageBytes,
+  canonicalJsonBytes: () => canonicalJsonBytes,
+  canonicalizeRequestTarget: () => canonicalizeRequestTarget,
+  checkProofTiming: () => checkProofTiming,
+  checkRetentionAdmissible: () => checkRetentionAdmissible,
+  copyAttestationSnapshot: () => copyAttestationSnapshot,
+  createAttestationBodyCapture: () => createAttestationBodyCapture,
+  createMemoryAttestationStore: () => createMemoryAttestationStore,
+  createMongoAttestationStore: () => createMongoAttestationStore,
+  createRedisAttestationStore: () => createRedisAttestationStore,
+  createRequestAttestationMiddleware: () => createRequestAttestationMiddleware,
+  createRotatingKeyProvider: () => createRotatingKeyProvider,
+  createSignerBundleRouter: () => createSignerBundleRouter,
+  createStaticKeyProvider: () => createStaticKeyProvider,
+  decodeTransactionId: () => decodeTransactionId,
+  deriveAttestationReplayKey: () => deriveAttestationReplayKey,
+  deriveReplayKey: () => deriveReplayKey,
+  encodeTransactionId: () => encodeTransactionId,
+  evaluateProofTiming: () => evaluateProofTiming,
+  extractSingleHeaderValue: () => extractSingleHeaderValue,
+  generateAttestationKey: () => generateAttestationKey,
+  getAttestationBodyRecord: () => getAttestationBodyRecord,
+  hashBodySha256Hex: () => hashBodySha256Hex,
+  isAttestationError: () => isAttestationError,
+  maxStoreAdmissionMs: () => maxStoreAdmissionMs,
+  maxVerifierRemainingMs: () => maxVerifierRemainingMs,
+  normalizeContentType: () => normalizeContentType,
+  normalizeMethod: () => normalizeMethod,
+  parseCanonicalJsonArray: () => parseCanonicalJsonArray,
+  resolveContentType: () => resolveContentType,
+  resolveRequestTarget: () => resolveRequestTarget,
+  resolveTimePolicy: () => resolveTimePolicy,
+  toAttestationErrorPayload: () => toAttestationErrorPayload,
+  utf8ByteLength: () => utf8ByteLength,
+  utf8Decode: () => utf8Decode,
+  utf8Encode: () => utf8Encode,
+  validateBodyHashHex: () => validateBodyHashHex,
+  validateHeaderName: () => validateHeaderName,
+  validateKeyBytes: () => validateKeyBytes,
+  validateKeyId: () => validateKeyId,
+  validateMac: () => validateMac,
+  validateNonceHex: () => validateNonceHex,
+  validatePublicOrigin: () => validatePublicOrigin,
+  validateReplayKey: () => validateReplayKey,
+  validateReplayNamespace: () => validateReplayNamespace,
+  verifyAttestationProof: () => verifyAttestationProof
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_crypto6 = require("crypto");
+
+// src/shared/types.ts
+var PROTOCOL_VERSION = 1;
+var MAC_INPUT_LABEL = "wtt-request-signature";
+var DEFAULT_ATTESTATION_HEADER = "x-client-transaction-id";
+var ATTESTATION_ERROR_RESPONSE_HEADER = "x-attestation-error";
+var REPLAY_KEY_PREFIX = "att:v1:";
+var KEY_BYTES_LENGTH = 32;
+var NONCE_BYTES_LENGTH = 16;
+var MAC_BYTES_LENGTH = 32;
+var MAX_KEY_ID_LENGTH = 64;
+var MAX_REPLAY_NAMESPACE_LENGTH = 128;
+var MAX_ENCODED_TRANSACTION_ID_BYTES = 1024;
+var MAX_REQUEST_TARGET_BYTES = 8192;
+var MAX_CONTENT_TYPE_BYTES = 256;
+var MAX_PUBLIC_ORIGIN_BYTES = 512;
+var MIN_REPLAY_KEY_BYTES = 1;
+var MAX_REPLAY_KEY_BYTES = 256;
+var MAX_HEADER_NAME_BYTES = 128;
+var DEFAULT_MAX_BODY_BYTES = 1048576;
+var MAX_BODY_BYTES_HARD_CAP = 16777216;
+var DEFAULT_MAX_AGE_MS = 3e4;
+var MIN_MAX_AGE_MS = 1e3;
+var MAX_MAX_AGE_MS = 12e4;
+var DEFAULT_CLOCK_SKEW_MS = 5e3;
+var MIN_CLOCK_SKEW_MS = 0;
+var MAX_CLOCK_SKEW_MS = 3e4;
+var DEFAULT_CLUSTER_CLOCK_GUARD_MS = 5e3;
+var MIN_CLUSTER_CLOCK_GUARD_MS = 0;
+var MAX_CLUSTER_CLOCK_GUARD_MS = 3e4;
+var GLOBAL_MAX_RETENTION_MS = 24e4;
+var EMPTY_BODY_SHA256_HEX = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+var AttestationProtocolError = class extends Error {
+  name = "AttestationProtocolError";
+  constructor(message) {
+    super(`[express-request-attestation] ${message}`);
+  }
+};
+
+// src/shared/canonical.ts
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var BASE64URL_DECODE_TABLE = (() => {
+  const table = /* @__PURE__ */ Object.create(null);
+  for (let index = 0; index < BASE64URL_ALPHABET.length; index += 1) {
+    table[BASE64URL_ALPHABET[index]] = index;
+  }
+  return table;
+})();
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+function utf8Encode(text) {
+  if (typeof text !== "string") {
+    throw new AttestationProtocolError("expected a string for UTF-8 encoding");
+  }
+  return textEncoder.encode(text);
+}
+function utf8Decode(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new AttestationProtocolError("expected a Uint8Array for UTF-8 decoding");
+  }
+  try {
+    return textDecoder.decode(bytes);
+  } catch {
+    throw new AttestationProtocolError("input is not valid UTF-8");
+  }
+}
+function utf8ByteLength(text) {
+  return utf8Encode(text).length;
+}
+function base64urlEncode(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new AttestationProtocolError("expected a Uint8Array for base64url encoding");
+  }
+  let out = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const first = bytes[index];
+    const second = index + 1 < bytes.length ? bytes[index + 1] : 0;
+    const third = index + 2 < bytes.length ? bytes[index + 2] : 0;
+    const triplet = first << 16 | second << 8 | third;
+    out += BASE64URL_ALPHABET[triplet >> 18 & 63];
+    out += BASE64URL_ALPHABET[triplet >> 12 & 63];
+    if (index + 1 < bytes.length) {
+      out += BASE64URL_ALPHABET[triplet >> 6 & 63];
+    }
+    if (index + 2 < bytes.length) {
+      out += BASE64URL_ALPHABET[triplet & 63];
+    }
+  }
+  return out;
+}
+function base64urlDecode(input) {
+  if (typeof input !== "string" || input.length === 0) {
+    throw new AttestationProtocolError("base64url input must be a non-empty string");
+  }
+  for (const char of input) {
+    if (!(char in BASE64URL_DECODE_TABLE)) {
+      throw new AttestationProtocolError("base64url input uses a non-canonical alphabet or padding");
+    }
+  }
+  if (input.length % 4 === 1) {
+    throw new AttestationProtocolError("base64url input has an impossible length");
+  }
+  const outLength = Math.floor(input.length * 6 / 8);
+  const out = new Uint8Array(outLength);
+  let cursor = 0;
+  let buffer = 0;
+  let bits = 0;
+  for (const char of input) {
+    buffer = buffer << 6 | BASE64URL_DECODE_TABLE[char];
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[cursor] = buffer >> bits & 255;
+      cursor += 1;
+    }
+  }
+  if (bits > 0 && (buffer & (1 << bits) - 1) !== 0) {
+    throw new AttestationProtocolError("base64url input has non-canonical trailing bits");
+  }
+  const canonical = base64urlEncode(out);
+  if (canonical !== input) {
+    throw new AttestationProtocolError("base64url input is not canonical");
+  }
+  return out;
+}
+function canonicalJsonBytes(value) {
+  let text;
+  try {
+    text = JSON.stringify(value);
+  } catch {
+    throw new AttestationProtocolError("value is not JSON-serializable");
+  }
+  if (typeof text !== "string") {
+    throw new AttestationProtocolError("value is not JSON-serializable");
+  }
+  return utf8Encode(text);
+}
+function parseCanonicalJsonArray(text, expectedLength) {
+  if (typeof text !== "string") {
+    throw new AttestationProtocolError("canonical JSON input must be a string");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new AttestationProtocolError("input is not valid JSON");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new AttestationProtocolError("canonical JSON input must be an array");
+  }
+  if (JSON.stringify(parsed) !== text) {
+    throw new AttestationProtocolError("JSON input is not in canonical form");
+  }
+  if (expectedLength !== void 0 && parsed.length !== expectedLength) {
+    throw new AttestationProtocolError(`canonical JSON array must have exactly ${expectedLength} elements`);
+  }
+  return parsed;
+}
+function assertTimestampMs(name, value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new AttestationProtocolError(`${name} must be a non-negative safe integer`);
+  }
+}
+
+// src/shared/codec.ts
+var KEY_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+var REPLAY_NAMESPACE_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+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}$/;
+var RESERVED_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "www-authenticate",
+  "cookie",
+  "set-cookie",
+  "host",
+  "origin",
+  "content-encoding",
+  "content-length",
+  "content-type",
+  "transfer-encoding",
+  ATTESTATION_ERROR_RESPONSE_HEADER
+]);
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "[::1]" || /^127\./.test(hostname);
+}
+function validateKeyId(keyId) {
+  if (typeof keyId !== "string" || !KEY_ID_PATTERN.test(keyId) || keyId.length > MAX_KEY_ID_LENGTH) {
+    throw new AttestationProtocolError("keyId must match [A-Za-z0-9_-]{1,64}");
+  }
+}
+function validateReplayNamespace(namespace) {
+  if (typeof namespace !== "string" || !REPLAY_NAMESPACE_PATTERN.test(namespace) || namespace.length > MAX_REPLAY_NAMESPACE_LENGTH) {
+    throw new AttestationProtocolError("replayNamespace must match [A-Za-z0-9_-]{1,128}");
+  }
+}
+function validateNonceHex(nonceHex) {
+  if (typeof nonceHex !== "string" || !NONCE_HEX_PATTERN.test(nonceHex)) {
+    throw new AttestationProtocolError("nonceHex must be exactly 32 lowercase hex characters");
+  }
+}
+function validateBodyHashHex(bodyHashHex) {
+  if (typeof bodyHashHex !== "string" || !BODY_HASH_HEX_PATTERN.test(bodyHashHex)) {
+    throw new AttestationProtocolError("bodyHashHex must be exactly 64 lowercase hex characters");
+  }
+}
+function validateMac(mac) {
+  if (typeof mac !== "string" || mac.length !== 43) {
+    throw new AttestationProtocolError("mac must be exactly 43 base64url characters");
+  }
+  const decoded = base64urlDecode(mac);
+  if (decoded.length !== MAC_BYTES_LENGTH) {
+    throw new AttestationProtocolError("mac must decode to 32 bytes");
+  }
+}
+function validateKeyBytes(key) {
+  if (!(key instanceof Uint8Array) || key.length !== KEY_BYTES_LENGTH) {
+    throw new AttestationProtocolError("signing key must be exactly 32 bytes");
+  }
+}
+function validatePublicOrigin(origin) {
+  if (typeof origin !== "string") {
+    throw new AttestationProtocolError("publicOrigin must be a string");
+  }
+  if (origin.length === 0 || utf8ByteLength(origin) > MAX_PUBLIC_ORIGIN_BYTES) {
+    throw new AttestationProtocolError(`publicOrigin must be 1-${MAX_PUBLIC_ORIGIN_BYTES} UTF-8 bytes`);
+  }
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    throw new AttestationProtocolError("publicOrigin must be a valid HTTP(S) origin");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new AttestationProtocolError("publicOrigin must use http or https");
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new AttestationProtocolError("publicOrigin must not contain userinfo");
+  }
+  const canonical = `${url.protocol}//${url.host}`;
+  if (origin !== canonical) {
+    throw new AttestationProtocolError(
+      "publicOrigin must be canonical (lowercase, no path, no trailing slash, no default port)"
+    );
+  }
+  if (url.protocol === "http:" && !isLoopbackHostname(url.hostname)) {
+    throw new AttestationProtocolError("http publicOrigin is allowed only for loopback development");
+  }
+}
+function normalizeMethod(method) {
+  if (typeof method !== "string" || method.length === 0 || !HTTP_TOKEN_PATTERN.test(method)) {
+    throw new AttestationProtocolError("method must be a non-empty valid HTTP token");
+  }
+  return method.toUpperCase();
+}
+function normalizeContentType(contentType) {
+  if (contentType === void 0 || contentType === null) {
+    return "";
+  }
+  if (typeof contentType !== "string") {
+    throw new AttestationProtocolError("contentType must be a string");
+  }
+  const trimmed = contentType.replace(/^[ \t]+|[ \t]+$/g, "");
+  for (const char of trimmed) {
+    const code = char.codePointAt(0);
+    if (code === 9 || code === 32) {
+      continue;
+    }
+    if (code < 32 || code === 127) {
+      throw new AttestationProtocolError("contentType must not contain control characters");
+    }
+  }
+  if (utf8ByteLength(trimmed) > MAX_CONTENT_TYPE_BYTES) {
+    throw new AttestationProtocolError(`contentType must be at most ${MAX_CONTENT_TYPE_BYTES} UTF-8 bytes`);
+  }
+  return trimmed;
+}
+function assertValidPercentEscapes(target) {
+  for (let index = 0; index < target.length; index += 1) {
+    if (target[index] !== "%") {
+      continue;
+    }
+    const hex = target.slice(index + 1, index + 3);
+    if (!HEX_BYTE_PATTERN.test(hex)) {
+      throw new AttestationProtocolError("requestTarget contains a malformed percent escape");
+    }
+    index += 2;
+  }
+}
+function percentDecodeSegment(segment) {
+  return segment.replace(/%[0-9a-fA-F]{2}/g, (escape) => String.fromCharCode(Number.parseInt(escape.slice(1), 16)));
+}
+function canonicalizeRequestTarget(target) {
+  if (typeof target !== "string") {
+    throw new AttestationProtocolError("requestTarget must be a string");
+  }
+  if (target.length === 0) {
+    throw new AttestationProtocolError("requestTarget must not be empty");
+  }
+  if (utf8ByteLength(target) > MAX_REQUEST_TARGET_BYTES) {
+    throw new AttestationProtocolError(`requestTarget must be at most ${MAX_REQUEST_TARGET_BYTES} UTF-8 bytes`);
+  }
+  if (!target.startsWith("/")) {
+    throw new AttestationProtocolError("requestTarget must be an origin-form target starting with /");
+  }
+  if (target.startsWith("//")) {
+    throw new AttestationProtocolError("requestTarget must not resolve as an authority");
+  }
+  for (const char of target) {
+    const code = char.codePointAt(0);
+    if (code <= 32 || code === 127) {
+      throw new AttestationProtocolError("requestTarget must not contain controls or raw spaces");
+    }
+    if (char === "#" || char === "\\") {
+      throw new AttestationProtocolError("requestTarget must not contain fragments or backslashes");
+    }
+  }
+  assertValidPercentEscapes(target);
+  const queryIndex = target.indexOf("?");
+  const path2 = queryIndex === -1 ? target : target.slice(0, queryIndex);
+  for (const segment of path2.split("/")) {
+    if (segment === "." || segment === "..") {
+      throw new AttestationProtocolError("requestTarget must not contain dot segments");
+    }
+    const decoded = percentDecodeSegment(segment).toLowerCase();
+    if (decoded === "." || decoded === "..") {
+      throw new AttestationProtocolError("requestTarget must not contain encoded dot segments");
+    }
+  }
+  if (queryIndex === target.length - 1) {
+    return target.slice(0, queryIndex);
+  }
+  return target;
+}
+function validateHeaderName(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new AttestationProtocolError("headerName must be a non-empty string");
+  }
+  if (utf8ByteLength(name) > MAX_HEADER_NAME_BYTES) {
+    throw new AttestationProtocolError(`headerName must be at most ${MAX_HEADER_NAME_BYTES} UTF-8 bytes`);
+  }
+  if (!HTTP_TOKEN_PATTERN.test(name)) {
+    throw new AttestationProtocolError("headerName must be a valid HTTP token");
+  }
+  if (RESERVED_HEADER_NAMES.has(name.toLowerCase())) {
+    throw new AttestationProtocolError(`headerName must not collide with reserved header ${name}`);
+  }
+}
+function extractSingleHeaderValue(raw) {
+  if (raw === void 0) {
+    return null;
+  }
+  const values = (Array.isArray(raw) ? raw : [raw]).filter((entry) => entry !== void 0);
+  if (values.length === 0) {
+    return null;
+  }
+  if (values.length > 1) {
+    throw new AttestationProtocolError("duplicate signature headers are not allowed");
+  }
+  const value = values[0];
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  if (value.includes(",")) {
+    throw new AttestationProtocolError("comma-joined signature headers are not allowed");
+  }
+  return value;
+}
+function validateReplayKey(replayKey) {
+  if (typeof replayKey !== "string") {
+    throw new AttestationProtocolError("replayKey must be a string");
+  }
+  const length = replayKey.length;
+  if (length < MIN_REPLAY_KEY_BYTES || length > MAX_REPLAY_KEY_BYTES) {
+    throw new AttestationProtocolError(`replayKey must be ${MIN_REPLAY_KEY_BYTES}-${MAX_REPLAY_KEY_BYTES} characters`);
+  }
+  for (const char of replayKey) {
+    const code = char.codePointAt(0);
+    if (code < 32 || code > 126) {
+      throw new AttestationProtocolError("replayKey must be printable ASCII");
+    }
+  }
+}
+function buildMacInputBytes(fields) {
+  validateReplayNamespace(fields.replayNamespace);
+  validatePublicOrigin(fields.publicOrigin);
+  validateKeyId(fields.keyId);
+  assertTimestampMs("timestampMs", fields.timestampMs);
+  validateNonceHex(fields.nonceHex);
+  const method = normalizeMethod(fields.method);
+  const requestTarget = canonicalizeRequestTarget(fields.requestTarget);
+  const contentType = normalizeContentType(fields.contentType);
+  validateBodyHashHex(fields.bodyHashHex);
+  const tuple = [
+    MAC_INPUT_LABEL,
+    PROTOCOL_VERSION,
+    fields.replayNamespace,
+    fields.publicOrigin,
+    fields.keyId,
+    fields.timestampMs,
+    fields.nonceHex,
+    method,
+    requestTarget,
+    contentType,
+    fields.bodyHashHex
+  ];
+  return canonicalJsonBytes(tuple);
+}
+function buildReplayKeyPreimageBytes(input) {
+  validateReplayNamespace(input.replayNamespace);
+  validatePublicOrigin(input.publicOrigin);
+  validateNonceHex(input.nonceHex);
+  return canonicalJsonBytes([input.replayNamespace, input.publicOrigin, input.nonceHex]);
+}
+function encodeTransactionId(fields) {
+  validateKeyId(fields.keyId);
+  assertTimestampMs("timestampMs", fields.timestampMs);
+  validateNonceHex(fields.nonceHex);
+  validateMac(fields.mac);
+  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`
+    );
+  }
+  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`
+    );
+  }
+  const bytes = base64urlDecode(headerValue);
+  const text = utf8Decode(bytes);
+  const envelope = parseCanonicalJsonArray(text, 5);
+  const [version, keyId, timestampMs, nonceHex, mac] = envelope;
+  if (version !== PROTOCOL_VERSION) {
+    throw new AttestationProtocolError(`unsupported transactionId version ${String(version)}`);
+  }
+  validateKeyId(keyId);
+  assertTimestampMs("timestampMs", timestampMs);
+  validateNonceHex(nonceHex);
+  validateMac(mac);
+  return {
+    keyId,
+    timestampMs,
+    nonceHex,
+    mac
+  };
+}
+
+// src/shared/time-policy.ts
+function assertPolicyField(name, value, min, max) {
+  if (!Number.isSafeInteger(value) || value < min || value > max) {
+    throw new AttestationProtocolError(`${name} must be a safe integer in [${min}, ${max}]`);
+  }
+}
+function resolveTimePolicy(options = {}) {
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new AttestationProtocolError("time policy options must be an object");
+  }
+  const allowed = /* @__PURE__ */ new Set(["maxAgeMs", "clockSkewMs", "clusterClockGuardMs"]);
+  for (const key of Object.keys(options)) {
+    if (!allowed.has(key)) {
+      throw new AttestationProtocolError(`unknown time policy option ${key}`);
+    }
+  }
+  const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const clockSkewMs = options.clockSkewMs ?? DEFAULT_CLOCK_SKEW_MS;
+  const clusterClockGuardMs = options.clusterClockGuardMs ?? DEFAULT_CLUSTER_CLOCK_GUARD_MS;
+  assertPolicyField("maxAgeMs", maxAgeMs, MIN_MAX_AGE_MS, MAX_MAX_AGE_MS);
+  assertPolicyField("clockSkewMs", clockSkewMs, MIN_CLOCK_SKEW_MS, MAX_CLOCK_SKEW_MS);
+  assertPolicyField("clusterClockGuardMs", clusterClockGuardMs, MIN_CLUSTER_CLOCK_GUARD_MS, MAX_CLUSTER_CLOCK_GUARD_MS);
+  return Object.freeze({ maxAgeMs, clockSkewMs, clusterClockGuardMs });
+}
+function evaluateProofTiming(input) {
+  assertTimestampMs("timestampMs", input.timestampMs);
+  assertTimestampMs("nowMs", input.nowMs);
+  assertTimestampMs("acceptFrom", input.acceptFrom);
+  assertTimestampMs("acceptUntil", input.acceptUntil);
+  if (input.acceptFrom >= input.acceptUntil) {
+    throw new AttestationProtocolError("key acceptance window must satisfy acceptFrom < acceptUntil");
+  }
+  const { timestampMs, nowMs, acceptFrom, acceptUntil, policy } = input;
+  const active = acceptFrom <= nowMs && nowMs < acceptUntil;
+  if (!active) {
+    const timeDeadlineMs2 = safeAdd3(timestampMs, policy.maxAgeMs, policy.clockSkewMs);
+    const proofDeadlineMs2 = timeDeadlineMs2 === null ? acceptUntil : Math.min(timeDeadlineMs2, acceptUntil);
+    return {
+      decision: "stale-key",
+      timeDeadlineMs: timeDeadlineMs2,
+      proofDeadlineMs: proofDeadlineMs2,
+      retainUntilMs: safeAdd(proofDeadlineMs2, policy.clusterClockGuardMs)
+    };
+  }
+  if (timestampMs > nowMs + policy.clockSkewMs) {
+    const timeDeadlineMs2 = safeAdd3(timestampMs, policy.maxAgeMs, policy.clockSkewMs);
+    const proofDeadlineMs2 = timeDeadlineMs2 === null ? acceptUntil : Math.min(timeDeadlineMs2, acceptUntil);
+    return {
+      decision: "future",
+      timeDeadlineMs: timeDeadlineMs2,
+      proofDeadlineMs: proofDeadlineMs2,
+      retainUntilMs: safeAdd(proofDeadlineMs2, policy.clusterClockGuardMs)
+    };
+  }
+  const timeDeadlineMs = safeAdd3(timestampMs, policy.maxAgeMs, policy.clockSkewMs);
+  if (timeDeadlineMs === null) {
+    return { decision: "expired", timeDeadlineMs: null, proofDeadlineMs: null, retainUntilMs: null };
+  }
+  const proofDeadlineMs = Math.min(timeDeadlineMs, acceptUntil);
+  if (nowMs >= proofDeadlineMs) {
+    return {
+      decision: "expired",
+      timeDeadlineMs,
+      proofDeadlineMs,
+      retainUntilMs: safeAdd(proofDeadlineMs, policy.clusterClockGuardMs)
+    };
+  }
+  return {
+    decision: "valid",
+    timeDeadlineMs,
+    proofDeadlineMs,
+    retainUntilMs: safeAdd(proofDeadlineMs, policy.clusterClockGuardMs)
+  };
+}
+function safeAdd(first, second) {
+  const sum = first + second;
+  return Number.isSafeInteger(sum) ? sum : null;
+}
+function safeAdd3(first, second, third) {
+  const sum = first + second + third;
+  return Number.isSafeInteger(sum) ? sum : null;
+}
+function maxVerifierRemainingMs(policy) {
+  return policy.maxAgeMs + 2 * policy.clockSkewMs + policy.clusterClockGuardMs;
+}
+function maxStoreAdmissionMs(policy) {
+  return Math.min(GLOBAL_MAX_RETENTION_MS, policy.maxAgeMs + 2 * policy.clockSkewMs + 2 * policy.clusterClockGuardMs);
+}
+function checkRetentionAdmissible(input) {
+  assertTimestampMs("retainUntilMs", input.retainUntilMs);
+  assertTimestampMs("nowMs", input.nowMs);
+  const { retainUntilMs, nowMs, policy } = input;
+  if (retainUntilMs <= nowMs) {
+    return "expired";
+  }
+  const remaining = retainUntilMs - nowMs;
+  if (!Number.isSafeInteger(remaining)) {
+    return "overlong";
+  }
+  if (remaining > GLOBAL_MAX_RETENTION_MS) {
+    return "overlong";
+  }
+  if (remaining > maxStoreAdmissionMs(policy)) {
+    return "overlong";
+  }
+  return "admissible";
+}
+
+// src/server-types.ts
+var ERROR_DETAILS = {
+  ATTESTATION_MISSING: { status: 403, message: "Request signature is required." },
+  ATTESTATION_MALFORMED: { status: 403, message: "Request signature is invalid." },
+  ATTESTATION_STALE_KEY: { status: 403, message: "Request signing key is no longer accepted." },
+  ATTESTATION_EXPIRED: { status: 403, message: "Request signature has expired." },
+  ATTESTATION_FUTURE: { status: 403, message: "Request signature timestamp is ahead of the allowed clock window." },
+  ATTESTATION_INVALID_SIGNATURE: { status: 403, message: "Request signature does not match." },
+  ATTESTATION_REPLAY: { status: 403, message: "Request signature was already used." },
+  ATTESTATION_BODY_TOO_LARGE: { status: 413, message: "Request body exceeds the configured byte limit." },
+  ATTESTATION_UNSUPPORTED_ENCODING: { status: 415, message: "Request body encoding is unsupported." },
+  ATTESTATION_BODY_CAPTURE_REQUIRED: { status: 500, message: "Request body capture is not configured." },
+  ATTESTATION_INTERNAL_ERROR: { status: 500, message: "Request signature verification failed." },
+  ATTESTATION_KEYS_UNAVAILABLE: { status: 503, message: "Request signing keys are unavailable." },
+  ATTESTATION_REPLAY_UNAVAILABLE: { status: 503, message: "Request replay protection is unavailable." }
+};
+var AttestationError = class extends Error {
+  name = "AttestationError";
+  code;
+  status;
+  constructor(code) {
+    super(ERROR_DETAILS[code].message);
+    this.code = code;
+    this.status = ERROR_DETAILS[code].status;
+  }
+};
+function isAttestationError(error) {
+  return error instanceof AttestationError;
+}
+function toAttestationErrorPayload(error) {
+  return { code: error.code, message: error.message };
+}
+
+// src/body-capture.ts
+var import_node_crypto = require("crypto");
+var BODY_CAPTURE_OPTION_KEYS = /* @__PURE__ */ new Set(["maxBodyBytes"]);
+var bodyRecords = /* @__PURE__ */ new WeakMap();
+function toBytes(body) {
+  if (body === null || body === void 0) {
+    return null;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) {
+    return new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+  }
+  if (body instanceof Uint8Array) {
+    return new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+  }
+  if (typeof body === "string") {
+    return new TextEncoder().encode(body);
+  }
+  return null;
+}
+function getAttestationBodyRecord(req) {
+  if (req === null || typeof req !== "object" && typeof req !== "function") {
+    return void 0;
+  }
+  const record = bodyRecords.get(req);
+  if (record === void 0) {
+    return void 0;
+  }
+  return Object.freeze({ digestHex: record.digestHex, byteLength: record.byteLength });
+}
+function isParserSizeError(error) {
+  if (error === null || typeof error !== "object") {
+    return false;
+  }
+  const record = error;
+  if (record.type === "entity.too.large") {
+    return true;
+  }
+  return false;
+}
+function isParserEncodingError(error) {
+  if (error === null || typeof error !== "object") {
+    return false;
+  }
+  const record = error;
+  return record.type === "charset.unsupported" || record.type === "encoding.unsupported";
+}
+function sendCaptureError(res, status, code) {
+  const error = new AttestationError(code);
+  const target = res;
+  if (typeof target.setHeader === "function") {
+    target.setHeader("Cache-Control", "no-store");
+  } else if (typeof target.set === "function") {
+    target.set("Cache-Control", "no-store");
+  }
+  if (typeof target.status === "function") {
+    target.status(status).json({ code: error.code, message: error.message });
+    return;
+  }
+  throw new AttestationProtocolError("attestation body capture error handler requires an Express response");
+}
+function createAttestationBodyCapture(options = {}) {
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new AttestationProtocolError("attestation body capture options must be an object");
+  }
+  for (const key of Object.keys(options)) {
+    if (!BODY_CAPTURE_OPTION_KEYS.has(key)) {
+      throw new AttestationProtocolError(`unknown attestation body capture option ${key}`);
+    }
+  }
+  const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  if (!Number.isSafeInteger(maxBodyBytes) || maxBodyBytes <= 0) {
+    throw new AttestationProtocolError("maxBodyBytes must be a positive safe integer");
+  }
+  if (maxBodyBytes > MAX_BODY_BYTES_HARD_CAP) {
+    throw new AttestationProtocolError(
+      `maxBodyBytes must be at most ${MAX_BODY_BYTES_HARD_CAP} bytes (16 MiB v1 hard cap)`
+    );
+  }
+  const verify = (req, _res, body, _encoding) => {
+    void _encoding;
+    if (req === null || typeof req !== "object" && typeof req !== "function") {
+      return;
+    }
+    const bytes = toBytes(body);
+    if (bytes === null) {
+      return;
+    }
+    if (bytes.length > maxBodyBytes) {
+      const overflow = new Error("Request body exceeds the configured byte limit.");
+      overflow.type = "entity.too.large";
+      overflow.status = 413;
+      overflow.statusCode = 413;
+      throw overflow;
+    }
+    const digestHex = (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+    bodyRecords.set(req, Object.freeze({ digestHex, byteLength: bytes.length }));
+  };
+  const errorHandler = (err, _req, res, next) => {
+    if (err === null || err === void 0) {
+      next();
+      return;
+    }
+    const target = res;
+    if (target?.headersSent === true) {
+      next(err);
+      return;
+    }
+    if (isParserSizeError(err)) {
+      sendCaptureError(res, 413, "ATTESTATION_BODY_TOO_LARGE");
+      return;
+    }
+    if (isParserEncodingError(err)) {
+      sendCaptureError(res, 415, "ATTESTATION_UNSUPPORTED_ENCODING");
+      return;
+    }
+    next(err);
+  };
+  const getRecord = (req) => getAttestationBodyRecord(req);
+  return Object.freeze({
+    verify,
+    errorHandler,
+    getRecord,
+    maxBodyBytes
+  });
+}
+
+// src/verify.ts
+var import_node_crypto2 = require("crypto");
+function fail(code) {
+  throw new AttestationError(code);
+}
+function copyAttestationSnapshot(snapshot) {
+  try {
+    if (snapshot === null || typeof snapshot !== "object" || Array.isArray(snapshot)) {
+      throw new AttestationProtocolError("key snapshot must be an object");
+    }
+    const record = snapshot;
+    validateKeyId(record.currentKeyId);
+    if (!Array.isArray(record.keys)) {
+      throw new AttestationProtocolError("key snapshot keys must be an array");
+    }
+    if (record.keys.length === 0 || record.keys.length > 16) {
+      throw new AttestationProtocolError("key snapshot must retain 1-16 keys");
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const copied = record.keys.map((entry) => {
+      if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+        throw new AttestationProtocolError("key snapshot entry must be an object");
+      }
+      const row = entry;
+      validateKeyId(row.keyId);
+      validateKeyBytes(row.key);
+      assertTimestampMs("acceptFrom", row.acceptFrom);
+      assertTimestampMs("acceptUntil", row.acceptUntil);
+      const acceptFrom = row.acceptFrom;
+      const acceptUntil = row.acceptUntil;
+      if (acceptFrom >= acceptUntil) {
+        throw new AttestationProtocolError("key acceptance window must satisfy acceptFrom < acceptUntil");
+      }
+      const keyId = row.keyId;
+      if (seen.has(keyId)) {
+        throw new AttestationProtocolError("key snapshot keyIds must be unique");
+      }
+      seen.add(keyId);
+      const key = new Uint8Array(row.key);
+      return Object.freeze({ keyId, key, acceptFrom, acceptUntil });
+    });
+    if (!seen.has(record.currentKeyId)) {
+      throw new AttestationProtocolError("key snapshot currentKeyId must name a present entry");
+    }
+    const currentKeyId = record.currentKeyId;
+    return Object.freeze({ currentKeyId, keys: Object.freeze(copied) });
+  } catch (error) {
+    if (error instanceof AttestationError) {
+      throw error;
+    }
+    fail("ATTESTATION_KEYS_UNAVAILABLE");
+  }
+}
+function checkProofTiming(input) {
+  let timing;
+  try {
+    timing = evaluateProofTiming({
+      timestampMs: input.timestampMs,
+      nowMs: input.nowMs,
+      acceptFrom: input.keyEntry.acceptFrom,
+      acceptUntil: input.keyEntry.acceptUntil,
+      policy: input.policy
+    });
+  } catch (error) {
+    if (error instanceof AttestationError) {
+      throw error;
+    }
+    fail("ATTESTATION_INTERNAL_ERROR");
+  }
+  const decision = timing.decision;
+  if (decision === "valid") {
+    return timing;
+  }
+  if (decision === "future") {
+    fail("ATTESTATION_FUTURE");
+  }
+  if (decision === "expired") {
+    fail("ATTESTATION_EXPIRED");
+  }
+  fail("ATTESTATION_STALE_KEY");
+}
+function resolveRequestTarget(originalUrl, publicPathPrefix) {
+  try {
+    if (typeof originalUrl !== "string" || originalUrl.length === 0) {
+      throw new AttestationProtocolError("request target must be a non-empty string");
+    }
+    const full = `${publicPathPrefix}${originalUrl}`;
+    return canonicalizeRequestTarget(full);
+  } catch (error) {
+    if (error instanceof AttestationError) {
+      throw error;
+    }
+    fail("ATTESTATION_MALFORMED");
+  }
+}
+function resolveContentType(header) {
+  try {
+    if (header === void 0 || header === null) {
+      return "";
+    }
+    if (Array.isArray(header)) {
+      if (header.length === 0) {
+        return "";
+      }
+      if (header.length > 1) {
+        throw new AttestationProtocolError("duplicate content-type headers are not allowed");
+      }
+      return normalizeContentType(header[0]);
+    }
+    return normalizeContentType(header);
+  } catch (error) {
+    if (error instanceof AttestationError) {
+      throw error;
+    }
+    fail("ATTESTATION_MALFORMED");
+  }
+}
+function assertAllowedContentEncoding(header) {
+  if (header === void 0 || header === null) {
+    return;
+  }
+  const values = Array.isArray(header) ? [...header] : [header];
+  const tokens = [];
+  for (const value of values) {
+    if (typeof value !== "string") {
+      fail("ATTESTATION_MALFORMED");
+    }
+    for (const token of value.split(",")) {
+      const trimmed = token.trim();
+      if (trimmed === "") {
+        continue;
+      }
+      tokens.push(trimmed.toLowerCase());
+    }
+  }
+  for (const token of tokens) {
+    if (token !== "identity") {
+      fail("ATTESTATION_UNSUPPORTED_ENCODING");
+    }
+  }
+}
+function resolveBodyDigest(digest) {
+  try {
+    validateBodyHashHex(digest);
+    return digest;
+  } catch (error) {
+    if (error instanceof AttestationError) {
+      throw error;
+    }
+    fail("ATTESTATION_INTERNAL_ERROR");
+  }
+}
+function deriveReplayKey(input) {
+  const preimage = buildReplayKeyPreimageBytes(input);
+  const digest = (0, import_node_crypto2.createHash)("sha256").update(preimage).digest("hex");
+  return `${REPLAY_KEY_PREFIX}${digest}`;
+}
+function verifyAttestationProof(input) {
+  let headerValue;
+  try {
+    headerValue = extractSingleHeaderValue(input.headerValue);
+  } catch {
+    fail("ATTESTATION_MALFORMED");
+  }
+  if (headerValue === null) {
+    fail("ATTESTATION_MISSING");
+  }
+  let envelope;
+  try {
+    envelope = decodeTransactionId(headerValue);
+  } catch {
+    fail("ATTESTATION_MALFORMED");
+  }
+  const snapshot = copyAttestationSnapshot(input.snapshot);
+  const keyEntry = snapshot.keys.find((entry) => entry.keyId === envelope.keyId);
+  if (keyEntry === void 0) {
+    fail("ATTESTATION_STALE_KEY");
+  }
+  try {
+    assertTimestampMs("nowMs", input.nowMs);
+  } catch {
+    fail("ATTESTATION_INTERNAL_ERROR");
+  }
+  const timing = checkProofTiming({
+    timestampMs: envelope.timestampMs,
+    nowMs: input.nowMs,
+    keyEntry,
+    policy: input.policy
+  });
+  const requestTarget = resolveRequestTarget(input.originalUrl, input.publicPathPrefix ?? "");
+  let method;
+  try {
+    method = normalizeMethod(input.method);
+  } catch {
+    fail("ATTESTATION_MALFORMED");
+  }
+  assertAllowedContentEncoding(input.contentEncodingHeader);
+  const contentType = resolveContentType(input.contentTypeHeader);
+  const bodyHashHex = resolveBodyDigest(input.bodyDigestHex);
+  let macInput;
+  try {
+    macInput = buildMacInputBytes({
+      replayNamespace: input.replayNamespace,
+      publicOrigin: input.publicOrigin,
+      keyId: envelope.keyId,
+      timestampMs: envelope.timestampMs,
+      nonceHex: envelope.nonceHex,
+      method,
+      requestTarget,
+      contentType,
+      bodyHashHex
+    });
+  } catch (error) {
+    if (error instanceof AttestationError) {
+      throw error;
+    }
+    fail("ATTESTATION_INTERNAL_ERROR");
+  }
+  let presented;
+  try {
+    presented = base64urlDecode(envelope.mac);
+  } catch {
+    fail("ATTESTATION_MALFORMED");
+  }
+  if (presented.length !== 32) {
+    fail("ATTESTATION_INVALID_SIGNATURE");
+  }
+  const expected = (0, import_node_crypto2.createHmac)("sha256", Buffer.from(keyEntry.key)).update(macInput).digest();
+  const presentedBuf = Buffer.from(presented);
+  if (presentedBuf.length !== expected.length || !(0, import_node_crypto2.timingSafeEqual)(presentedBuf, expected)) {
+    fail("ATTESTATION_INVALID_SIGNATURE");
+  }
+  let replayKey;
+  try {
+    replayKey = deriveReplayKey({
+      replayNamespace: input.replayNamespace,
+      publicOrigin: input.publicOrigin,
+      nonceHex: envelope.nonceHex
+    });
+  } catch (error) {
+    if (error instanceof AttestationError) {
+      throw error;
+    }
+    fail("ATTESTATION_INTERNAL_ERROR");
+  }
+  const retainUntilMs = timing.retainUntilMs;
+  if (retainUntilMs === null || !Number.isSafeInteger(retainUntilMs)) {
+    fail("ATTESTATION_EXPIRED");
+  }
+  return Object.freeze({
+    keyId: envelope.keyId,
+    timestampMs: envelope.timestampMs,
+    nonceHex: envelope.nonceHex,
+    keyEntry,
+    timing,
+    replayKey,
+    retainUntilMs,
+    method,
+    requestTarget,
+    contentType,
+    bodyHashHex
+  });
+}
+
+// src/stores/memory.ts
+var MEMORY_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES = 5e4;
+var EXPIRY_SWEEP_BATCH_SIZE = 64;
+var STORE_OPTION_KEYS = /* @__PURE__ */ new Set(["maxEntries", "now"]);
+var AttestationCapacityError = class extends Error {
+  name = "AttestationCapacityError";
+  constructor(message = "Attestation replay store capacity is exhausted.") {
+    super(message);
+  }
+};
+var MemoryAttestationStore = class {
+  reservations = /* @__PURE__ */ new Map();
+  expiryHeap = [];
+  maxEntries;
+  now;
+  constructor(options = {}) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+      throw new AttestationProtocolError("memory attestation store options must be an object");
+    }
+    for (const key of Object.keys(options)) {
+      if (!STORE_OPTION_KEYS.has(key)) {
+        throw new AttestationProtocolError(`unknown memory attestation store option ${key}`);
+      }
+    }
+    const maxEntries = options.maxEntries === void 0 ? MEMORY_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES : options.maxEntries;
+    if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0) {
+      throw new AttestationProtocolError("memory attestation store maxEntries must be a positive safe integer");
+    }
+    const now = options.now === void 0 ? () => Date.now() : options.now;
+    if (typeof now !== "function") {
+      throw new AttestationProtocolError("memory attestation store now must be a function");
+    }
+    this.maxEntries = maxEntries;
+    this.now = now;
+  }
+  async reserve(input) {
+    if (input === null || typeof input !== "object" || Array.isArray(input)) {
+      throw new AttestationProtocolError("attestation store reserve input must be an object");
+    }
+    const record = input;
+    const replayKey = record.replayKey;
+    const retainUntilMs = record.retainUntilMs ?? record.retainUntil;
+    const nowMs = this.now();
+    if (!Number.isSafeInteger(nowMs) || nowMs < 0) {
+      throw new AttestationProtocolError("attestation store clock must return a non-negative safe integer");
+    }
+    validateReplayKey(replayKey);
+    if (retainUntilMs === void 0) {
+      throw new AttestationProtocolError("retainUntilMs must be a non-negative safe integer");
+    }
+    assertTimestampMs("retainUntilMs", retainUntilMs);
+    if (retainUntilMs <= nowMs) {
+      return "expired";
+    }
+    const remainingMs = retainUntilMs - nowMs;
+    if (remainingMs > GLOBAL_MAX_RETENTION_MS) {
+      throw new AttestationProtocolError(
+        `retainUntilMs exceeds the ${GLOBAL_MAX_RETENTION_MS} ms global retention cap`
+      );
+    }
+    const existing = this.reservations.get(replayKey);
+    if (existing !== void 0 && existing.retainUntilMs > nowMs) {
+      return "duplicate";
+    }
+    if (existing !== void 0) {
+      this.remove(existing.index);
+    }
+    for (let cleaned = 0; cleaned < EXPIRY_SWEEP_BATCH_SIZE && this.expiryHeap[0] !== void 0 && this.expiryHeap[0].retainUntilMs <= nowMs; cleaned += 1) {
+      this.remove(0);
+    }
+    if (this.reservations.size >= this.maxEntries) {
+      throw new AttestationCapacityError();
+    }
+    const reservation = {
+      replayKey,
+      retainUntilMs,
+      index: this.expiryHeap.length
+    };
+    this.reservations.set(replayKey, reservation);
+    this.expiryHeap.push(reservation);
+    this.moveUp(reservation.index);
+    return "reserved";
+  }
+  remove(index) {
+    const removed = this.expiryHeap[index];
+    const last = this.expiryHeap.pop();
+    this.reservations.delete(removed.replayKey);
+    if (index === this.expiryHeap.length) {
+      return;
+    }
+    this.expiryHeap[index] = last;
+    last.index = index;
+    this.moveUp(index);
+    this.moveDown(last.index);
+  }
+  swap(left, right) {
+    const leftRow = this.expiryHeap[left];
+    const rightRow = this.expiryHeap[right];
+    this.expiryHeap[left] = rightRow;
+    this.expiryHeap[right] = leftRow;
+    rightRow.index = left;
+    leftRow.index = right;
+  }
+  moveUp(index) {
+    while (index > 0) {
+      const parent = Math.floor((index - 1) / 2);
+      if (this.expiryHeap[parent].retainUntilMs <= this.expiryHeap[index].retainUntilMs) {
+        break;
+      }
+      this.swap(parent, index);
+      index = parent;
+    }
+  }
+  moveDown(index) {
+    for (; ; ) {
+      const left = index * 2 + 1;
+      if (left >= this.expiryHeap.length) {
+        return;
+      }
+      const right = left + 1;
+      const child = right < this.expiryHeap.length && this.expiryHeap[right].retainUntilMs < this.expiryHeap[left].retainUntilMs ? right : left;
+      if (this.expiryHeap[index].retainUntilMs <= this.expiryHeap[child].retainUntilMs) {
+        return;
+      }
+      this.swap(index, child);
+      index = child;
+    }
+  }
+};
+function createMemoryAttestationStore(options = {}) {
+  return new MemoryAttestationStore(options);
+}
+
+// src/middleware.ts
+var MIDDLEWARE_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "publicOrigin",
+  "replayNamespace",
+  "publicPathPrefix",
+  "keyProvider",
+  "store",
+  "maxAgeMs",
+  "clockSkewMs",
+  "clusterClockGuardMs",
+  "headerName",
+  "now",
+  "operationTimeoutMs",
+  "onDiagnostic"
+]);
+var DEFAULT_OPERATION_TIMEOUT_MS = 5e3;
+var MIN_OPERATION_TIMEOUT_MS = 1;
+var MAX_OPERATION_TIMEOUT_MS = 6e4;
+var AttestationOperationTimeoutError = class extends Error {
+  name = "AttestationOperationTimeoutError";
+};
+function validatePublicPathPrefix(value) {
+  if (value === void 0) {
+    return "";
+  }
+  if (typeof value !== "string") {
+    throw new AttestationProtocolError("publicPathPrefix must be a string");
+  }
+  if (value === "") {
+    return "";
+  }
+  if (!value.startsWith("/")) {
+    throw new AttestationProtocolError("publicPathPrefix must start with /");
+  }
+  if (value.endsWith("/")) {
+    throw new AttestationProtocolError("publicPathPrefix must not end with /");
+  }
+  if (value.includes("?") || value.includes("#") || value.includes("\\")) {
+    throw new AttestationProtocolError("publicPathPrefix must not contain query, fragment, or backslashes");
+  }
+  for (const char of value) {
+    const code = char.codePointAt(0);
+    if (code <= 32 || code === 127) {
+      throw new AttestationProtocolError("publicPathPrefix must not contain controls or spaces");
+    }
+  }
+  return value;
+}
+function checkedNow(now) {
+  let value;
+  try {
+    value = now();
+  } catch {
+    throw new AttestationError("ATTESTATION_INTERNAL_ERROR");
+  }
+  try {
+    assertTimestampMs("nowMs", value);
+  } catch {
+    throw new AttestationError("ATTESTATION_INTERNAL_ERROR");
+  }
+  return value;
+}
+function withOperationTimeout(task, ms) {
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new AttestationOperationTimeoutError(`operation timed out after ${ms} ms`));
+    }, ms);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  });
+  const raced = Promise.race([task, timeout]);
+  return raced.finally(() => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  });
+}
+function emitDiagnostic(hook, error) {
+  if (hook === void 0) {
+    return;
+  }
+  try {
+    hook({ code: error.code, status: error.status });
+  } catch {
+  }
+}
+function sendControlledError(res, error, hooks) {
+  emitDiagnostic(hooks.onDiagnostic, error);
+  const target = res;
+  if (target?.headersSent === true) {
+    return;
+  }
+  if (typeof target.setHeader === "function") {
+    target.setHeader("Cache-Control", "no-store");
+  } else if (typeof target.set === "function") {
+    target.set("Cache-Control", "no-store");
+  }
+  if (error.code === "ATTESTATION_STALE_KEY") {
+    if (typeof target.setHeader === "function") {
+      target.setHeader("X-Attestation-Error", "stale-key");
+    } else if (typeof target.set === "function") {
+      target.set("X-Attestation-Error", "stale-key");
+    }
+  }
+  if (typeof target.status === "function") {
+    target.status(error.status).json({ code: error.code, message: error.message });
+  }
+}
+function extractRawHeader(req, lowerName) {
+  const record = req;
+  const headers = record.headers;
+  const rawHeaders = record.rawHeaders;
+  let rawCount = 0;
+  let firstRaw;
+  if (Array.isArray(rawHeaders)) {
+    for (let index = 0; index + 1 < rawHeaders.length; index += 2) {
+      const name = rawHeaders[index];
+      const value2 = rawHeaders[index + 1];
+      if (typeof name === "string" && name.toLowerCase() === lowerName) {
+        rawCount += 1;
+        if (firstRaw === void 0 && typeof value2 === "string") {
+          firstRaw = value2;
+        }
+      }
+    }
+  }
+  if (rawCount > 1) {
+    throw new AttestationError("ATTESTATION_MALFORMED");
+  }
+  const value = headers?.[lowerName];
+  if (value === void 0) {
+    if (rawCount === 1 && firstRaw !== void 0) {
+      return firstRaw;
+    }
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const filtered = value.filter((entry) => entry !== void 0);
+    if (filtered.length === 0) {
+      return void 0;
+    }
+    if (filtered.length > 1) {
+      throw new AttestationError("ATTESTATION_MALFORMED");
+    }
+    return filtered[0];
+  }
+  return value;
+}
+function resolveBodyDigestHex(req) {
+  const record = getAttestationBodyRecord(req);
+  if (record !== void 0) {
+    return record.digestHex;
+  }
+  const snapshot = req;
+  const headers = snapshot.headers ?? {};
+  const contentLengthRaw = headers["content-length"];
+  if (typeof contentLengthRaw === "string" && contentLengthRaw.trim() !== "") {
+    const parsed = Number(contentLengthRaw.trim());
+    if (Number.isSafeInteger(parsed) && parsed > 0) {
+      throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+    }
+    if (!Number.isSafeInteger(parsed) || parsed < 0) {
+      throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+    }
+  } else if (Array.isArray(contentLengthRaw) && contentLengthRaw.length > 0) {
+    for (const entry of contentLengthRaw) {
+      if (typeof entry === "string" && entry.trim() !== "") {
+        const parsed = Number(entry.trim());
+        if (!Number.isSafeInteger(parsed) || parsed !== 0) {
+          throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+        }
+      }
+    }
+  }
+  const transferEncoding = headers["transfer-encoding"];
+  if (typeof transferEncoding === "string" && transferEncoding.trim() !== "") {
+    throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+  }
+  if (Array.isArray(transferEncoding) && transferEncoding.length > 0) {
+    const nonEmpty = transferEncoding.some((entry) => typeof entry === "string" && entry.trim() !== "");
+    if (nonEmpty) {
+      throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+    }
+  }
+  const body = snapshot.body;
+  if (body !== void 0 && body !== null) {
+    if (typeof body === "string" && body.length > 0) {
+      throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(body) && body.length > 0) {
+      throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+    }
+    if (body instanceof Uint8Array && body.length > 0) {
+      throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+    }
+    if (Array.isArray(body) && body.length > 0) {
+      throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+    }
+    if (typeof body === "object" && !Array.isArray(body)) {
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) {
+      } else if (!(body instanceof Uint8Array)) {
+        const keys = Object.keys(body);
+        if (keys.length > 0) {
+          throw new AttestationError("ATTESTATION_BODY_CAPTURE_REQUIRED");
+        }
+      }
+    }
+  }
+  return EMPTY_BODY_SHA256_HEX;
+}
+function resolveConfig(options) {
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new AttestationProtocolError("attestation middleware options must be an object");
+  }
+  for (const key of Object.keys(options)) {
+    if (!MIDDLEWARE_OPTION_KEYS.has(key)) {
+      throw new AttestationProtocolError(`unknown attestation middleware option ${key}`);
+    }
+  }
+  validatePublicOrigin(options.publicOrigin);
+  validateReplayNamespace(options.replayNamespace);
+  const publicPathPrefix = validatePublicPathPrefix(options.publicPathPrefix);
+  const keyProvider = options.keyProvider;
+  if (keyProvider === null || typeof keyProvider !== "object" || typeof keyProvider.getSnapshot !== "function") {
+    throw new AttestationProtocolError("attestation middleware keyProvider must expose getSnapshot()");
+  }
+  const store = options.store;
+  if (store === null || typeof store !== "object" || typeof store.reserve !== "function") {
+    throw new AttestationProtocolError("attestation middleware store must expose reserve()");
+  }
+  const policy = resolveTimePolicy({
+    ...options.maxAgeMs === void 0 ? {} : { maxAgeMs: options.maxAgeMs },
+    ...options.clockSkewMs === void 0 ? {} : { clockSkewMs: options.clockSkewMs },
+    ...options.clusterClockGuardMs === void 0 ? {} : { clusterClockGuardMs: options.clusterClockGuardMs }
+  });
+  const headerName = options.headerName ?? DEFAULT_ATTESTATION_HEADER;
+  validateHeaderName(headerName);
+  const now = options.now ?? Date.now;
+  if (typeof now !== "function") {
+    throw new AttestationProtocolError("attestation middleware now must be a function");
+  }
+  const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+  if (!Number.isSafeInteger(operationTimeoutMs) || operationTimeoutMs < MIN_OPERATION_TIMEOUT_MS || operationTimeoutMs > MAX_OPERATION_TIMEOUT_MS) {
+    throw new AttestationProtocolError(
+      `operationTimeoutMs must be a safe integer in [${MIN_OPERATION_TIMEOUT_MS}, ${MAX_OPERATION_TIMEOUT_MS}]`
+    );
+  }
+  const onDiagnostic = options.onDiagnostic;
+  if (onDiagnostic !== void 0 && typeof onDiagnostic !== "function") {
+    throw new AttestationProtocolError("attestation middleware onDiagnostic must be a function");
+  }
+  return Object.freeze({
+    publicOrigin: options.publicOrigin,
+    replayNamespace: options.replayNamespace,
+    publicPathPrefix,
+    keyProvider,
+    store,
+    policy,
+    headerName,
+    headerNameLower: headerName.toLowerCase(),
+    now,
+    operationTimeoutMs,
+    onDiagnostic
+  });
+}
+function createRequestAttestationMiddleware(options) {
+  const config = resolveConfig(options);
+  const middleware = (req, res, next) => {
+    void Promise.resolve().then(async () => {
+      let nowMs = checkedNow(config.now);
+      let headerValue;
+      try {
+        headerValue = extractRawHeader(req, config.headerNameLower);
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendControlledError(res, error, config);
+          return;
+        }
+        throw error;
+      }
+      let snapshotRaw;
+      try {
+        const pending = config.keyProvider.getSnapshot();
+        snapshotRaw = await withOperationTimeout(Promise.resolve(pending), config.operationTimeoutMs);
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendControlledError(res, error, config);
+          return;
+        }
+        sendControlledError(res, new AttestationError("ATTESTATION_KEYS_UNAVAILABLE"), config);
+        return;
+      }
+      let snapshot;
+      try {
+        snapshot = copyAttestationSnapshot(snapshotRaw);
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendControlledError(res, error, config);
+          return;
+        }
+        sendControlledError(res, new AttestationError("ATTESTATION_KEYS_UNAVAILABLE"), config);
+        return;
+      }
+      const record = req;
+      const originalUrl = typeof record.originalUrl === "string" ? record.originalUrl : record.url;
+      const contentTypeHeader = record.headers?.["content-type"] ?? void 0;
+      const contentEncodingHeader = record.headers?.["content-encoding"] ?? void 0;
+      let bodyDigestHex;
+      try {
+        bodyDigestHex = resolveBodyDigestHex(req);
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendControlledError(res, error, config);
+          return;
+        }
+        throw error;
+      }
+      let verified;
+      try {
+        verified = verifyAttestationProof({
+          headerValue,
+          method: record.method,
+          originalUrl,
+          publicPathPrefix: config.publicPathPrefix,
+          contentTypeHeader,
+          contentEncodingHeader,
+          bodyDigestHex,
+          snapshot,
+          nowMs,
+          policy: config.policy,
+          replayNamespace: config.replayNamespace,
+          publicOrigin: config.publicOrigin
+        });
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendControlledError(res, error, config);
+          return;
+        }
+        sendControlledError(res, new AttestationError("ATTESTATION_INTERNAL_ERROR"), config);
+        return;
+      }
+      nowMs = checkedNow(config.now);
+      let rechecked;
+      try {
+        rechecked = checkProofTiming({
+          timestampMs: verified.timestampMs,
+          nowMs,
+          keyEntry: verified.keyEntry,
+          policy: config.policy
+        });
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendControlledError(res, error, config);
+          return;
+        }
+        sendControlledError(res, new AttestationError("ATTESTATION_INTERNAL_ERROR"), config);
+        return;
+      }
+      const retainUntilMs = rechecked.retainUntilMs;
+      if (retainUntilMs === null || !Number.isSafeInteger(retainUntilMs)) {
+        sendControlledError(res, new AttestationError("ATTESTATION_EXPIRED"), config);
+        return;
+      }
+      let reserveResult;
+      try {
+        const pending = config.store.reserve({
+          replayKey: verified.replayKey,
+          retainUntilMs
+        });
+        reserveResult = await withOperationTimeout(Promise.resolve(pending), config.operationTimeoutMs);
+      } catch (error) {
+        if (error instanceof AttestationCapacityError) {
+          sendControlledError(res, new AttestationError("ATTESTATION_REPLAY_UNAVAILABLE"), config);
+          return;
+        }
+        sendControlledError(res, new AttestationError("ATTESTATION_REPLAY_UNAVAILABLE"), config);
+        return;
+      }
+      if (reserveResult === "duplicate") {
+        sendControlledError(res, new AttestationError("ATTESTATION_REPLAY"), config);
+        return;
+      }
+      if (reserveResult === "expired") {
+        sendControlledError(res, new AttestationError("ATTESTATION_EXPIRED"), config);
+        return;
+      }
+      if (reserveResult !== "reserved") {
+        sendControlledError(res, new AttestationError("ATTESTATION_REPLAY_UNAVAILABLE"), config);
+        return;
+      }
+      nowMs = checkedNow(config.now);
+      try {
+        checkProofTiming({
+          timestampMs: verified.timestampMs,
+          nowMs,
+          keyEntry: verified.keyEntry,
+          policy: config.policy
+        });
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendControlledError(res, error, config);
+          return;
+        }
+        sendControlledError(res, new AttestationError("ATTESTATION_INTERNAL_ERROR"), config);
+        return;
+      }
+      next();
+    }).catch((error) => {
+      if (error instanceof AttestationError) {
+        const target2 = res;
+        if (target2?.headersSent !== true) {
+          sendControlledError(res, error, config);
+        }
+        return;
+      }
+      const target = res;
+      if (target?.headersSent === true) {
+        try {
+          next(error);
+        } catch {
+        }
+        return;
+      }
+      sendControlledError(res, new AttestationError("ATTESTATION_INTERNAL_ERROR"), config);
+    });
+  };
+  return middleware;
+}
+
+// src/stores/redis-script.ts
+var import_node_crypto3 = require("crypto");
+var RESERVE_ATTESTATION_SCRIPT = `
+local function finiteNumber(value)
+  return type(value) == 'number' and value == value and value > -math.huge and value < math.huge
+end
+local function serverNow()
+  local time = redis.call('TIME')
+  return tonumber(time[1]) * 1000 + math.floor(tonumber(time[2]) / 1000)
+end
+local retainUntil = tonumber(ARGV[2])
+if not finiteNumber(retainUntil) or retainUntil ~= math.floor(retainUntil)
+  or retainUntil < 0 or retainUntil > 9007199254740991 then
+  return 4
+end
+local maxEntries = tonumber(ARGV[3])
+if not finiteNumber(maxEntries) or maxEntries ~= math.floor(maxEntries)
+  or maxEntries <= 0 or maxEntries > 9007199254740991 then
+  return 4
+end
+local now = serverNow()
+if retainUntil <= now then
+  return 2
+end
+if retainUntil - now > 240000 then
+  return 4
+end
+local keyType = redis.call('TYPE', KEYS[1])['ok']
+if keyType ~= 'none' and keyType ~= 'zset' then
+  error('Attestation Redis replay key has unexpected type')
+end
+local existing = redis.call('ZSCORE', KEYS[1], ARGV[1])
+if existing ~= false and tonumber(existing) > now then
+  return 0
+end
+local expired = redis.call('ZRANGEBYSCORE', KEYS[1], '-inf', now, 'LIMIT', 0, 64)
+if #expired > 0 then
+  redis.call('ZREM', KEYS[1], unpack(expired))
+end
+if existing ~= false then
+  redis.call('ZREM', KEYS[1], ARGV[1])
+end
+if redis.call('ZCARD', KEYS[1]) >= maxEntries then
+  return 3
+end
+redis.call('ZADD', KEYS[1], retainUntil, ARGV[1])
+local last = redis.call('ZREVRANGE', KEYS[1], 0, 0, 'WITHSCORES')
+redis.call('PEXPIREAT', KEYS[1], last[2])
+return 1
+`;
+function buildReserveAttestationCommand(ledgerKey, replayKey, retainUntilMs, maxEntries) {
+  return ["EVAL", RESERVE_ATTESTATION_SCRIPT, "1", ledgerKey, replayKey, String(retainUntilMs), String(maxEntries)];
+}
+function scriptSha1(script) {
+  return (0, import_node_crypto3.createHash)("sha1").update(script).digest("hex");
+}
+var NOSCRIPT_ERROR_PREFIX = "NOSCRIPT";
+function isNoScriptError(error) {
+  if (error instanceof Error) {
+    return error.message.startsWith(NOSCRIPT_ERROR_PREFIX);
+  }
+  if (typeof error === "string") {
+    return error.startsWith(NOSCRIPT_ERROR_PREFIX);
+  }
+  return false;
+}
+var RedisScriptRunner = class {
+  client;
+  digests = /* @__PURE__ */ new Map();
+  constructor(client) {
+    this.client = client;
+  }
+  /** Drop cached digests (e.g. after a deliberate reconnect known to flush). */
+  reset() {
+    this.digests.clear();
+  }
+  /**
+   * Execute an `EVAL`-form command via cached `EVALSHA`. The leading `EVAL`
+   * and script body are replaced with `EVALSHA` + digest; the remaining
+   * positional layout (key count, keys, args) is preserved exactly.
+   */
+  async run(command) {
+    if (command[0] !== "EVAL" || typeof command[1] !== "string" || typeof command[2] !== "string") {
+      throw new Error("RedisScriptRunner.run expects an EVAL-form command.");
+    }
+    const script = command[1];
+    const tail = command.slice(2);
+    return this.runDigest(script, tail);
+  }
+  async runDigest(script, tail) {
+    let digest = this.digests.get(script);
+    if (!digest) {
+      digest = scriptSha1(script);
+      this.digests.set(script, digest);
+    }
+    try {
+      return await this.client.sendCommand(["EVALSHA", digest, ...tail]);
+    } catch (error) {
+      if (!isNoScriptError(error)) {
+        throw error;
+      }
+      const loaded = await this.client.sendCommand(["SCRIPT", "LOAD", script]);
+      if (typeof loaded === "string" && loaded.length > 0) {
+        digest = loaded;
+        this.digests.set(script, digest);
+      }
+      return this.client.sendCommand(["EVALSHA", digest, ...tail]);
+    }
+  }
+  /** Exposed for tests: the digest the runner would currently send. */
+  digestFor(script) {
+    return this.digests.get(script) ?? scriptSha1(script);
+  }
+};
+
+// src/stores/redis.ts
+var REDIS_ATTESTATION_STORE_DEFAULT_KEY_PREFIX = "wtt-attestation";
+var REDIS_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES = 5e4;
+var LEDGER_KEY_SUFFIX = "attestation-proofs";
+var STORE_OPTION_KEYS2 = /* @__PURE__ */ new Set(["client", "keyPrefix", "maxEntries"]);
+var AttestationRedisStoreError = class extends Error {
+  name = "AttestationRedisStoreError";
+  constructor(message = "Attestation Redis replay store is unavailable.") {
+    super(message);
+  }
+};
+function ledgerKeyFor(keyPrefix) {
+  return `${keyPrefix}:${LEDGER_KEY_SUFFIX}`;
+}
+var RedisAttestationStore = class {
+  client;
+  ledgerKey;
+  maxEntries;
+  runner;
+  constructor(options) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+      throw new AttestationProtocolError("redis attestation store options must be an object");
+    }
+    for (const key of Object.keys(options)) {
+      if (!STORE_OPTION_KEYS2.has(key)) {
+        throw new AttestationProtocolError(`unknown redis attestation store option ${key}`);
+      }
+    }
+    const client = options.client;
+    if (client === null || typeof client !== "object" || typeof client.sendCommand !== "function") {
+      throw new AttestationProtocolError("redis attestation store client must expose sendCommand()");
+    }
+    const keyPrefix = options.keyPrefix === void 0 ? REDIS_ATTESTATION_STORE_DEFAULT_KEY_PREFIX : options.keyPrefix;
+    if (typeof keyPrefix !== "string" || keyPrefix.length === 0 || keyPrefix.length > 256) {
+      throw new AttestationProtocolError("redis attestation store keyPrefix must be a 1-256 character string");
+    }
+    const maxEntries = options.maxEntries === void 0 ? REDIS_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES : options.maxEntries;
+    if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0) {
+      throw new AttestationProtocolError("redis attestation store maxEntries must be a positive safe integer");
+    }
+    this.client = client;
+    this.ledgerKey = ledgerKeyFor(keyPrefix);
+    this.maxEntries = maxEntries;
+    this.runner = new RedisScriptRunner(this.client);
+  }
+  async reserve(input) {
+    if (input === null || typeof input !== "object" || Array.isArray(input)) {
+      throw new AttestationProtocolError("attestation store reserve input must be an object");
+    }
+    const record = input;
+    const replayKey = record.replayKey;
+    const retainUntilMs = record.retainUntilMs ?? record.retainUntil;
+    validateReplayKey(replayKey);
+    if (retainUntilMs === void 0) {
+      throw new AttestationProtocolError("retainUntilMs must be a non-negative safe integer");
+    }
+    assertTimestampMs("retainUntilMs", retainUntilMs);
+    const replayKeySnapshot = replayKey;
+    const retainUntilSnapshot = retainUntilMs;
+    const ledgerKey = this.ledgerKey;
+    const maxEntries = this.maxEntries;
+    let reply;
+    try {
+      reply = await this.runner.run(
+        buildReserveAttestationCommand(ledgerKey, replayKeySnapshot, retainUntilSnapshot, maxEntries)
+      );
+    } catch (error) {
+      if (error instanceof AttestationCapacityError || error instanceof AttestationProtocolError) {
+        throw error;
+      }
+      if (error instanceof AttestationRedisStoreError) {
+        throw error;
+      }
+      throw new AttestationRedisStoreError(
+        error instanceof Error ? `Attestation Redis reservation failed: ${error.message}` : "Attestation Redis reservation failed."
+      );
+    }
+    if (reply === 1 || reply === "1") {
+      return "reserved";
+    }
+    if (reply === 0 || reply === "0") {
+      return "duplicate";
+    }
+    if (reply === 2 || reply === "2") {
+      return "expired";
+    }
+    if (reply === 3 || reply === "3") {
+      throw new AttestationCapacityError();
+    }
+    if (reply === 4 || reply === "4") {
+      throw new AttestationProtocolError(
+        "retainUntilMs exceeds the 240000 ms global retention cap or is not a safe live deadline"
+      );
+    }
+    throw new AttestationRedisStoreError("Attestation Redis store received an unexpected script reply.");
+  }
+};
+function createRedisAttestationStore(options) {
+  return new RedisAttestationStore(options);
+}
+
+// src/stores/mongodb.ts
+var MONGO_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES = 5e4;
+var MONGO_ATTESTATION_STORE_DEFAULT_PROOFS_COLLECTION = "attestation_proofs";
+var MONGO_ATTESTATION_STORE_DEFAULT_CAPACITY_COLLECTION = "attestation_replay_capacity";
+var EXPIRY_SWEEP_BATCH_SIZE2 = 64;
+var CAPACITY_ID = "capacity";
+var STORE_OPTION_KEYS3 = /* @__PURE__ */ new Set([
+  "db",
+  "proofsCollectionName",
+  "capacityCollectionName",
+  "maxEntries",
+  "now"
+]);
+var reservationId = (replayKey) => `proof:${replayKey}`;
+var AttestationMongoStoreError = class extends Error {
+  name = "AttestationMongoStoreError";
+  constructor(message = "Attestation MongoDB replay store is unavailable.") {
+    super(message);
+  }
+};
+function validateCollectionName(role, name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new AttestationProtocolError(`mongo attestation store ${role} collection name must be a non-empty string`);
+  }
+  if (name.includes("\0")) {
+    throw new AttestationProtocolError(`mongo attestation store ${role} collection name must not contain null bytes`);
+  }
+  if (name.startsWith("system.")) {
+    throw new AttestationProtocolError(
+      `mongo attestation store ${role} collection name must not use the reserved system namespace`
+    );
+  }
+  if (name.includes("$")) {
+    throw new AttestationProtocolError(`mongo attestation store ${role} collection name must not contain '$'`);
+  }
+}
+function unwrapFindOneAndUpdate(reply) {
+  if (reply !== null && typeof reply === "object" && "value" in reply && "ok" in reply) {
+    return reply.value;
+  }
+  return reply;
+}
+function deletedCountOf(reply) {
+  if (reply !== null && typeof reply === "object" && "deletedCount" in reply) {
+    const count = reply.deletedCount;
+    if (typeof count === "number" && Number.isSafeInteger(count) && count >= 0) {
+      return count;
+    }
+  }
+  return 0;
+}
+var MongoAttestationStore = class {
+  db;
+  proofs;
+  capacity;
+  maxEntries;
+  now;
+  constructor(options) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+      throw new AttestationProtocolError("mongo attestation store options must be an object");
+    }
+    for (const key of Object.keys(options)) {
+      if (!STORE_OPTION_KEYS3.has(key)) {
+        throw new AttestationProtocolError(`unknown mongo attestation store option ${key}`);
+      }
+    }
+    const db = options.db;
+    if (db === null || typeof db !== "object" || typeof db.collection !== "function" || db.client === null || typeof db.client !== "object" || typeof db.client.startSession !== "function") {
+      throw new AttestationProtocolError(
+        "mongo attestation store db must expose collection() and client.startSession()"
+      );
+    }
+    const proofsCollectionName = options.proofsCollectionName === void 0 ? MONGO_ATTESTATION_STORE_DEFAULT_PROOFS_COLLECTION : options.proofsCollectionName;
+    const capacityCollectionName = options.capacityCollectionName === void 0 ? MONGO_ATTESTATION_STORE_DEFAULT_CAPACITY_COLLECTION : options.capacityCollectionName;
+    validateCollectionName("proofs", proofsCollectionName);
+    validateCollectionName("capacity", capacityCollectionName);
+    if (proofsCollectionName === capacityCollectionName) {
+      throw new AttestationProtocolError("mongo attestation store proofs and capacity collections must be distinct");
+    }
+    const maxEntries = options.maxEntries === void 0 ? MONGO_ATTESTATION_STORE_DEFAULT_MAX_ENTRIES : options.maxEntries;
+    if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0) {
+      throw new AttestationProtocolError("mongo attestation store maxEntries must be a positive safe integer");
+    }
+    const now = options.now === void 0 ? () => Date.now() : options.now;
+    if (typeof now !== "function") {
+      throw new AttestationProtocolError("mongo attestation store now must be a function");
+    }
+    const liveDb = db;
+    let proofs;
+    let capacity;
+    try {
+      proofs = liveDb.collection(proofsCollectionName);
+      capacity = liveDb.collection(capacityCollectionName);
+    } catch {
+      throw new AttestationProtocolError("mongo attestation store db.collection() failed");
+    }
+    if (proofs === null || typeof proofs !== "object" || capacity === null || typeof capacity !== "object") {
+      throw new AttestationProtocolError("mongo attestation store db.collection() failed");
+    }
+    this.db = liveDb;
+    this.proofs = proofs;
+    this.capacity = capacity;
+    this.maxEntries = maxEntries;
+    this.now = now;
+  }
+  async reserve(input) {
+    if (input === null || typeof input !== "object" || Array.isArray(input)) {
+      throw new AttestationProtocolError("attestation store reserve input must be an object");
+    }
+    const record = input;
+    const replayKey = record.replayKey;
+    const retainUntilMs = record.retainUntilMs ?? record.retainUntil;
+    const nowMs = this.now();
+    if (!Number.isSafeInteger(nowMs) || nowMs < 0) {
+      throw new AttestationProtocolError("attestation store clock must return a non-negative safe integer");
+    }
+    validateReplayKey(replayKey);
+    if (retainUntilMs === void 0) {
+      throw new AttestationProtocolError("retainUntilMs must be a non-negative safe integer");
+    }
+    assertTimestampMs("retainUntilMs", retainUntilMs);
+    if (retainUntilMs <= nowMs) {
+      return "expired";
+    }
+    if (retainUntilMs - nowMs > GLOBAL_MAX_RETENTION_MS) {
+      throw new AttestationProtocolError(
+        `retainUntilMs exceeds the ${GLOBAL_MAX_RETENTION_MS} ms global retention cap`
+      );
+    }
+    const replayKeySnapshot = replayKey;
+    const retainUntilSnapshot = retainUntilMs;
+    let session;
+    try {
+      session = this.db.client.startSession();
+    } catch (error) {
+      throw new AttestationMongoStoreError(
+        error instanceof Error ? `Attestation MongoDB session failed: ${error.message}` : "Attestation MongoDB session failed."
+      );
+    }
+    try {
+      const result = await session.withTransaction(
+        async () => {
+          const nowTx = this.now();
+          if (!Number.isSafeInteger(nowTx) || nowTx < 0) {
+            throw new AttestationProtocolError("attestation store clock must return a non-negative safe integer");
+          }
+          if (retainUntilSnapshot <= nowTx) {
+            return "expired";
+          }
+          if (retainUntilSnapshot - nowTx > GLOBAL_MAX_RETENTION_MS) {
+            throw new AttestationProtocolError(
+              `retainUntilMs exceeds the ${GLOBAL_MAX_RETENTION_MS} ms global retention cap`
+            );
+          }
+          const capacityRaw = unwrapFindOneAndUpdate(
+            await this.capacity.findOneAndUpdate(
+              { _id: CAPACITY_ID },
+              {
+                // Note: `$inc` must not share `revision` with `$setOnInsert`
+                // (MongoDB rejects the conflicting path on insert); `$inc`
+                // creates `revision: 1` for a fresh capacity row.
+                $inc: { revision: 1 },
+                $setOnInsert: {
+                  kind: "capacity",
+                  entries: 0,
+                  maxEntries: this.maxEntries,
+                  proofsCollectionName: this.proofs.collectionName
+                }
+              },
+              { session, returnDocument: "after", upsert: true }
+            )
+          );
+          this.validateCapacity(capacityRaw);
+          const capacityDoc = capacityRaw;
+          const proofRaw = await this.proofs.findOne({ _id: replayKeySnapshot }, { session });
+          if (proofRaw !== null) {
+            this.validateProof(proofRaw, replayKeySnapshot);
+            if (proofRaw.retainUntilMs > nowTx) {
+              return "duplicate";
+            }
+          }
+          const ledgerId = reservationId(replayKeySnapshot);
+          const existingRaw = await this.capacity.findOne({ _id: ledgerId }, { session });
+          if (existingRaw !== null) {
+            this.validateReservation(existingRaw);
+            if (existingRaw.retainUntilMs > nowTx) {
+              return "duplicate";
+            }
+          }
+          let removed = 0;
+          if (existingRaw !== null) {
+            removed += deletedCountOf(await this.capacity.deleteOne({ _id: ledgerId }, { session }));
+          }
+          const expiredRows = await this.capacity.find({ kind: "reservation", retainUntilMs: { $lte: nowTx } }, { session }).sort({ retainUntilMs: 1 }).limit(EXPIRY_SWEEP_BATCH_SIZE2).toArray();
+          if (!Array.isArray(expiredRows)) {
+            throw new AttestationMongoStoreError("Attestation MongoDB expiry accounting is malformed.");
+          }
+          for (const row of expiredRows) {
+            this.validateReservation(row);
+          }
+          if (expiredRows.length > 0) {
+            const ids = expiredRows.map((row) => row._id);
+            const replayKeys = expiredRows.map((row) => row.replayKey);
+            removed += deletedCountOf(
+              await this.capacity.deleteMany({ _id: { $in: ids }, kind: "reservation" }, { session })
+            );
+            await this.proofs.deleteMany({ _id: { $in: replayKeys }, retainUntilMs: { $lte: nowTx } }, { session });
+          }
+          const entries = capacityDoc.entries - removed;
+          if (!Number.isSafeInteger(entries) || entries < 0) {
+            throw new AttestationMongoStoreError("Attestation MongoDB replay capacity accounting is inconsistent.");
+          }
+          if (entries >= this.maxEntries) {
+            throw new AttestationCapacityError();
+          }
+          await this.proofs.replaceOne(
+            { _id: replayKeySnapshot },
+            { _id: replayKeySnapshot, retainUntilMs: retainUntilSnapshot },
+            { upsert: true, session }
+          );
+          await this.capacity.insertOne(
+            {
+              _id: ledgerId,
+              kind: "reservation",
+              replayKey: replayKeySnapshot,
+              retainUntilMs: retainUntilSnapshot
+            },
+            { session }
+          );
+          await this.capacity.updateOne({ _id: CAPACITY_ID }, { $set: { entries: entries + 1 } }, { session });
+          return "reserved";
+        },
+        { readConcern: { level: "snapshot" } }
+      );
+      if (result === "reserved" || result === "duplicate" || result === "expired") {
+        return result;
+      }
+      throw new AttestationMongoStoreError("Attestation MongoDB reservation did not commit.");
+    } catch (error) {
+      if (error instanceof AttestationCapacityError || error instanceof AttestationProtocolError || error instanceof AttestationMongoStoreError) {
+        throw error;
+      }
+      throw new AttestationMongoStoreError(
+        error instanceof Error ? `Attestation MongoDB reservation failed: ${error.message}` : "Attestation MongoDB reservation failed."
+      );
+    } finally {
+      await session.endSession();
+    }
+  }
+  validateCapacity(row) {
+    if (row === null || typeof row !== "object" || row._id !== CAPACITY_ID || row.kind !== "capacity" || row.maxEntries !== this.maxEntries || row.proofsCollectionName !== this.proofs.collectionName || !Number.isSafeInteger(row.entries) || row.entries < 0 || row.entries > this.maxEntries || !Number.isSafeInteger(row.revision)) {
+      throw new AttestationMongoStoreError(
+        "Attestation MongoDB replay capacity configuration/accounting is inconsistent."
+      );
+    }
+  }
+  validateReservation(row) {
+    if (row.kind !== "reservation" || typeof row.replayKey !== "string" || row._id !== reservationId(row.replayKey) || !Number.isSafeInteger(row.retainUntilMs) || row.retainUntilMs < 0) {
+      throw new AttestationMongoStoreError("Attestation MongoDB replay expiry accounting is malformed.");
+    }
+  }
+  validateProof(row, replayKey) {
+    if (row._id !== replayKey || !Number.isSafeInteger(row.retainUntilMs) || row.retainUntilMs < 0) {
+      throw new AttestationMongoStoreError("Attestation MongoDB replay proof is malformed.");
+    }
+  }
+};
+function createMongoAttestationStore(options) {
+  return new MongoAttestationStore(options);
+}
+
+// src/keys.ts
+var import_node_crypto4 = require("crypto");
+var MAX_RETAINED_ATTESTATION_KEYS = 16;
+var SNAPSHOT_OPTION_KEYS = /* @__PURE__ */ new Set(["currentKeyId", "keys"]);
+var KEY_ENTRY_KEYS = /* @__PURE__ */ new Set(["keyId", "key", "acceptFrom", "acceptUntil"]);
+var KEY_WINDOW_KEYS = /* @__PURE__ */ new Set(["acceptFrom", "acceptUntil"]);
+function bytesEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function copyKeyEntry(entry) {
+  const keyCopy = new Uint8Array(entry.key);
+  return Object.freeze({
+    keyId: entry.keyId,
+    key: keyCopy,
+    acceptFrom: entry.acceptFrom,
+    acceptUntil: entry.acceptUntil
+  });
+}
+function copySnapshot(snapshot) {
+  const keys = snapshot.keys.map(copyKeyEntry);
+  return Object.freeze({
+    currentKeyId: snapshot.currentKeyId,
+    keys: Object.freeze(keys)
+  });
+}
+function assertValidSnapshotShape(snapshot) {
+  if (snapshot === null || typeof snapshot !== "object" || Array.isArray(snapshot)) {
+    throw new AttestationProtocolError("key snapshot must be an object");
+  }
+  for (const key of Object.keys(snapshot)) {
+    if (!SNAPSHOT_OPTION_KEYS.has(key)) {
+      throw new AttestationProtocolError(`unknown key snapshot option ${key}`);
+    }
+  }
+  const record = snapshot;
+  validateKeyId(record.currentKeyId);
+  if (!Array.isArray(record.keys)) {
+    throw new AttestationProtocolError("key snapshot keys must be an array");
+  }
+  if (record.keys.length === 0 || record.keys.length > MAX_RETAINED_ATTESTATION_KEYS) {
+    throw new AttestationProtocolError(`key snapshot must retain 1-${MAX_RETAINED_ATTESTATION_KEYS} keys`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of record.keys) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new AttestationProtocolError("key snapshot entry must be an object");
+    }
+    for (const key of Object.keys(entry)) {
+      if (!KEY_ENTRY_KEYS.has(key)) {
+        throw new AttestationProtocolError(`unknown key snapshot entry option ${key}`);
+      }
+    }
+    const row = entry;
+    validateKeyId(row.keyId);
+    validateKeyBytes(row.key);
+    assertTimestampMs("acceptFrom", row.acceptFrom);
+    assertTimestampMs("acceptUntil", row.acceptUntil);
+    const acceptFrom = row.acceptFrom;
+    const acceptUntil = row.acceptUntil;
+    if (acceptFrom >= acceptUntil) {
+      throw new AttestationProtocolError("key acceptance window must satisfy acceptFrom < acceptUntil");
+    }
+    const keyId = row.keyId;
+    if (seen.has(keyId)) {
+      throw new AttestationProtocolError("key snapshot keyIds must be unique");
+    }
+    seen.add(keyId);
+  }
+  if (!seen.has(record.currentKeyId)) {
+    throw new AttestationProtocolError("key snapshot currentKeyId must name a present entry");
+  }
+}
+function ownSnapshot(input) {
+  assertValidSnapshotShape(input);
+  const keys = input.keys.map(
+    (entry) => Object.freeze({
+      keyId: entry.keyId,
+      key: new Uint8Array(entry.key),
+      acceptFrom: entry.acceptFrom,
+      acceptUntil: entry.acceptUntil
+    })
+  );
+  return Object.freeze({
+    currentKeyId: input.currentKeyId,
+    keys: Object.freeze(keys)
+  });
+}
+function generateAttestationKey(keyId, window) {
+  validateKeyId(keyId);
+  if (window === null || typeof window !== "object" || Array.isArray(window)) {
+    throw new AttestationProtocolError("key window must be an object");
+  }
+  for (const key2 of Object.keys(window)) {
+    if (!KEY_WINDOW_KEYS.has(key2)) {
+      throw new AttestationProtocolError(`unknown key window option ${key2}`);
+    }
+  }
+  assertTimestampMs("acceptFrom", window.acceptFrom);
+  assertTimestampMs("acceptUntil", window.acceptUntil);
+  if (window.acceptFrom >= window.acceptUntil) {
+    throw new AttestationProtocolError("key acceptance window must satisfy acceptFrom < acceptUntil");
+  }
+  const key = new Uint8Array((0, import_node_crypto4.randomBytes)(32));
+  return Object.freeze({
+    keyId,
+    key,
+    acceptFrom: window.acceptFrom,
+    acceptUntil: window.acceptUntil
+  });
+}
+function createStaticKeyProvider(snapshot) {
+  const owned = ownSnapshot(snapshot);
+  const provider = {
+    getSnapshot() {
+      return copySnapshot(owned);
+    }
+  };
+  return Object.freeze(provider);
+}
+function createRotatingKeyProvider(snapshot) {
+  let current = ownSnapshot(snapshot);
+  function checkRemappingPreserved(previous, next) {
+    const previousById = /* @__PURE__ */ new Map();
+    for (const entry of previous.keys) {
+      previousById.set(entry.keyId, entry);
+    }
+    for (const entry of next.keys) {
+      const prior = previousById.get(entry.keyId);
+      if (prior === void 0) {
+        continue;
+      }
+      const nextKey = entry.key;
+      if (!bytesEqual(prior.key, nextKey)) {
+        throw new AttestationProtocolError(
+          `key snapshot must not remap retained keyId ${entry.keyId} to different key material`
+        );
+      }
+      if (prior.acceptFrom !== entry.acceptFrom || prior.acceptUntil !== entry.acceptUntil) {
+        throw new AttestationProtocolError(
+          `key snapshot must not remap retained keyId ${entry.keyId} to a different acceptance window`
+        );
+      }
+    }
+  }
+  const provider = {
+    getSnapshot() {
+      return copySnapshot(current);
+    },
+    replace(next) {
+      assertValidSnapshotShape(next);
+      checkRemappingPreserved(current, next);
+      current = ownSnapshot(next);
+    }
+  };
+  return Object.freeze(provider);
+}
+
+// src/signer-bundle.ts
+var import_express = require("express");
+
+// src/signer-assets.ts
+var import_node_crypto5 = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var import_node_url = require("url");
+var SIGNER_RUNTIME_BYTE_CAP = 524288;
+var SIGNER_KEY_MODULE_BYTE_CAP = 8192;
+var SIGNER_ASSET_METADATA_BYTE_CAP = 4096;
+var CONTENT_HASH_PATTERN = /^[0-9a-f]{64}$/;
+function isContentHash(value) {
+  return typeof value === "string" && CONTENT_HASH_PATTERN.test(value);
+}
+function sha256Hex(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new AttestationProtocolError("content hash input must be a Uint8Array");
+  }
+  return (0, import_node_crypto5.createHash)("sha256").update(bytes).digest("hex");
+}
+function dirFromStack() {
+  try {
+    const stack = new Error().stack;
+    if (typeof stack !== "string") {
+      return null;
+    }
+    for (const line of stack.split("\n")) {
+      const fileUrlMatch = /(file:\/\/[^\s:)]+)/.exec(line);
+      if (fileUrlMatch?.[1] !== void 0) {
+        try {
+          const filePath = (0, import_node_url.fileURLToPath)(new URL(fileUrlMatch[1]));
+          if (filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs")) {
+            return import_node_path.default.dirname(filePath);
+          }
+        } catch {
+          continue;
+        }
+      }
+      const pathMatch = /\((\/[^():]+\.m?[jt]s):\d+:\d+\)/.exec(line) ?? /at\s+(\/[^():\s]+\.m?[jt]s):\d+:\d+/.exec(line);
+      if (pathMatch?.[1] !== void 0) {
+        return import_node_path.default.dirname(pathMatch[1]);
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function currentFileCandidates() {
+  const candidates = [];
+  const stackDir = dirFromStack();
+  if (stackDir !== null) {
+    candidates.push(import_node_path.default.join(stackDir, "signer.mjs"));
+    candidates.push(import_node_path.default.join(stackDir, "..", "dist", "signer.mjs"));
+    candidates.push(import_node_path.default.join(stackDir, "dist", "signer.mjs"));
+  }
+  try {
+    const dirname = globalThis.__dirname;
+    if (typeof dirname === "string" && dirname.length > 0) {
+      candidates.push(import_node_path.default.join(dirname, "signer.mjs"));
+      candidates.push(import_node_path.default.join(dirname, "..", "dist", "signer.mjs"));
+    }
+  } catch {
+  }
+  try {
+    const filename = globalThis.__filename;
+    if (typeof filename === "string" && filename.length > 0) {
+      candidates.push(import_node_path.default.join(import_node_path.default.dirname(filename), "signer.mjs"));
+      candidates.push(import_node_path.default.join(import_node_path.default.dirname(filename), "..", "dist", "signer.mjs"));
+    }
+  } catch {
+  }
+  return candidates;
+}
+var cachedRuntimeBytes = null;
+var cachedRuntimeHash = null;
+function loadSignerRuntimeBytes() {
+  if (cachedRuntimeBytes !== null) {
+    return new Uint8Array(cachedRuntimeBytes);
+  }
+  const candidates = currentFileCandidates();
+  for (const candidate of candidates) {
+    try {
+      const read = (0, import_node_fs.readFileSync)(candidate);
+      if (read.length === 0 || read.length > SIGNER_RUNTIME_BYTE_CAP) {
+        throw new AttestationProtocolError(`signer runtime exceeds the ${SIGNER_RUNTIME_BYTE_CAP}-byte cap`);
+      }
+      const bytes = new Uint8Array(read.buffer.slice(read.byteOffset, read.byteOffset + read.byteLength));
+      cachedRuntimeBytes = bytes;
+      cachedRuntimeHash = sha256Hex(bytes);
+      return new Uint8Array(bytes);
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        continue;
+      }
+      if (error instanceof AttestationProtocolError) {
+        throw error;
+      }
+      continue;
+    }
+  }
+  throw new AttestationProtocolError(
+    `signer runtime (dist/signer.mjs sibling) could not be located${candidates.length > 0 ? ` (tried ${candidates.length} candidate path(s))` : ""}. Build the package before serving signer assets.`
+  );
+}
+function getSignerRuntimeAsset() {
+  const bytes = loadSignerRuntimeBytes();
+  const contentHash = cachedRuntimeHash ?? sha256Hex(bytes);
+  if (cachedRuntimeHash === null) {
+    cachedRuntimeHash = contentHash;
+  }
+  return {
+    bytes,
+    contentHash,
+    fileName: `runtime.${contentHash}.mjs`
+  };
+}
+function buildSignerKeyModuleSource(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new AttestationProtocolError("signer key module input must be an object");
+  }
+  const { keyId, key, publicOrigin, replayNamespace, runtimeFileName } = input;
+  if (typeof keyId !== "string" || typeof publicOrigin !== "string" || typeof replayNamespace !== "string") {
+    throw new AttestationProtocolError("signer key module fields must be strings");
+  }
+  if (!(key instanceof Uint8Array) || key.length !== 32) {
+    throw new AttestationProtocolError("signer key module key must be 32 bytes");
+  }
+  if (typeof runtimeFileName !== "string" || runtimeFileName.length === 0) {
+    throw new AttestationProtocolError("signer key module runtime file name must be a non-empty string");
+  }
+  if (runtimeFileName.includes("\0") || runtimeFileName.includes("\\")) {
+    throw new AttestationProtocolError("signer key module runtime file name is invalid");
+  }
+  const runtimeSpecifier = `./${runtimeFileName}`;
+  const lines = [
+    `import { createRequestSigner } from ${JSON.stringify(runtimeSpecifier)};`,
+    `const __attestationKeyBytes = new Uint8Array(${JSON.stringify(Array.from(key))});`,
+    `export const signer = createRequestSigner({`,
+    `  keyId: ${JSON.stringify(keyId)},`,
+    `  key: __attestationKeyBytes,`,
+    `  publicOrigin: ${JSON.stringify(publicOrigin)},`,
+    `  replayNamespace: ${JSON.stringify(replayNamespace)},`,
+    `});`,
+    ``
+  ];
+  return lines.join("\n");
+}
+function buildSignerKeyModuleBytes(input) {
+  const source = buildSignerKeyModuleSource({
+    keyId: input.entry.keyId,
+    key: input.entry.key,
+    publicOrigin: input.publicOrigin,
+    replayNamespace: input.replayNamespace,
+    runtimeFileName: input.runtimeFileName
+  });
+  if (utf8ByteLength(source) > SIGNER_KEY_MODULE_BYTE_CAP) {
+    throw new AttestationProtocolError(`signer key module exceeds the ${SIGNER_KEY_MODULE_BYTE_CAP}-byte cap`);
+  }
+  return utf8Encode(source);
+}
+function getSignerKeyModuleAsset(input) {
+  const bytes = buildSignerKeyModuleBytes(input);
+  const contentHash = sha256Hex(bytes);
+  return {
+    bytes,
+    contentHash,
+    fileName: `signer.${contentHash}.mjs`
+  };
+}
+
+// src/signer-bundle.ts
+var SIGNER_BUNDLE_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "publicOrigin",
+  "replayNamespace",
+  "keyProvider",
+  "basePath",
+  "publicPathPrefix",
+  "now",
+  "operationTimeoutMs"
+]);
+var DEFAULT_SIGNER_BASE_PATH = "/attestation";
+var DEFAULT_OPERATION_TIMEOUT_MS2 = 5e3;
+var MIN_OPERATION_TIMEOUT_MS2 = 1;
+var MAX_OPERATION_TIMEOUT_MS2 = 6e4;
+var SignerBundleOperationTimeoutError = class extends Error {
+  name = "SignerBundleOperationTimeoutError";
+};
+function validateBasePath(value) {
+  if (value === void 0) {
+    return DEFAULT_SIGNER_BASE_PATH;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw new AttestationProtocolError("signer bundle basePath must be a non-empty string");
+  }
+  if (!value.startsWith("/")) {
+    throw new AttestationProtocolError("signer bundle basePath must start with /");
+  }
+  if (value.length > 1 && value.endsWith("/")) {
+    throw new AttestationProtocolError("signer bundle basePath must not end with /");
+  }
+  if (value.includes("?") || value.includes("#") || value.includes("\\")) {
+    throw new AttestationProtocolError("signer bundle basePath must not contain query, fragment, or backslashes");
+  }
+  for (const char of value) {
+    const code = char.codePointAt(0);
+    if (code <= 32 || code === 127) {
+      throw new AttestationProtocolError("signer bundle basePath must not contain controls or spaces");
+    }
+  }
+  return value;
+}
+function validatePublicPathPrefix2(value) {
+  if (value === void 0) {
+    return "";
+  }
+  if (typeof value !== "string") {
+    throw new AttestationProtocolError("signer bundle publicPathPrefix must be a string");
+  }
+  if (value === "") {
+    return "";
+  }
+  if (!value.startsWith("/")) {
+    throw new AttestationProtocolError("signer bundle publicPathPrefix must start with /");
+  }
+  if (value.endsWith("/")) {
+    throw new AttestationProtocolError("signer bundle publicPathPrefix must not end with /");
+  }
+  if (value.includes("?") || value.includes("#") || value.includes("\\")) {
+    throw new AttestationProtocolError(
+      "signer bundle publicPathPrefix must not contain query, fragment, or backslashes"
+    );
+  }
+  for (const char of value) {
+    const code = char.codePointAt(0);
+    if (code <= 32 || code === 127) {
+      throw new AttestationProtocolError("signer bundle publicPathPrefix must not contain controls or spaces");
+    }
+  }
+  return value;
+}
+function checkedNow2(now) {
+  let value;
+  try {
+    value = now();
+  } catch {
+    throw new AttestationError("ATTESTATION_INTERNAL_ERROR");
+  }
+  try {
+    assertTimestampMs("nowMs", value);
+  } catch {
+    throw new AttestationError("ATTESTATION_INTERNAL_ERROR");
+  }
+  return value;
+}
+function withOperationTimeout2(task, ms) {
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new SignerBundleOperationTimeoutError(`operation timed out after ${ms} ms`));
+    }, ms);
+    const handle = timer;
+    if (typeof handle.unref === "function") {
+      handle.unref();
+    }
+  });
+  const raced = Promise.race([task, timeout]);
+  return raced.finally(() => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  });
+}
+function resolveConfig2(options) {
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new AttestationProtocolError("signer bundle router options must be an object");
+  }
+  for (const key of Object.keys(options)) {
+    if (!SIGNER_BUNDLE_OPTION_KEYS.has(key)) {
+      throw new AttestationProtocolError(`unknown signer bundle router option ${key}`);
+    }
+  }
+  validatePublicOrigin(options.publicOrigin);
+  validateReplayNamespace(options.replayNamespace);
+  const keyProvider = options.keyProvider;
+  if (keyProvider === null || typeof keyProvider !== "object" || typeof keyProvider.getSnapshot !== "function") {
+    throw new AttestationProtocolError("signer bundle router keyProvider must expose getSnapshot()");
+  }
+  const basePath = validateBasePath(options.basePath);
+  const publicPathPrefix = validatePublicPathPrefix2(options.publicPathPrefix);
+  const now = options.now ?? Date.now;
+  if (typeof now !== "function") {
+    throw new AttestationProtocolError("signer bundle router now must be a function");
+  }
+  const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS2;
+  if (!Number.isSafeInteger(operationTimeoutMs) || operationTimeoutMs < MIN_OPERATION_TIMEOUT_MS2 || operationTimeoutMs > MAX_OPERATION_TIMEOUT_MS2) {
+    throw new AttestationProtocolError(
+      `operationTimeoutMs must be a safe integer in [${MIN_OPERATION_TIMEOUT_MS2}, ${MAX_OPERATION_TIMEOUT_MS2}]`
+    );
+  }
+  return Object.freeze({
+    publicOrigin: options.publicOrigin,
+    replayNamespace: options.replayNamespace,
+    keyProvider,
+    basePath,
+    publicPathPrefix,
+    now,
+    operationTimeoutMs
+  });
+}
+function sendKeysUnavailable(res) {
+  const error = new AttestationError("ATTESTATION_KEYS_UNAVAILABLE");
+  res.set("Cache-Control", "no-store");
+  res.status(error.status).json({ code: error.code, message: error.message });
+}
+function sendInternalError(res) {
+  const error = new AttestationError("ATTESTATION_INTERNAL_ERROR");
+  try {
+    res.set("Cache-Control", "no-store");
+  } catch {
+  }
+  try {
+    res.status(error.status).json({ code: error.code, message: error.message });
+  } catch {
+  }
+}
+function sendAssetNotFound(res, gone) {
+  res.set("Cache-Control", "no-store");
+  if (gone) {
+    res.status(410).json({
+      code: "ATTESTATION_ASSET_GONE",
+      message: "Signer asset is no longer available."
+    });
+  } else {
+    res.status(404).json({
+      code: "ATTESTATION_ASSET_NOT_FOUND",
+      message: "Signer asset is not available."
+    });
+  }
+}
+function createSignerBundleRouter(options) {
+  const config = resolveConfig2(options);
+  const router = (0, import_express.Router)();
+  router.get("/signer-meta", (req, res) => {
+    void Promise.resolve().then(async () => {
+      let nowMs;
+      try {
+        nowMs = checkedNow2(config.now);
+      } catch (error) {
+        if (error instanceof AttestationError) {
+          sendInternalError(res);
+          return;
+        }
+        throw error;
+      }
+      let snapshotRaw;
+      try {
+        const pending = config.keyProvider.getSnapshot();
+        snapshotRaw = await withOperationTimeout2(Promise.resolve(pending), config.operationTimeoutMs);
+      } catch {
+        sendKeysUnavailable(res);
+        return;
+      }
+      let snapshot;
+      try {
+        snapshot = copyAttestationSnapshot(snapshotRaw);
+      } catch {
+        sendKeysUnavailable(res);
+        return;
+      }
+      const current = snapshot.keys.find((entry) => entry.keyId === snapshot.currentKeyId);
+      if (current === void 0) {
+        sendKeysUnavailable(res);
+        return;
+      }
+      if (!(current.acceptFrom <= nowMs && nowMs < current.acceptUntil)) {
+        sendKeysUnavailable(res);
+        return;
+      }
+      let runtimeFileName;
+      try {
+        const runtime = getSignerRuntimeAsset();
+        runtimeFileName = runtime.fileName;
+      } catch {
+        sendInternalError(res);
+        return;
+      }
+      let keyAsset;
+      try {
+        keyAsset = getSignerKeyModuleAsset({
+          entry: current,
+          publicOrigin: config.publicOrigin,
+          replayNamespace: config.replayNamespace,
+          runtimeFileName
+        });
+      } catch {
+        sendInternalError(res);
+        return;
+      }
+      const signerUrl = `${config.publicOrigin}${config.publicPathPrefix}${config.basePath}/signer.${keyAsset.contentHash}.mjs`;
+      const document = {
+        version: PROTOCOL_VERSION,
+        keyId: current.keyId,
+        signerUrl,
+        publicOrigin: config.publicOrigin,
+        replayNamespace: config.replayNamespace
+      };
+      let body;
+      try {
+        body = JSON.stringify(document);
+      } catch {
+        sendInternalError(res);
+        return;
+      }
+      if (utf8ByteLength(body) > SIGNER_ASSET_METADATA_BYTE_CAP) {
+        sendInternalError(res);
+        return;
+      }
+      res.set("Cache-Control", "no-store");
+      res.set("Content-Type", "application/json; charset=utf-8");
+      res.status(200).send(body);
+    }).catch(() => {
+      try {
+        if (!res.headersSent) {
+          sendInternalError(res);
+        }
+      } catch {
+      }
+    });
+  });
+  router.get("/signer.:contentHash.mjs", (req, res) => {
+    void Promise.resolve().then(async () => {
+      const params = req.params ?? {};
+      const requested = params["contentHash"];
+      if (typeof requested !== "string" || requested.length === 0) {
+        sendAssetNotFound(res, false);
+        return;
+      }
+      if (!isContentHash(requested)) {
+        sendAssetNotFound(res, false);
+        return;
+      }
+      let snapshotRaw;
+      try {
+        const pending = config.keyProvider.getSnapshot();
+        snapshotRaw = await withOperationTimeout2(Promise.resolve(pending), config.operationTimeoutMs);
+      } catch {
+        sendKeysUnavailable(res);
+        return;
+      }
+      let snapshot;
+      try {
+        snapshot = copyAttestationSnapshot(snapshotRaw);
+      } catch {
+        sendKeysUnavailable(res);
+        return;
+      }
+      let runtimeFileName;
+      try {
+        runtimeFileName = getSignerRuntimeAsset().fileName;
+      } catch {
+        sendInternalError(res);
+        return;
+      }
+      for (const entry of snapshot.keys) {
+        let asset;
+        try {
+          asset = getSignerKeyModuleAsset({
+            entry,
+            publicOrigin: config.publicOrigin,
+            replayNamespace: config.replayNamespace,
+            runtimeFileName
+          });
+        } catch {
+          continue;
+        }
+        if (asset.contentHash === requested) {
+          res.set("Cache-Control", "public, max-age=31536000, immutable");
+          res.set("Content-Type", "text/javascript; charset=utf-8");
+          res.set("X-Content-Type-Options", "nosniff");
+          res.status(200).send(Buffer.from(asset.bytes));
+          return;
+        }
+      }
+      sendAssetNotFound(res, true);
+    }).catch(() => {
+      try {
+        if (!res.headersSent) {
+          sendInternalError(res);
+        }
+      } catch {
+      }
+    });
+  });
+  router.get("/runtime.:contentHash.mjs", (req, res) => {
+    try {
+      const params = req.params ?? {};
+      const requested = params["contentHash"];
+      if (typeof requested !== "string" || requested.length === 0) {
+        sendAssetNotFound(res, false);
+        return;
+      }
+      if (!isContentHash(requested)) {
+        sendAssetNotFound(res, false);
+        return;
+      }
+      let asset;
+      try {
+        asset = getSignerRuntimeAsset();
+      } catch {
+        sendInternalError(res);
+        return;
+      }
+      if (asset.contentHash !== requested) {
+        sendAssetNotFound(res, true);
+        return;
+      }
+      res.set("Cache-Control", "public, max-age=31536000, immutable");
+      res.set("Content-Type", "text/javascript; charset=utf-8");
+      res.set("X-Content-Type-Options", "nosniff");
+      res.status(200).send(Buffer.from(asset.bytes));
+    } catch {
+      try {
+        if (!res.headersSent) {
+          sendInternalError(res);
+        }
+      } catch {
+      }
+    }
+  });
+  return router;
+}
+
+// src/index.ts
+function hashBodySha256Hex(body) {
+  if (!(body instanceof Uint8Array)) {
+    throw new AttestationProtocolError("body must be a Uint8Array");
+  }
+  return (0, import_node_crypto6.createHash)("sha256").update(body).digest("hex");
+}
+function deriveAttestationReplayKey(input) {
+  const preimage = buildReplayKeyPreimageBytes(input);
+  const digest = (0, import_node_crypto6.createHash)("sha256").update(preimage).digest("hex");
+  const replayKey = `${REPLAY_KEY_PREFIX}${digest}`;
+  validateReplayKey(replayKey);
+  return replayKey;
+}