@invisible-labs/sdk 0.6.0-devnet.4 → 0.6.0-devnet.5

package/dist/chunk-Y7AK6RBV.js

@@ -0,0 +1,4189 @@
+import { getSessionState, failSessionClosed, createSessionHandle, closeSessionState } from './chunk-HJFMDMPY.js';
+import { getStorageBacking, browserStorage, extensionStorage } from './chunk-DCTYBUY3.js';
+import { TransportError, StorageError, AttestationError } from './chunk-QRN46R3F.js';
+import * as x509 from '@peculiar/x509';
+import { generateKeyPair, sharedKey } from '@stablelib/x25519';
+import { ChaCha20Poly1305 } from '@stablelib/chacha20poly1305';
+import { hash, SHA256 } from '@stablelib/sha256';
+import { HMAC } from '@stablelib/hmac';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+
+// src/core/exponentialBackoff.ts
+function createExponentialBackoff(options) {
+  if (!Number.isFinite(options.initialDelayMs) || options.initialDelayMs <= 0) {
+    throw new Error("initialDelayMs must be a positive finite number");
+  }
+  if (!Number.isFinite(options.maxDelayMs) || options.maxDelayMs < options.initialDelayMs) {
+    throw new Error("maxDelayMs must be finite and >= initialDelayMs");
+  }
+  if (options.multiplier !== void 0 && (!Number.isFinite(options.multiplier) || options.multiplier < 1)) {
+    throw new Error("multiplier must be finite and >= 1");
+  }
+  if (options.jitterRatio !== void 0 && (!Number.isFinite(options.jitterRatio) || options.jitterRatio < 0 || options.jitterRatio > 1)) {
+    throw new Error("jitterRatio must be between 0 and 1");
+  }
+  const initialDelayMs = options.initialDelayMs;
+  const maxDelayMs = options.maxDelayMs;
+  const multiplier = options.multiplier ?? 2;
+  const jitterRatio = options.jitterRatio ?? 0;
+  const random = options.random ?? Math.random;
+  let attempt = 0;
+  return {
+    nextDelayMs() {
+      const baseDelayMs = Math.min(maxDelayMs, initialDelayMs * multiplier ** attempt);
+      attempt += 1;
+      if (jitterRatio === 0) return Math.round(baseDelayMs);
+      const lowerBound = baseDelayMs * (1 - jitterRatio);
+      const upperBound = baseDelayMs * (1 + jitterRatio);
+      const boundedRandom = Math.min(Math.max(random(), 0), 1);
+      return Math.min(
+        maxDelayMs,
+        Math.round(lowerBound + (upperBound - lowerBound) * boundedRandom)
+      );
+    },
+    reset() {
+      attempt = 0;
+    }
+  };
+}
+
+// src/transport/stateController.ts
+function createStateController(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get: () => state,
+    set(next) {
+      if (next === state) return;
+      state = next;
+      for (const listener of listeners) listener(next);
+    },
+    onChange(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/transport/noiseWebSocketTransport.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
+function defaultWebSocketFactory(url) {
+  const ctor = globalThis.WebSocket;
+  if (!ctor) {
+    throw new TransportError(
+      "WS_HANDSHAKE_FAILED",
+      "no global WebSocket available; pass options.webSocketFactory"
+    );
+  }
+  return new ctor(url);
+}
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  throw new TransportError("NOISE_FRAME_TOO_LARGE", "unsupported inbound frame type");
+}
+function noiseWebSocketTransport(options) {
+  const factory = options.webSocketFactory ?? defaultWebSocketFactory;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const sc = createStateController("idle");
+  const messageListeners = /* @__PURE__ */ new Set();
+  let socket = null;
+  function teardown() {
+    if (sc.get() === "closed") return;
+    sc.set("closing");
+    const ws = socket;
+    socket = null;
+    if (ws) {
+      ws.onopen = null;
+      ws.onerror = null;
+      ws.onmessage = null;
+      ws.onclose = null;
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+    sc.set("closed");
+  }
+  return {
+    state: () => sc.get(),
+    onStateChange: (listener) => sc.onChange(listener),
+    onMessage(listener) {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    },
+    connect(signal) {
+      if (sc.get() === "open") return Promise.resolve();
+      if (signal?.aborted) {
+        return Promise.reject(
+          new TransportError("CONNECTION_LOST", "connect aborted before it started")
+        );
+      }
+      sc.set("connecting");
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const ws = factory(options.wsUrl);
+        socket = ws;
+        ws.binaryType = "arraybuffer";
+        const cleanupConnect = () => {
+          clearTimeout(timer);
+          signal?.removeEventListener("abort", onAbort);
+        };
+        const fail = (error) => {
+          if (settled) return;
+          settled = true;
+          cleanupConnect();
+          teardown();
+          reject(error);
+        };
+        const onAbort = () => fail(new TransportError("CONNECTION_LOST", "connect aborted"));
+        const timer = setTimeout(
+          () => fail(
+            new TransportError(
+              "WS_HANDSHAKE_FAILED",
+              `connect timed out after ${connectTimeoutMs}ms`
+            )
+          ),
+          connectTimeoutMs
+        );
+        signal?.addEventListener("abort", onAbort, { once: true });
+        ws.onopen = () => {
+          if (settled) return;
+          settled = true;
+          cleanupConnect();
+          ws.onmessage = (event) => {
+            const frame = toUint8Array(event.data);
+            for (const listener of messageListeners) listener(frame);
+          };
+          ws.onclose = () => teardown();
+          ws.onerror = () => teardown();
+          sc.set("open");
+          resolve();
+        };
+        ws.onerror = () => fail(new TransportError("WS_HANDSHAKE_FAILED", "socket error during connect"));
+        ws.onclose = () => fail(new TransportError("CONNECTION_LOST", "socket closed during connect"));
+      });
+    },
+    send(frame) {
+      const ws = socket;
+      if (sc.get() !== "open" || !ws) {
+        throw new TransportError("CONNECTION_LOST", "cannot send on a non-open transport");
+      }
+      ws.send(frame);
+    },
+    close() {
+      teardown();
+    }
+  };
+}
+
+// src/storage/clientPersistence.ts
+var CLIENT_PERSISTENCE_NAMESPACE = "normal-user-transfers";
+var CLIENT_PERSISTENCE_SCHEMA_VERSION = 1;
+var CLIENT_PERSISTENCE_MAX_RECORD_BYTES = 64 * 1024;
+var CLIENT_PERSISTENCE_MAX_RECORD_COUNT = 100;
+var CLIENT_PERSISTENCE_MAX_NAMESPACE_BYTES = 1024 * 1024;
+var HEX_BYTE_LENGTH = 32;
+var HEX_LENGTH = HEX_BYTE_LENGTH * 2;
+var MAX_IDENTIFIER_LENGTH = 256;
+var MAX_ADDRESS_LENGTH = 128;
+var MAX_POLICY_DESTINATION_COUNT = CLIENT_PERSISTENCE_MAX_RECORD_COUNT;
+var MAX_POLICY_JSON_BYTES = CLIENT_PERSISTENCE_MAX_RECORD_BYTES;
+var CLIENT_PERSISTENCE_PROBE_KEY_PREFIX = "__sdk_probe__";
+var CLIENT_PERSISTENCE_PROBE_BYTES = Uint8Array.from([83, 68, 75, 49]);
+var CLIENT_PERSISTENCE_NAMESPACE_GATE_KEY = "__sdk_namespace_gate__";
+var PERSISTED_STAGE_VALUES = /* @__PURE__ */ new Set([
+  "allocation",
+  "ready",
+  "terminal-cleaned"
+]);
+var CLIENT_SWAP_STATE_VALUES = /* @__PURE__ */ new Set([
+  "new",
+  "awaiting_dkg",
+  "awaiting_deposit",
+  "awaiting_delegation",
+  "awaiting_delegate_ack",
+  "awaiting_delegate_ack_after_deposit",
+  "ready_for_settlement",
+  "settling",
+  "completed",
+  "refunded",
+  "failed"
+]);
+var SERIALIZED_RECORD_KEYS = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "stage",
+  "swapId",
+  "amountLamports",
+  "destinationAddress",
+  "policySnapshot",
+  "status",
+  "stateVersion",
+  "updatedAtMs",
+  "coordinatorTimestampMs",
+  "depositAddress",
+  "depositExpiresAtMs",
+  "delegatedAtMs",
+  "syncSecretHex",
+  "recoveryCodeHex"
+]);
+var POLICY_SNAPSHOT_KEYS = /* @__PURE__ */ new Set([
+  "asset",
+  "entry_amount_lamports",
+  "total_committed_lamports",
+  "payout_deadline_ms",
+  "payout_window_ms",
+  "payout_schedule",
+  "fragment_count",
+  "payout_mode",
+  "matching_mode",
+  "fragmentation_allowed",
+  "min_fee_bps",
+  "fee_bps",
+  "fee_lamports",
+  "net_payout_lamports"
+]);
+var POLICY_DESTINATION_KEYS = /* @__PURE__ */ new Set(["destination_address"]);
+var HEX_PATTERN = /^[0-9a-f]+$/u;
+var terminalWriteBarriers = /* @__PURE__ */ new WeakMap();
+var namespaceWriteGates = /* @__PURE__ */ new WeakMap();
+var automaticStorageAdapters = /* @__PURE__ */ new WeakMap();
+var clientPersistenceProbeSequence = 0;
+function disabledClientPersistence() {
+  return { enabled: false, adapter: null };
+}
+async function resolveClientPersistence(enabled, storage) {
+  let adapter = null;
+  let automaticBackend = null;
+  try {
+    if (storage === void 0) {
+      const selection = automaticStorageAdapter();
+      adapter = selection.adapter;
+      automaticBackend = selection.backend;
+    } else {
+      adapter = validateStorageAdapter(storage);
+    }
+    if (adapter === null) {
+      throw new StorageError("STORAGE_NOT_AVAILABLE", "client persistence storage is unavailable");
+    }
+    await probeStorage(adapter);
+    return { enabled: true, adapter };
+  } catch (error) {
+    if (automaticBackend !== null && adapter !== null && automaticStorageAdapters.get(automaticBackend) === adapter) {
+      automaticStorageAdapters.delete(automaticBackend);
+    }
+    throw withContext(error, { phase: "session-init" });
+  }
+}
+async function listPersistedTransfers(session) {
+  const state = getSessionState(session).clientPersistence;
+  const records = await readAllRecords(state, "read");
+  return records.map(toPublicRecord);
+}
+async function getPersistedTransfer(session, swapId) {
+  const state = getSessionState(session).clientPersistence;
+  assertSwapId(swapId, "read");
+  if (isReservedPersistenceKey(swapId)) return null;
+  const record = await readOptionalRecord(state, swapId, "read");
+  return record === null ? null : toPublicRecord(record);
+}
+async function removePersistedTransfer(session, swapId) {
+  const state = getSessionState(session).clientPersistence;
+  assertSwapId(swapId, "remove");
+  const adapter = requireAdapter(state, "remove");
+  const terminalWrite = beginTerminalWrite(state, swapId);
+  try {
+    await terminalWrite?.waitForNonTerminalWrites;
+    await withNamespaceWriteGate(
+      adapter,
+      CLIENT_PERSISTENCE_NAMESPACE,
+      swapId,
+      () => adapter.remove(CLIENT_PERSISTENCE_NAMESPACE, swapId),
+      { exclusive: true }
+    );
+  } catch (error) {
+    throw withContext(error, { phase: "remove" });
+  } finally {
+    terminalWrite?.release();
+  }
+}
+async function purgePersistedTransfers(session) {
+  const state = getSessionState(session).clientPersistence;
+  const adapter = requireAdapter(state, "purge");
+  try {
+    await withNamespaceWriteGate(
+      adapter,
+      CLIENT_PERSISTENCE_NAMESPACE,
+      CLIENT_PERSISTENCE_NAMESPACE_GATE_KEY,
+      async () => {
+        const keys = await adapter.list(CLIENT_PERSISTENCE_NAMESPACE);
+        for (const key of keys) {
+          await adapter.remove(CLIENT_PERSISTENCE_NAMESPACE, key);
+        }
+      },
+      { exclusive: true }
+    );
+  } catch (error) {
+    throw withContext(error, { phase: "purge" });
+  }
+}
+async function persistTransferAllocation(state, params) {
+  const record = {
+    schemaVersion: CLIENT_PERSISTENCE_SCHEMA_VERSION,
+    stage: "allocation",
+    swapId: params.swapId,
+    amountLamports: params.amountLamports,
+    destinationAddress: destinationFromPayoutSpec(params.payoutSpec),
+    policySnapshot: params.policySnapshot,
+    status: "awaiting_dkg",
+    updatedAtMs: Date.now(),
+    coordinatorTimestampMs: params.coordinatorTimestampMs,
+    syncSecret: new Uint8Array(params.syncSecret)
+  };
+  const nonTerminalWrite = beginNonTerminalWriteForState(state, params.swapId);
+  if (nonTerminalWrite === null) return;
+  try {
+    await writeRecord(state, record, "allocation", true, null, nonTerminalWrite);
+  } finally {
+    nonTerminalWrite();
+  }
+}
+async function persistTransferDkgMetadata(state, params) {
+  if (!state.enabled) return;
+  const adapter = requireAdapter(state, "allocation", params.swapId, true);
+  const nonTerminalWrite = beginNonTerminalWriteForState(state, params.swapId);
+  if (nonTerminalWrite === null) return;
+  try {
+    await withNamespaceWriteGate(adapter, CLIENT_PERSISTENCE_NAMESPACE, params.swapId, async () => {
+      const record = await readRequiredRecord(state, params.swapId, "allocation", true);
+      if (record.stage !== "allocation") return;
+      await writeRecord(
+        state,
+        {
+          ...record,
+          depositAddress: params.depositAddress,
+          depositExpiresAtMs: params.depositExpiresAtMs,
+          coordinatorTimestampMs: params.coordinatorTimestampMs,
+          updatedAtMs: Date.now()
+        },
+        "allocation",
+        true,
+        null,
+        nonTerminalWrite,
+        { namespaceGateHeld: true }
+      );
+    });
+  } finally {
+    nonTerminalWrite();
+  }
+}
+async function persistTransferRecoveryCode(state, swapId, recoveryCode) {
+  if (!state.enabled) return;
+  const adapter = requireAdapter(state, "recovery-code", swapId, true);
+  const nonTerminalWrite = beginNonTerminalWriteForState(state, swapId);
+  if (nonTerminalWrite === null) return;
+  try {
+    await withNamespaceWriteGate(adapter, CLIENT_PERSISTENCE_NAMESPACE, swapId, async () => {
+      const record = await readOptionalRecord(state, swapId, "recovery-code", true);
+      if (record === null) return;
+      await writeRecord(
+        state,
+        { ...record, recoveryCode: new Uint8Array(recoveryCode), updatedAtMs: Date.now() },
+        "recovery-code",
+        true,
+        null,
+        nonTerminalWrite,
+        { namespaceGateHeld: true }
+      );
+    });
+  } finally {
+    nonTerminalWrite();
+  }
+}
+async function readPersistedTransferForResume(state, swapId) {
+  return readOptionalRecord(state, swapId, "ready", false);
+}
+async function persistTransferReady(state, params) {
+  if (!state.enabled) return;
+  const adapter = requireAdapter(state, "ready", params.swapId, true);
+  const nonTerminalWrite = beginNonTerminalWriteForState(state, params.swapId);
+  if (nonTerminalWrite === null) return;
+  try {
+    await withNamespaceWriteGate(adapter, CLIENT_PERSISTENCE_NAMESPACE, params.swapId, async () => {
+      const record = await readRequiredRecord(state, params.swapId, "ready", true);
+      await writeRecord(
+        state,
+        {
+          ...record,
+          stage: "ready",
+          status: "awaiting_deposit",
+          depositAddress: params.depositAddress,
+          depositExpiresAtMs: params.depositExpiresAtMs,
+          delegatedAtMs: params.delegatedAtMs,
+          coordinatorTimestampMs: params.coordinatorTimestampMs,
+          updatedAtMs: Date.now()
+        },
+        "ready",
+        true,
+        null,
+        nonTerminalWrite,
+        { namespaceGateHeld: true }
+      );
+    });
+  } finally {
+    nonTerminalWrite();
+  }
+}
+async function persistTransferStatus(state, swapId, status, coordinatorTimestampMs) {
+  if (!state.enabled) return;
+  const isTerminal = CLIENT_SWAP_STATE_VALUES.has(status.state) && isTerminalState(status.state);
+  const terminalWrite = isTerminal ? beginTerminalWrite(state, swapId) : null;
+  const nonTerminalWrite = isTerminal ? null : beginNonTerminalWriteForState(state, swapId);
+  if (!isTerminal && nonTerminalWrite === null) return;
+  const adapter = requireAdapter(state, "sync", swapId, true);
+  try {
+    if (terminalWrite) await terminalWrite.waitForNonTerminalWrites;
+    await withNamespaceWriteGate(
+      adapter,
+      CLIENT_PERSISTENCE_NAMESPACE,
+      swapId,
+      async () => {
+        const record = await readOptionalRecord(state, swapId, "sync", true);
+        if (record === null || record.stage === "terminal-cleaned" && !isTerminal) return;
+        const next = isTerminal ? {
+          ...record,
+          stage: "terminal-cleaned",
+          status: status.state,
+          ...status.actor_sync === void 0 ? {} : { stateVersion: status.actor_sync.snapshot.state_version },
+          updatedAtMs: Date.now(),
+          coordinatorTimestampMs,
+          syncSecret: void 0,
+          recoveryCode: void 0
+        } : {
+          ...record,
+          status: status.state,
+          ...status.actor_sync === void 0 ? {} : { stateVersion: status.actor_sync.snapshot.state_version },
+          updatedAtMs: Date.now(),
+          coordinatorTimestampMs
+        };
+        await writeRecord(state, next, "sync", true, terminalWrite, nonTerminalWrite, {
+          namespaceGateHeld: true
+        });
+      },
+      { exclusive: isTerminal }
+    );
+  } finally {
+    terminalWrite?.release();
+    nonTerminalWrite?.();
+  }
+}
+async function persistTransferTerminal(state, swapId, status, coordinatorTimestampMs, phase = "refund") {
+  if (!state.enabled) return;
+  const terminalWrite = beginTerminalWrite(state, swapId);
+  const adapter = requireAdapter(state, phase, swapId, true);
+  try {
+    await terminalWrite?.waitForNonTerminalWrites;
+    await withNamespaceWriteGate(
+      adapter,
+      CLIENT_PERSISTENCE_NAMESPACE,
+      swapId,
+      async () => {
+        const record = await readOptionalRecord(state, swapId, phase, true);
+        if (record === null) return;
+        await writeRecord(
+          state,
+          {
+            ...record,
+            stage: "terminal-cleaned",
+            status,
+            updatedAtMs: Date.now(),
+            coordinatorTimestampMs,
+            syncSecret: void 0,
+            recoveryCode: void 0
+          },
+          phase,
+          true,
+          terminalWrite,
+          void 0,
+          { namespaceGateHeld: true }
+        );
+      },
+      { exclusive: true }
+    );
+  } finally {
+    terminalWrite?.release();
+  }
+}
+function automaticStorageAdapter() {
+  const global = globalThis;
+  const chromeStorage = global.chrome?.storage?.local;
+  const extensionContext = global.chrome?.runtime?.id !== void 0 || global.browser?.runtime?.id !== void 0;
+  if (isExtensionStorageArea(chromeStorage)) {
+    return automaticAdapterFor(chromeStorage, () => extensionStorage({ storage: chromeStorage }));
+  }
+  if (extensionContext) {
+    throw new StorageError(
+      "STORAGE_NOT_AVAILABLE",
+      "Chrome extension storage.local is unavailable",
+      { phase: "session-init" }
+    );
+  }
+  let localStorage;
+  try {
+    localStorage = globalThis.localStorage;
+  } catch {
+    return { backend: null, adapter: browserStorage() };
+  }
+  if (typeof localStorage === "object" && localStorage !== null) {
+    return automaticAdapterFor(
+      localStorage,
+      () => browserStorage({ storage: localStorage })
+    );
+  }
+  return { backend: null, adapter: browserStorage() };
+}
+function automaticAdapterFor(backend, create) {
+  const existing = automaticStorageAdapters.get(backend);
+  if (existing !== void 0) return { backend, adapter: existing };
+  const adapter = create();
+  automaticStorageAdapters.set(backend, adapter);
+  return { backend, adapter };
+}
+function isExtensionStorageArea(value) {
+  return typeof value === "object" && value !== null && isFunction(value.get) && isFunction(value.set) && isFunction(value.remove);
+}
+function validateStorageAdapter(value) {
+  if (typeof value !== "object" || value === null || !isStorageKind(value.kind) || !isFunction(value.put) || !isFunction(value.get) || !isFunction(value.list) || !isFunction(value.remove)) {
+    throw new StorageError(
+      "STORAGE_INVALID_ADAPTER",
+      "client persistence storage must implement the StorageAdapter contract",
+      { phase: "session-init" }
+    );
+  }
+  return value;
+}
+async function probeStorage(adapter) {
+  const probeKey = `${CLIENT_PERSISTENCE_PROBE_KEY_PREFIX}${Date.now()}-${clientPersistenceProbeSequence}`;
+  clientPersistenceProbeSequence += 1;
+  const probeBytes = new Uint8Array(CLIENT_PERSISTENCE_PROBE_BYTES);
+  try {
+    await withNamespaceWriteGate(
+      adapter,
+      CLIENT_PERSISTENCE_NAMESPACE,
+      probeKey,
+      async () => {
+        let probeMayExist = false;
+        try {
+          await adapter.list(CLIENT_PERSISTENCE_NAMESPACE);
+          probeMayExist = true;
+          await adapter.put(CLIENT_PERSISTENCE_NAMESPACE, probeKey, probeBytes);
+          const storedProbe = await adapter.get(CLIENT_PERSISTENCE_NAMESPACE, probeKey);
+          if (!(storedProbe instanceof Uint8Array) || storedProbe.byteLength !== probeBytes.byteLength || storedProbe.some((byte, index) => byte !== probeBytes[index])) {
+            throw new StorageError(
+              "STORAGE_NOT_AVAILABLE",
+              "client persistence storage probe readback failed",
+              { phase: "session-init" }
+            );
+          }
+          await adapter.remove(CLIENT_PERSISTENCE_NAMESPACE, probeKey);
+          const remainingProbe = await adapter.get(CLIENT_PERSISTENCE_NAMESPACE, probeKey);
+          if (remainingProbe !== null) {
+            throw new StorageError(
+              "STORAGE_NOT_AVAILABLE",
+              "client persistence storage probe removal readback failed",
+              { phase: "session-init" }
+            );
+          }
+          probeMayExist = false;
+        } catch (error) {
+          if (probeMayExist) {
+            try {
+              await adapter.remove(CLIENT_PERSISTENCE_NAMESPACE, probeKey);
+            } catch {
+            }
+          }
+          throw error;
+        }
+      },
+      { exclusive: true }
+    );
+  } catch (error) {
+    throw withContext(error, { phase: "session-init" });
+  }
+}
+async function writeRecord(state, record, phase, remoteAccepted, terminalWrite, nonTerminalWrite, options = {}) {
+  if (!state.enabled) return;
+  const adapter = requireAdapter(state, phase, record.swapId, remoteAccepted);
+  const terminalRecord = record.stage === "terminal-cleaned";
+  const ownedTerminalWrite = terminalRecord && terminalWrite === void 0 ? beginTerminalWrite(state, record.swapId) : null;
+  const activeTerminalWrite = terminalWrite ?? ownedTerminalWrite;
+  const releaseNonTerminalWrite = terminalRecord ? null : nonTerminalWrite ?? beginNonTerminalWrite(adapter, record.swapId);
+  if (!terminalRecord && releaseNonTerminalWrite === null) return;
+  try {
+    if (activeTerminalWrite) await activeTerminalWrite.waitForNonTerminalWrites;
+    const bytes = serializeRecord(record);
+    const write = async () => {
+      const keys = (await adapter.list(CLIENT_PERSISTENCE_NAMESPACE)).filter(
+        (key) => !isReservedPersistenceKey(key)
+      );
+      const values = /* @__PURE__ */ new Map();
+      let namespaceBytes = 0;
+      for (const key of keys) {
+        const value = await adapter.get(CLIENT_PERSISTENCE_NAMESPACE, key);
+        if (value !== null) {
+          values.set(key, value);
+          namespaceBytes += value.byteLength;
+        }
+      }
+      const previous = values.get(record.swapId);
+      const nextCount = previous === void 0 ? keys.length + 1 : keys.length;
+      if (previous === void 0 && nextCount > CLIENT_PERSISTENCE_MAX_RECORD_COUNT) {
+        throw namespaceLimitError("namespace record limit exceeded");
+      }
+      const nextBytes = namespaceBytes - (previous?.byteLength ?? 0) + bytes.byteLength;
+      if (nextBytes > CLIENT_PERSISTENCE_MAX_NAMESPACE_BYTES && (previous === void 0 || bytes.byteLength > previous.byteLength)) {
+        throw namespaceLimitError("namespace byte limit exceeded");
+      }
+      await adapter.put(CLIENT_PERSISTENCE_NAMESPACE, record.swapId, bytes);
+    };
+    if (options.namespaceGateHeld) {
+      await write();
+    } else {
+      await withNamespaceWriteGate(adapter, CLIENT_PERSISTENCE_NAMESPACE, record.swapId, write);
+    }
+  } catch (error) {
+    throw withContext(error, { phase, swapId: record.swapId, remoteAccepted });
+  } finally {
+    releaseNonTerminalWrite?.();
+    ownedTerminalWrite?.release();
+  }
+}
+function beginNonTerminalWriteForState(state, swapId) {
+  if (!state.enabled || state.adapter === null) return null;
+  return beginNonTerminalWrite(state.adapter, swapId);
+}
+async function withNamespaceWriteGate(adapter, namespace, key, write, options = {}) {
+  const release = await acquireNamespaceWriteGate(adapter, namespace, key, options);
+  try {
+    await write();
+  } finally {
+    release();
+  }
+}
+async function acquireNamespaceWriteGate(adapter, namespace, key, options = {}) {
+  const gate = getNamespaceWriteGate(adapter, namespace);
+  const exclusive = options.exclusive === true;
+  let granted = false;
+  const shouldWait = () => {
+    if (gate.activeCount === 0) return gate.waiters.length !== 0;
+    if (exclusive || gate.exclusive) return true;
+    return gate.activeKey !== key || gate.waiters.length !== 0;
+  };
+  while (!granted && shouldWait()) {
+    await new Promise(
+      (resolve) => gate.waiters.push({
+        key,
+        resolve: () => {
+          granted = true;
+          resolve();
+        }
+      })
+    );
+  }
+  gate.activeKey = key;
+  gate.activeCount += 1;
+  gate.exclusive = exclusive;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    gate.activeCount -= 1;
+    if (gate.activeCount !== 0) return;
+    gate.activeKey = null;
+    gate.exclusive = false;
+    const next = gate.waiters.shift();
+    if (next) {
+      next.resolve();
+      return;
+    }
+    cleanupNamespaceWriteGate(adapter, namespace, gate);
+  };
+}
+function getNamespaceWriteGate(adapter, namespace) {
+  const backing = getStorageBacking(adapter);
+  let gates = namespaceWriteGates.get(backing);
+  if (!gates) {
+    gates = /* @__PURE__ */ new Map();
+    namespaceWriteGates.set(backing, gates);
+  }
+  let gate = gates.get(namespace);
+  if (!gate) {
+    gate = { activeKey: null, activeCount: 0, exclusive: false, waiters: [] };
+    gates.set(namespace, gate);
+  }
+  return gate;
+}
+function cleanupNamespaceWriteGate(adapter, namespace, gate) {
+  if (gate.activeKey !== null || gate.waiters.length !== 0) return;
+  namespaceWriteGates.get(getStorageBacking(adapter))?.delete(namespace);
+}
+function beginTerminalWrite(state, swapId) {
+  if (!state.enabled || state.adapter === null) return null;
+  const barrier = getTerminalWriteBarrier(state.adapter, swapId);
+  barrier.activeTerminalWrites += 1;
+  barrier.terminalRequested = true;
+  const waitForNonTerminalWrites = barrier.activeNonTerminalWrites === 0 ? Promise.resolve() : new Promise((resolve) => barrier.nonTerminalWaiters.push(resolve));
+  let released = false;
+  return {
+    waitForNonTerminalWrites,
+    release() {
+      if (released) return;
+      released = true;
+      barrier.activeTerminalWrites -= 1;
+      if (barrier.activeTerminalWrites === 0) barrier.terminalRequested = false;
+      cleanupTerminalWriteBarrier(state.adapter, swapId, barrier);
+    }
+  };
+}
+function beginNonTerminalWrite(adapter, swapId) {
+  const barrier = getTerminalWriteBarrier(adapter, swapId);
+  if (barrier.terminalRequested) return null;
+  barrier.activeNonTerminalWrites += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    barrier.activeNonTerminalWrites -= 1;
+    if (barrier.activeNonTerminalWrites === 0) {
+      const waiters = barrier.nonTerminalWaiters.splice(0);
+      for (const resolve of waiters) resolve();
+    }
+    cleanupTerminalWriteBarrier(adapter, swapId, barrier);
+  };
+}
+function getTerminalWriteBarrier(adapter, swapId) {
+  const backing = getStorageBacking(adapter);
+  let barriers = terminalWriteBarriers.get(backing);
+  if (!barriers) {
+    barriers = /* @__PURE__ */ new Map();
+    terminalWriteBarriers.set(backing, barriers);
+  }
+  let barrier = barriers.get(swapId);
+  if (!barrier) {
+    barrier = {
+      activeNonTerminalWrites: 0,
+      activeTerminalWrites: 0,
+      terminalRequested: false,
+      nonTerminalWaiters: []
+    };
+    barriers.set(swapId, barrier);
+  }
+  return barrier;
+}
+function cleanupTerminalWriteBarrier(adapter, swapId, barrier) {
+  if (barrier.activeNonTerminalWrites !== 0 || barrier.activeTerminalWrites !== 0 || barrier.terminalRequested || barrier.nonTerminalWaiters.length !== 0) {
+    return;
+  }
+  terminalWriteBarriers.get(getStorageBacking(adapter))?.delete(swapId);
+}
+async function readAllRecords(state, phase) {
+  const adapter = requireAdapter(state, phase);
+  try {
+    const keys = (await adapter.list(CLIENT_PERSISTENCE_NAMESPACE)).filter(
+      (key) => !isReservedPersistenceKey(key)
+    );
+    if (keys.length > CLIENT_PERSISTENCE_MAX_RECORD_COUNT) {
+      throw namespaceLimitError("namespace contains too many records");
+    }
+    const records = [];
+    let namespaceBytes = 0;
+    for (const key of keys) {
+      const value = await adapter.get(CLIENT_PERSISTENCE_NAMESPACE, key);
+      if (value === null) {
+        throw new StorageError(
+          "STORAGE_KEY_MISSING",
+          "persisted transfer key disappeared during read"
+        );
+      }
+      namespaceBytes += value.byteLength;
+      if (namespaceBytes > CLIENT_PERSISTENCE_MAX_NAMESPACE_BYTES) {
+        throw namespaceLimitError("namespace byte limit exceeded");
+      }
+      records.push(parseRecord(value, key));
+    }
+    return records;
+  } catch (error) {
+    throw withContext(error, { phase });
+  }
+}
+async function readOptionalRecord(state, swapId, phase, remoteAccepted = false) {
+  if (!state.enabled) return null;
+  assertSwapId(swapId, phase);
+  const value = await readValue(state, swapId, phase, remoteAccepted);
+  if (value === null) return null;
+  try {
+    return parseRecord(value, swapId);
+  } catch (error) {
+    throw withContext(error, { phase, swapId, remoteAccepted });
+  }
+}
+async function readRequiredRecord(state, swapId, phase, remoteAccepted = true) {
+  const record = await readOptionalRecord(state, swapId, phase, remoteAccepted);
+  if (record === null) {
+    throw new StorageError("STORAGE_KEY_MISSING", `persisted transfer ${swapId} is missing`, {
+      phase,
+      swapId,
+      remoteAccepted
+    });
+  }
+  return record;
+}
+async function readValue(state, swapId, phase, remoteAccepted = false) {
+  const adapter = requireAdapter(state, phase, swapId, remoteAccepted);
+  try {
+    return await adapter.get(CLIENT_PERSISTENCE_NAMESPACE, swapId);
+  } catch (error) {
+    throw withContext(error, { phase, swapId, remoteAccepted });
+  }
+}
+function serializeRecord(record) {
+  assertRecord(record);
+  const policySnapshot = normalizePolicySnapshot(record.policySnapshot);
+  const serialized = {
+    schemaVersion: record.schemaVersion,
+    stage: record.stage,
+    swapId: record.swapId,
+    amountLamports: record.amountLamports,
+    destinationAddress: record.destinationAddress,
+    policySnapshot,
+    status: record.status,
+    ...record.stateVersion !== void 0 && { stateVersion: record.stateVersion },
+    updatedAtMs: record.updatedAtMs,
+    ...record.coordinatorTimestampMs !== void 0 && {
+      coordinatorTimestampMs: record.coordinatorTimestampMs
+    },
+    ...record.depositAddress !== void 0 && { depositAddress: record.depositAddress },
+    ...record.depositExpiresAtMs !== void 0 && {
+      depositExpiresAtMs: record.depositExpiresAtMs
+    },
+    ...record.delegatedAtMs !== void 0 && { delegatedAtMs: record.delegatedAtMs },
+    syncSecretHex: record.syncSecret === void 0 ? void 0 : bytesToHex(record.syncSecret),
+    recoveryCodeHex: record.recoveryCode === void 0 ? void 0 : bytesToHex(record.recoveryCode)
+  };
+  const json = JSON.stringify(serialized);
+  const bytes = new TextEncoder().encode(json);
+  if (bytes.byteLength > CLIENT_PERSISTENCE_MAX_RECORD_BYTES) {
+    throw namespaceLimitError("persisted transfer record exceeds the byte limit");
+  }
+  return bytes;
+}
+function parseRecord(bytes, expectedSwapId) {
+  if (bytes.byteLength > CLIENT_PERSISTENCE_MAX_RECORD_BYTES) {
+    throw new StorageError(
+      "STORAGE_QUOTA_EXCEEDED",
+      "persisted transfer record exceeds the byte limit"
+    );
+  }
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch (cause) {
+    throw new StorageError(
+      "STORAGE_DECRYPT_FAILED",
+      "persisted transfer record is not valid JSON",
+      {
+        cause
+      }
+    );
+  }
+  if (!isRecord(value)) {
+    throw corruptRecordError("persisted transfer record is not an object");
+  }
+  const keys = Object.keys(value);
+  if (keys.some((key) => !SERIALIZED_RECORD_KEYS.has(key))) {
+    throw corruptRecordError("persisted transfer record contains an unknown field");
+  }
+  if (value.schemaVersion !== CLIENT_PERSISTENCE_SCHEMA_VERSION) {
+    throw corruptRecordError("persisted transfer record has an unsupported schema version");
+  }
+  if (value.swapId !== expectedSwapId) {
+    throw corruptRecordError("persisted transfer key does not match its swap id");
+  }
+  const record = value;
+  if (!isPersistedStage(record.stage) || typeof record.swapId !== "string" || typeof record.amountLamports !== "number" || !Number.isSafeInteger(record.amountLamports) || record.amountLamports < 0 || typeof record.destinationAddress !== "string" || typeof record.status !== "string" || !CLIENT_SWAP_STATE_VALUES.has(record.status) || typeof record.updatedAtMs !== "number" || !Number.isSafeInteger(record.updatedAtMs) || record.updatedAtMs < 0 || !isRecord(record.policySnapshot)) {
+    throw corruptRecordError("persisted transfer record has invalid required fields");
+  }
+  assertBoundedString(record.swapId, MAX_IDENTIFIER_LENGTH, "swap id");
+  assertBoundedString(record.destinationAddress, MAX_ADDRESS_LENGTH, "destination address");
+  if (record.syncSecretHex !== void 0) {
+    if (typeof record.syncSecretHex !== "string") {
+      throw corruptRecordError("persisted transfer sync secret is invalid");
+    }
+    assertHex(record.syncSecretHex, "sync secret");
+  }
+  if (record.recoveryCodeHex !== void 0) {
+    if (typeof record.recoveryCodeHex !== "string") {
+      throw corruptRecordError("persisted transfer recovery code is invalid");
+    }
+    assertHex(record.recoveryCodeHex, "recovery code");
+  }
+  assertOptionalTimestamp(record.stateVersion, "state version");
+  assertOptionalTimestamp(record.coordinatorTimestampMs, "coordinator timestamp");
+  assertOptionalTimestamp(record.depositExpiresAtMs, "deposit expiry");
+  assertOptionalTimestamp(record.delegatedAtMs, "delegated timestamp");
+  if (record.depositAddress !== void 0) {
+    if (typeof record.depositAddress !== "string") {
+      throw corruptRecordError("persisted transfer deposit address is invalid");
+    }
+    assertBoundedString(record.depositAddress, MAX_ADDRESS_LENGTH, "deposit address");
+  }
+  if (record.stage === "ready") {
+    if (record.depositAddress === void 0 || record.depositExpiresAtMs === void 0 || record.delegatedAtMs === void 0) {
+      throw corruptRecordError("ready persisted transfer is missing deposit metadata");
+    }
+  }
+  if (record.stage === "terminal-cleaned") {
+    if (record.syncSecretHex !== void 0 || record.recoveryCodeHex !== void 0) {
+      throw corruptRecordError("terminal persisted transfer contains bearer material");
+    }
+    if (!isTerminalState(record.status)) {
+      throw corruptRecordError("terminal persisted transfer has a non-terminal status");
+    }
+  } else if (record.syncSecretHex === void 0 || isTerminalState(record.status)) {
+    throw corruptRecordError("non-terminal persisted transfer has invalid bearer state");
+  }
+  const policySnapshot = normalizePolicySnapshot(record.policySnapshot);
+  if (record.amountLamports !== policySnapshot.entry_amount_lamports || record.destinationAddress !== policySnapshot.payout_schedule[0]?.destination_address) {
+    throw corruptRecordError("persisted transfer metadata does not match its policy snapshot");
+  }
+  return {
+    schemaVersion: CLIENT_PERSISTENCE_SCHEMA_VERSION,
+    stage: record.stage,
+    swapId: record.swapId,
+    amountLamports: record.amountLamports,
+    destinationAddress: record.destinationAddress,
+    policySnapshot,
+    status: record.status,
+    ...record.stateVersion !== void 0 && { stateVersion: record.stateVersion },
+    updatedAtMs: record.updatedAtMs,
+    ...record.coordinatorTimestampMs !== void 0 && {
+      coordinatorTimestampMs: record.coordinatorTimestampMs
+    },
+    ...record.depositAddress !== void 0 && { depositAddress: record.depositAddress },
+    ...record.depositExpiresAtMs !== void 0 && {
+      depositExpiresAtMs: record.depositExpiresAtMs
+    },
+    ...record.delegatedAtMs !== void 0 && { delegatedAtMs: record.delegatedAtMs },
+    ...record.syncSecretHex !== void 0 && { syncSecret: hexToBytes(record.syncSecretHex) },
+    ...record.recoveryCodeHex !== void 0 && {
+      recoveryCode: hexToBytes(record.recoveryCodeHex)
+    }
+  };
+}
+function assertRecord(record) {
+  assertSwapId(record.swapId, "write");
+  if (record.schemaVersion !== CLIENT_PERSISTENCE_SCHEMA_VERSION) {
+    throw corruptRecordError("persisted transfer has an unsupported schema version");
+  }
+  if (!PERSISTED_STAGE_VALUES.has(record.stage)) {
+    throw corruptRecordError("persisted transfer has an invalid stage");
+  }
+  if (!Number.isSafeInteger(record.amountLamports) || record.amountLamports < 0) {
+    throw corruptRecordError("persisted transfer has an invalid amount");
+  }
+  assertBoundedString(record.destinationAddress, MAX_ADDRESS_LENGTH, "destination address");
+  if (!CLIENT_SWAP_STATE_VALUES.has(record.status)) {
+    throw corruptRecordError("persisted transfer has an invalid status");
+  }
+  if (!Number.isSafeInteger(record.updatedAtMs) || record.updatedAtMs < 0) {
+    throw corruptRecordError("persisted transfer has an invalid update timestamp");
+  }
+  assertOptionalTimestamp(record.stateVersion, "state version");
+  if (record.syncSecret !== void 0 && (!(record.syncSecret instanceof Uint8Array) || record.syncSecret.length !== HEX_BYTE_LENGTH)) {
+    throw corruptRecordError("persisted transfer sync secret has an invalid length");
+  }
+  if (record.recoveryCode !== void 0 && (!(record.recoveryCode instanceof Uint8Array) || record.recoveryCode.length !== HEX_BYTE_LENGTH)) {
+    throw corruptRecordError("persisted transfer recovery code has an invalid length");
+  }
+  const policySnapshot = normalizePolicySnapshot(record.policySnapshot);
+  if (record.amountLamports !== policySnapshot.entry_amount_lamports || record.destinationAddress !== policySnapshot.payout_schedule[0]?.destination_address) {
+    throw corruptRecordError("persisted transfer metadata does not match its policy snapshot");
+  }
+  assertOptionalTimestamp(record.coordinatorTimestampMs, "coordinator timestamp");
+  assertOptionalTimestamp(record.depositExpiresAtMs, "deposit expiry");
+  assertOptionalTimestamp(record.delegatedAtMs, "delegated timestamp");
+  if (record.depositAddress !== void 0) {
+    assertBoundedString(record.depositAddress, MAX_ADDRESS_LENGTH, "deposit address");
+  }
+  if (record.stage === "ready") {
+    if (record.depositAddress === void 0 || record.depositExpiresAtMs === void 0 || record.delegatedAtMs === void 0) {
+      throw corruptRecordError("ready persisted transfer is missing deposit metadata");
+    }
+  }
+  if (record.stage === "terminal-cleaned") {
+    if (record.syncSecret !== void 0 || record.recoveryCode !== void 0) {
+      throw corruptRecordError("terminal persisted transfer contains bearer material");
+    }
+    if (!isTerminalState(record.status)) {
+      throw corruptRecordError("terminal persisted transfer has a non-terminal status");
+    }
+  } else if (record.syncSecret === void 0 || isTerminalState(record.status)) {
+    throw corruptRecordError("non-terminal persisted transfer has invalid bearer state");
+  }
+  const policyBytes = new TextEncoder().encode(JSON.stringify(policySnapshot));
+  if (policyBytes.byteLength > MAX_POLICY_JSON_BYTES) {
+    throw namespaceLimitError("persisted transfer policy snapshot exceeds the byte limit");
+  }
+}
+function toPublicRecord(record) {
+  const hasDurableDelegation = record.stage !== "allocation" && record.depositAddress !== void 0 && record.depositExpiresAtMs !== void 0 && record.delegatedAtMs !== void 0;
+  return {
+    schemaVersion: record.schemaVersion,
+    stage: record.stage,
+    swapId: record.swapId,
+    amountLamports: record.amountLamports,
+    destinationAddress: record.destinationAddress,
+    policySnapshot: record.policySnapshot,
+    status: record.status,
+    ...record.stateVersion !== void 0 && { stateVersion: record.stateVersion },
+    updatedAtMs: record.updatedAtMs,
+    ...record.coordinatorTimestampMs !== void 0 && {
+      coordinatorTimestampMs: record.coordinatorTimestampMs
+    },
+    ...hasDurableDelegation && { depositAddress: record.depositAddress },
+    ...hasDurableDelegation && { depositExpiresAtMs: record.depositExpiresAtMs },
+    ...hasDurableDelegation && { delegatedAtMs: record.delegatedAtMs },
+    ...record.syncSecret !== void 0 && { syncSecret: new Uint8Array(record.syncSecret) },
+    ...record.recoveryCode !== void 0 && {
+      recoveryCode: new Uint8Array(record.recoveryCode)
+    }
+  };
+}
+function destinationFromPayoutSpec(payoutSpec) {
+  return payoutSpec.mode === "instant" ? payoutSpec.destination_address : payoutSpec.destination_addresses[0] ?? "";
+}
+function requireAdapter(state, phase, swapId, remoteAccepted) {
+  if (!state.enabled || state.adapter === null) {
+    throw new StorageError("STORAGE_NOT_AVAILABLE", "client persistence is disabled", {
+      phase,
+      ...swapId === void 0 ? {} : { swapId },
+      ...remoteAccepted === void 0 ? {} : { remoteAccepted }
+    });
+  }
+  return state.adapter;
+}
+function withContext(error, context) {
+  const code = error instanceof StorageError ? error.code === "STORAGE_NOT_AVAILABLE" && isQuotaError(error) ? "STORAGE_QUOTA_EXCEEDED" : error.code : isQuotaError(error) ? "STORAGE_QUOTA_EXCEEDED" : "STORAGE_NOT_AVAILABLE";
+  const message = error instanceof Error ? error.message : "storage operation failed";
+  return new StorageError(code, message, {
+    cause: error,
+    swapId: context.swapId ?? (error instanceof StorageError ? error.swapId : void 0),
+    phase: context.phase,
+    remoteAccepted: context.remoteAccepted ?? (error instanceof StorageError ? error.remoteAccepted : void 0)
+  });
+}
+function namespaceLimitError(message) {
+  return new StorageError("STORAGE_QUOTA_EXCEEDED", message);
+}
+function corruptRecordError(message) {
+  return new StorageError("STORAGE_DECRYPT_FAILED", message);
+}
+function assertSwapId(swapId, phase) {
+  if (typeof swapId !== "string" || swapId.length === 0 || swapId.length > MAX_IDENTIFIER_LENGTH) {
+    throw new StorageError("STORAGE_KEY_MISSING", "swapId is invalid", { phase });
+  }
+}
+function isReservedPersistenceKey(key) {
+  return key.startsWith(CLIENT_PERSISTENCE_PROBE_KEY_PREFIX);
+}
+function assertBoundedString(value, maxLength, label) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength) {
+    throw corruptRecordError(`${label} is outside the supported length`);
+  }
+}
+function assertHex(value, label) {
+  if (value.length !== HEX_LENGTH || !HEX_PATTERN.test(value)) {
+    throw corruptRecordError(`${label} is not a 32-byte hexadecimal value`);
+  }
+}
+function assertOptionalTimestamp(value, label) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) {
+    throw corruptRecordError(`${label} is invalid`);
+  }
+}
+function normalizePolicySnapshot(value) {
+  if (!isRecord(value)) throw corruptRecordError("persisted transfer policy snapshot is invalid");
+  if (Object.keys(value).some((key) => !POLICY_SNAPSHOT_KEYS.has(key))) {
+    throw corruptRecordError("persisted transfer policy snapshot contains an unknown field");
+  }
+  if (value.asset !== "SOL") throw corruptRecordError("persisted transfer policy asset is invalid");
+  const integerFields = [
+    "entry_amount_lamports",
+    "total_committed_lamports",
+    "payout_deadline_ms",
+    "fragment_count",
+    "min_fee_bps",
+    "fee_bps",
+    "fee_lamports",
+    "net_payout_lamports"
+  ];
+  for (const field of integerFields) assertNonNegativeInteger(value[field], field);
+  if (value.payout_window_ms !== void 0) {
+    assertNonNegativeInteger(value.payout_window_ms, "payout_window_ms");
+  }
+  if (value.payout_mode !== "instant" && value.payout_mode !== "scheduled") {
+    throw corruptRecordError("persisted transfer payout mode is invalid");
+  }
+  if (value.matching_mode !== "exact_1_to_1") {
+    throw corruptRecordError("persisted transfer matching mode is invalid");
+  }
+  if (value.fragmentation_allowed !== "payout_side_only") {
+    throw corruptRecordError("persisted transfer fragmentation mode is invalid");
+  }
+  if (!Array.isArray(value.payout_schedule) || value.payout_schedule.length === 0) {
+    throw corruptRecordError("persisted transfer payout schedule is invalid");
+  }
+  if (value.payout_schedule.length > MAX_POLICY_DESTINATION_COUNT) {
+    throw corruptRecordError("persisted transfer payout schedule is too large");
+  }
+  const payoutSchedule = Array.from(value.payout_schedule, (entry) => {
+    if (!isRecord(entry) || Object.keys(entry).some((key) => !POLICY_DESTINATION_KEYS.has(key))) {
+      throw corruptRecordError("persisted transfer payout schedule entry is invalid");
+    }
+    if (typeof entry.destination_address !== "string") {
+      throw corruptRecordError("persisted transfer payout destination is invalid");
+    }
+    assertBoundedString(entry.destination_address, MAX_ADDRESS_LENGTH, "payout destination");
+    return { destination_address: entry.destination_address };
+  });
+  return {
+    asset: "SOL",
+    entry_amount_lamports: value.entry_amount_lamports,
+    total_committed_lamports: value.total_committed_lamports,
+    payout_deadline_ms: value.payout_deadline_ms,
+    ...value.payout_window_ms !== void 0 && {
+      payout_window_ms: value.payout_window_ms
+    },
+    payout_schedule: payoutSchedule,
+    fragment_count: value.fragment_count,
+    payout_mode: value.payout_mode,
+    matching_mode: "exact_1_to_1",
+    fragmentation_allowed: "payout_side_only",
+    min_fee_bps: value.min_fee_bps,
+    fee_bps: value.fee_bps,
+    fee_lamports: value.fee_lamports,
+    net_payout_lamports: value.net_payout_lamports
+  };
+}
+function assertNonNegativeInteger(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw corruptRecordError(`persisted transfer policy ${label} is invalid`);
+  }
+}
+function isQuotaError(error) {
+  if (error instanceof StorageError) {
+    return isQuotaError(error.cause);
+  }
+  if (error instanceof Error && /quota/i.test(error.name)) return true;
+  if (error instanceof Error && /quota/i.test(error.message)) return true;
+  if (isRecord(error)) {
+    const name = typeof error.name === "string" ? error.name : "";
+    const message = typeof error.message === "string" ? error.message : "";
+    return /quota/i.test(name) || /quota/i.test(message);
+  }
+  return false;
+}
+function isPersistedStage(value) {
+  return typeof value === "string" && PERSISTED_STAGE_VALUES.has(value);
+}
+function isStorageKind(value) {
+  return value === "browser" || value === "extension" || value === "server-hkdf" || value === "server-custom" || value === "memory";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTerminalState(state) {
+  return state === "completed" || state === "refunded" || state === "failed";
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(value) {
+  const bytes = new Uint8Array(value.length / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+}
+var DEFAULT_AZURE_JWKS_TIMEOUT_MS = 3e4;
+var TPM_GENERATED_VALUE = 4283712327;
+var TPM_ST_ATTEST_QUOTE = 32792;
+function assertAttestResponse(value) {
+  if (typeof value !== "object" || value === null) {
+    throw err("QUOTE_DECODE", "attestation response is not a JSON object");
+  }
+  const v = value;
+  const fields = ["quote", "nonce", "pubkey", "binary_hash", "mode"];
+  for (const field of fields) {
+    if (typeof v[field] !== "string") {
+      throw err(
+        "QUOTE_DECODE",
+        `attestation response missing or non-string field: "${field}" (got ${typeof v[field]})`
+      );
+    }
+  }
+  if (v["mode"] !== "dev" && v["mode"] !== "prod") {
+    throw err("QUOTE_DECODE", `attestation response has unknown mode: "${v["mode"]}"`);
+  }
+  if (v["runtime_profile"] !== void 0 && v["runtime_profile"] !== "prod-hardened" && v["runtime_profile"] !== "prod-devnet-simplified" && v["runtime_profile"] !== "prod-devnet-simplified-locked" && v["runtime_profile"] !== "azure-tdx-v0-agentless") {
+    throw err(
+      "QUOTE_DECODE",
+      `attestation response has unknown runtime profile: "${v["runtime_profile"]}"`
+    );
+  }
+  if (v["local_attestation"] !== void 0 && typeof v["local_attestation"] !== "boolean") {
+    throw err(
+      "QUOTE_DECODE",
+      `attestation response has non-boolean local_attestation: ${typeof v["local_attestation"]}`
+    );
+  }
+}
+var INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256 = "44a0196b2b99f889b8e149e95b807a350e7424964399e885a7cbb8ccfab674d3";
+var REASON_TO_CODE = {
+  // Structural / chain / quote-signature failures -> the cert-chain bucket.
+  QUOTE_DECODE: "CERT_CHAIN_INVALID",
+  QUOTE_STRUCTURE: "CERT_CHAIN_INVALID",
+  UNSUPPORTED_PLATFORM: "CERT_CHAIN_INVALID",
+  PCK_CHAIN_MISSING: "CERT_CHAIN_INVALID",
+  PCK_CHAIN_PARSE: "CERT_CHAIN_INVALID",
+  ROOT_FINGERPRINT_MISMATCH: "CERT_CHAIN_INVALID",
+  PCK_CHAIN_SIGNATURE: "CERT_CHAIN_INVALID",
+  DCAP_COLLATERAL_SIGNATURE: "CERT_CHAIN_INVALID",
+  DCAP_COLLATERAL_MISSING: "TCB_REJECTED",
+  DCAP_COLLATERAL_PARSE: "TCB_REJECTED",
+  DCAP_COLLATERAL_REVOKED: "TCB_REJECTED",
+  TCB_STATUS_REJECTED: "TCB_REJECTED",
+  QE_IDENTITY_REJECTED: "TCB_REJECTED",
+  QUOTE_SIGNATURE: "CERT_CHAIN_INVALID",
+  QE_REPORT_BINDING: "CERT_CHAIN_INVALID",
+  QE_REPORT_SIGNATURE: "CERT_CHAIN_INVALID",
+  // Freshness.
+  NONCE_MISMATCH: "FRESHNESS_NONCE_MISMATCH",
+  NONCE_FIELD_MISMATCH: "FRESHNESS_NONCE_MISMATCH",
+  TPM_NONCE_MISMATCH: "AZURE_TPM_QUALIFYING_DATA_MISMATCH",
+  // Noise channel binding (pubkey / report-data binding / bound JSON fields).
+  CHANNEL_BINDING_MISMATCH: "NOISE_BINDING_MISMATCH",
+  PUBKEY_FIELD_MISMATCH: "NOISE_BINDING_MISMATCH",
+  BINARY_HASH_FORMAT: "NOISE_BINDING_MISMATCH",
+  BINARY_HASH_MISMATCH: "NOISE_BINDING_MISMATCH",
+  // Debug bit.
+  DEBUG_BIT_SET: "DEBUG_BIT_SET",
+  MAA_DEBUG_BIT_SET: "DEBUG_BIT_SET",
+  // Mode / measurement pinning.
+  MODE_MISMATCH: "MRTD_MISMATCH",
+  MRTD_MISMATCH: "MRTD_MISMATCH",
+  RUNTIME_MEASUREMENTS_MISMATCH: "RUNTIME_MEASUREMENTS_MISMATCH",
+  RUNTIME_PROFILE_MISMATCH: "RUNTIME_PROFILE_MISMATCH",
+  // Local fallback disabled -> not attested.
+  LOCAL_ATTESTATION_DISABLED: "NOT_ATTESTED",
+  // Azure MAA token issuer / JWKS / policy / signature / compliance / binding.
+  MAA_TOKEN_MISSING: "AZURE_MAA_JWKS_INVALID",
+  MAA_TOKEN_PARSE: "AZURE_MAA_JWKS_INVALID",
+  MAA_TOKEN_EXPIRED: "AZURE_MAA_JWKS_INVALID",
+  MAA_TOKEN_SIGNATURE: "AZURE_MAA_JWKS_INVALID",
+  MAA_TRUST_POLICY_MISSING: "AZURE_MAA_ISSUER_MISMATCH",
+  MAA_ISSUER_MISMATCH: "AZURE_MAA_ISSUER_MISMATCH",
+  MAA_JWKS_MISMATCH: "AZURE_MAA_JWKS_INVALID",
+  MAA_POLICY_HASH_MISMATCH: "AZURE_MAA_POLICY_HASH_MISMATCH",
+  MAA_COMPLIANCE_MISMATCH: "AZURE_MAA_NOT_COMPLIANT",
+  MAA_REPORTDATA_MISMATCH: "AZURE_MAA_DCAP_MISMATCH",
+  // Azure HCL key blob hash binding.
+  HCL_KEYS_MISSING: "AZURE_HCL_KEYS_MISMATCH",
+  HCL_KEYS_HASH_MISMATCH: "AZURE_HCL_KEYS_MISMATCH",
+  HCL_KEYS_PARSE: "AZURE_AK_PUB_INVALID",
+  // Azure TPM AK quote.
+  TPM_QUOTE_MISSING: "AZURE_TPM_AK_QUOTE_INVALID",
+  TPM_QUOTE_SIGNATURE: "AZURE_TPM_AK_QUOTE_INVALID"
+};
+function err(reason, message) {
+  return new AttestationError(REASON_TO_CODE[reason], `[${reason}] ${message}`);
+}
+var MEASUREMENT_LEN = 48;
+var HEADER_SIZE = 48;
+var HEADER_VERSION_OFF = 0;
+var HEADER_ATT_KEY_OFF = 2;
+var HEADER_TEE_TYPE_OFF = 4;
+var TDX_TEE_TYPE = 129;
+var ECDSA_P256_KEY_TYPE = 2;
+var BODY_OFFSET = 48;
+var BODY_SIZE = 584;
+var BODY_TEE_TCB_SVN_OFF = 0;
+var BODY_MRSIGNERSEAM_OFF = 64;
+var BODY_SEAM_ATTRIBUTES_OFF = 112;
+var BODY_TD_ATTR_OFF = 120;
+var BODY_MRTD_OFF = 136;
+var BODY_RTMR0_OFF = 328;
+var BODY_RTMR1_OFF = 376;
+var BODY_RTMR2_OFF = 424;
+var BODY_RTMR3_OFF = 472;
+var BODY_REPORT_DATA_OFF = 520;
+var BODY_REPORT_DATA_LEN = 64;
+var SIG_DATA_LEN_OFFSET = BODY_OFFSET + BODY_SIZE;
+var SIG_QUOTE_SIG_OFF = 0;
+var SIG_ATT_KEY_OFF = 64;
+var SIG_QE_CERT_DATA_OFF = 128;
+var SIG_QE_CERT_DATA_HEADER_SIZE = 6;
+var SIG_QE_REPORT_SIZE = 384;
+var SIG_QE_REPORT_SIG_SIZE = 64;
+var SGX_REPORT_MISCSELECT_OFF = 16;
+var SGX_REPORT_ATTRIBUTES_OFF = 48;
+var SGX_REPORT_MRSIGNER_OFF = 128;
+var SGX_REPORT_ISV_PROD_ID_OFF = 256;
+var SGX_REPORT_ISV_SVN_OFF = 258;
+var SGX_REPORT_DATA_OFF = 320;
+var QE_CERT_TYPE_PCK_CHAIN = 5;
+var QE_CERT_TYPE_QE_REPORT_CERT_DATA = 6;
+var INTEL_PCK_SGX_EXTENSIONS_OID = "1.2.840.113741.1.13.1";
+var INTEL_PCK_EXTENSION_TCB_OID = "1.2.840.113741.1.13.1.2";
+var INTEL_PCK_EXTENSION_PCE_ID_OID = "1.2.840.113741.1.13.1.3";
+var INTEL_PCK_EXTENSION_FMSPC_OID = "1.2.840.113741.1.13.1.4";
+var INTEL_PCK_EXTENSION_PCESVN_OID = "1.2.840.113741.1.13.1.2.17";
+var INTEL_PCK_EXTENSION_CPUSVN_OID = "1.2.840.113741.1.13.1.2.18";
+var INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX = "1.2.840.113741.1.13.1.2.";
+var INTEL_TCB_SIGNING_SUBJECT = "CN=Intel SGX TCB Signing, O=Intel Corporation, L=Santa Clara, ST=CA, C=US";
+var TEST_TCB_SIGNING_SUBJECT = "CN=Test SGX and TDX TCB Signing";
+var ACCEPTED_TCB_STATUSES = /* @__PURE__ */ new Set(["UpToDate"]);
+var ACCEPTED_TDX_MODULE_STATUSES = /* @__PURE__ */ new Set(["UpToDate"]);
+var ACCEPTED_QE_IDENTITY_STATUSES = /* @__PURE__ */ new Set(["UpToDate"]);
+async function verifyAttestation(params) {
+  const { response, expectedNonce, expectedNoiseStaticPub, policy, timeoutMs } = params;
+  if (policy.expectedRuntimeProfile !== void 0 && response.runtime_profile !== policy.expectedRuntimeProfile) {
+    throw err(
+      "RUNTIME_PROFILE_MISMATCH",
+      `runtime profile ${String(response.runtime_profile)} does not match the approved release profile ${policy.expectedRuntimeProfile}`
+    );
+  }
+  if (response.runtime_profile === "azure-tdx-v0-agentless" && policy.expectedRuntimeMeasurements === void 0) {
+    throw err(
+      "RUNTIME_MEASUREMENTS_MISMATCH",
+      "agentless attestation requires pinned RTMR0..RTMR3 measurements"
+    );
+  }
+  if (response.runtime_profile === "azure-tdx-v0-agentless" && response.local_attestation === true) {
+    throw err(
+      "LOCAL_ATTESTATION_DISABLED",
+      "the agentless Azure TDX profile requires a hardware attestation quote"
+    );
+  }
+  if (response.runtime_profile === "azure-tdx-v0-agentless" && response.platform !== "azure-tdx-dcap") {
+    throw err(
+      "UNSUPPORTED_PLATFORM",
+      "the agentless Azure TDX profile requires an Azure DCAP attestation response"
+    );
+  }
+  if (response.local_attestation === true) {
+    return verifyLocalAttestation({
+      response,
+      expectedNonce,
+      expectedNoiseStaticPub,
+      policy
+    });
+  }
+  const raw = decodeQuoteB64(response.quote);
+  ensureStructure(raw);
+  if (response.platform === "azure-tdx-dcap") {
+    return verifyAzureTdxAttestation({
+      raw,
+      response,
+      expectedNonce,
+      expectedNoiseStaticPub,
+      policy,
+      timeoutMs
+    });
+  }
+  if (response.platform && response.platform !== "tdx-dcap") {
+    throw err(
+      "UNSUPPORTED_PLATFORM",
+      `attestation not supported for platform "${response.platform}"`
+    );
+  }
+  return verifyGcpTdxAttestation({
+    raw,
+    response,
+    expectedNonce,
+    expectedNoiseStaticPub,
+    policy
+  });
+}
+async function verifyGcpTdxAttestation(params) {
+  const { raw, response, expectedNonce, expectedNoiseStaticPub, policy } = params;
+  const body = raw.subarray(BODY_OFFSET, BODY_OFFSET + BODY_SIZE);
+  const reportData = body.subarray(
+    BODY_REPORT_DATA_OFF,
+    BODY_REPORT_DATA_OFF + BODY_REPORT_DATA_LEN
+  );
+  if (!constantTimeEq(reportData.subarray(0, 32), expectedNonce)) {
+    throw err(
+      "NONCE_MISMATCH",
+      "REPORT_DATA[0:32] does not match verifier nonce - possible replay"
+    );
+  }
+  if (response.nonce.toLowerCase() !== bytesToHex2(expectedNonce)) {
+    throw err("NONCE_FIELD_MISMATCH", `JSON nonce ${response.nonce} does not match verifier nonce`);
+  }
+  if (!constantTimeEq(reportData.subarray(32, 64), expectedNoiseStaticPub)) {
+    throw err(
+      "CHANNEL_BINDING_MISMATCH",
+      "REPORT_DATA[32:64] does not match Noise static pubkey from handshake"
+    );
+  }
+  const expectedPubHex = bytesToHex2(expectedNoiseStaticPub);
+  if (response.pubkey.toLowerCase() !== expectedPubHex) {
+    throw err(
+      "PUBKEY_FIELD_MISMATCH",
+      "attestation pubkey field does not match Noise static pubkey from handshake"
+    );
+  }
+  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
+    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
+  }
+  if (policy.expectedBinaryHash !== void 0 && response.binary_hash.toLowerCase() !== policy.expectedBinaryHash.toLowerCase()) {
+    throw err(
+      "BINARY_HASH_MISMATCH",
+      `binary hash ${response.binary_hash.toLowerCase()} does not match the approved release pin`
+    );
+  }
+  await verifyDcapQuoteAndCollateral({ raw, body, response, policy });
+  assertDebugBitClear(body);
+  const measurements = parseMeasurements(body);
+  assertRuntimeMeasurementsMatch(measurements, policy);
+  if (policy.requiredMode !== void 0 && response.mode !== policy.requiredMode) {
+    throw err(
+      "MODE_MISMATCH",
+      `attestation mode ${response.mode} does not match required ${policy.requiredMode}`
+    );
+  }
+  if (response.mode === "prod") {
+    if ((policy.expectedMrtd === void 0 || policy.expectedMrtd === null) && policy.allowUnpinnedProdMrtdForRelease !== true) {
+      throw err(
+        "MRTD_MISMATCH",
+        "production attestation requires a pinned MRTD but none was configured"
+      );
+    }
+    if (policy.expectedMrtd !== void 0 && policy.expectedMrtd !== null && measurements.mrtd !== policy.expectedMrtd.toLowerCase()) {
+      throw err(
+        "MRTD_MISMATCH",
+        `MRTD ${measurements.mrtd} does not match pinned ${policy.expectedMrtd.toLowerCase()}`
+      );
+    }
+  }
+  return {
+    mode: response.mode,
+    binaryHash: response.binary_hash,
+    runtimeProfile: response.runtime_profile,
+    mrtd: measurements.mrtd,
+    rtmr0: measurements.rtmr0,
+    rtmr1: measurements.rtmr1,
+    rtmr2: measurements.rtmr2,
+    rtmr3: measurements.rtmr3,
+    pubkeyHex: response.pubkey.toLowerCase(),
+    localAttestation: false
+  };
+}
+function assertRuntimeMeasurementsMatch(measurements, policy) {
+  const expected = policy.expectedRuntimeMeasurements;
+  if (expected === void 0) return;
+  for (const field of ["rtmr0", "rtmr1", "rtmr2", "rtmr3"]) {
+    if (!/^[0-9a-f]{96}$/i.test(expected[field])) {
+      throw err(
+        "RUNTIME_MEASUREMENTS_MISMATCH",
+        `approved ${field.toUpperCase()} pin is not a 48-byte hex digest`
+      );
+    }
+    if (measurements[field] !== expected[field].toLowerCase()) {
+      throw err(
+        "RUNTIME_MEASUREMENTS_MISMATCH",
+        `${field.toUpperCase()} does not match the approved runtime measurement`
+      );
+    }
+  }
+}
+async function verifyDcapQuoteAndCollateral(params) {
+  const { raw, body, response, policy } = params;
+  const sigData = readSigData(raw);
+  const qeCertData = parseQeCertificationData(sigData);
+  const pckChain = extractPckChain(qeCertData.qeCertificationData);
+  const expectedRootFp = policy.intelRootFingerprint?.toLowerCase() ?? INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
+  const rootFp = await sha256Hex(new Uint8Array(pckChain[pckChain.length - 1].rawData));
+  if (rootFp !== expectedRootFp) {
+    throw err(
+      "ROOT_FINGERPRINT_MISMATCH",
+      `PCK root fingerprint ${rootFp} does not match pinned ${expectedRootFp}`
+    );
+  }
+  await verifyChainSignatures(pckChain);
+  const quoteSig = sigData.subarray(SIG_QUOTE_SIG_OFF, SIG_QUOTE_SIG_OFF + 64);
+  const attKey = sigData.subarray(SIG_ATT_KEY_OFF, SIG_ATT_KEY_OFF + 64);
+  const headerAndBody = raw.subarray(0, BODY_OFFSET + BODY_SIZE);
+  await verifyP256Signature(
+    rawXyToSpki(attKey),
+    quoteSig,
+    headerAndBody,
+    "QUOTE_SIGNATURE",
+    "quote header||body signature"
+  );
+  const { qeReport, qeReportSig, qeAuthData } = qeCertData;
+  const expectedBinding = await sha256(concat(attKey, qeAuthData));
+  const qeReportData = qeReport.subarray(SGX_REPORT_DATA_OFF, SGX_REPORT_DATA_OFF + 32);
+  if (!constantTimeEq(qeReportData, expectedBinding)) {
+    throw err(
+      "QE_REPORT_BINDING",
+      "QE report does not bind the in-quote attestation key (REPORT_DATA mismatch)"
+    );
+  }
+  const pckLeafSpki = await leafSpki(pckChain[0]);
+  await verifyP256Signature(
+    pckLeafSpki,
+    qeReportSig,
+    qeReport,
+    "QE_REPORT_SIGNATURE",
+    "QE report signature"
+  );
+  await verifyDcapCollateral({
+    collateral: response.dcap_collateral,
+    pckChain,
+    body,
+    qeReport,
+    mode: response.mode,
+    policy
+  });
+}
+async function verifyDcapCollateral(params) {
+  const { collateral, pckChain, body, qeReport, mode, policy } = params;
+  if (!collateral) {
+    if (policy.allowMissingDcapCollateral === true && mode === "dev" && policy.requiredMode === "dev") {
+      return;
+    }
+    throw err("DCAP_COLLATERAL_MISSING", "TDX quote is missing Intel DCAP collateral");
+  }
+  const now = /* @__PURE__ */ new Date();
+  const rootCert = pckChain[pckChain.length - 1];
+  const rootCrl = parseCrl(collateral.rootCaCrlPem, "root_ca_crl");
+  await verifyCrl(rootCrl, rootCert, "root_ca_crl", now);
+  const pckCrlIssuerChain = await verifyCollateralIssuerChain(
+    parsePemCertificateChain(collateral.pckCrlIssuerChainPem, "pck_crl_issuer_chain", 2),
+    policy,
+    "pck_crl_issuer_chain"
+  );
+  await assertNotRevokedByRoot(rootCrl, pckCrlIssuerChain[0], "PCK CRL issuer");
+  await assertSameCertificate(pckCrlIssuerChain[0], pckChain[1], "PCK CRL issuer");
+  const pckCrl = parseCrl(collateral.pckCrlPem, "pck_crl");
+  await verifyCrl(pckCrl, pckCrlIssuerChain[0], "pck_crl", now);
+  if (pckCrl.findRevoked(pckChain[0])) {
+    throw err("DCAP_COLLATERAL_REVOKED", "PCK leaf certificate is revoked by PCK CRL");
+  }
+  const tcbInfo = await verifySignedDcapJson({
+    signed: collateral.tcbInfo,
+    wrapperField: "tcbInfo",
+    policy,
+    rootCrl,
+    label: "tcb_info"
+  });
+  const qeIdentity = await verifySignedDcapJson({
+    signed: collateral.qeIdentity,
+    wrapperField: "enclaveIdentity",
+    policy,
+    rootCrl,
+    label: "qe_identity"
+  });
+  assertMatchingTcbEvaluationDataNumber(tcbInfo, qeIdentity);
+  verifyTcbInfo(tcbInfo, pckChain[0], body, now);
+  verifyQeIdentity(qeIdentity, qeReport, now);
+}
+function assertDebugBitClear(body) {
+  if ((body[BODY_TD_ATTR_OFF] & 1) !== 0) {
+    throw err("DEBUG_BIT_SET", "TD_ATTRIBUTES DEBUG bit set - refusing to attest a debuggable TD");
+  }
+}
+async function verifySignedDcapJson(params) {
+  const { signed, wrapperField, policy, rootCrl, label } = params;
+  if (!signed || typeof signed.body !== "string" || typeof signed.signature !== "string" || typeof signed.issuerChainPem !== "string") {
+    throw err("DCAP_COLLATERAL_MISSING", `${label} collateral is incomplete`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(signed.body);
+  } catch (e) {
+    throw err("DCAP_COLLATERAL_PARSE", `${label} body is not valid JSON: ${e}`);
+  }
+  const signedBody = exactSignedDcapJsonBody(signed.body, parsed, wrapperField, label);
+  const body = signedBody.parsed;
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw err("DCAP_COLLATERAL_PARSE", `${label} body is not a JSON object`);
+  }
+  const issuerChain = await verifyCollateralIssuerChain(
+    parsePemCertificateChain(signed.issuerChainPem, `${label}_issuer_chain`, 2),
+    policy,
+    `${label}_issuer_chain`
+  );
+  await assertNotRevokedByRoot(rootCrl, issuerChain[0], `${label} signing certificate`);
+  assertDcapJsonSignerIdentity(issuerChain[0], issuerChain[issuerChain.length - 1], policy, label);
+  if (!/^[0-9a-f]{128}$/i.test(signed.signature)) {
+    throw err("DCAP_COLLATERAL_PARSE", `${label} signature is not a 64-byte hex ECDSA signature`);
+  }
+  await verifyP256Signature(
+    await leafSpki(issuerChain[0]),
+    hexToBytes2(signed.signature),
+    new TextEncoder().encode(signedBody.body),
+    "DCAP_COLLATERAL_SIGNATURE",
+    `${label} signature`
+  );
+  return body;
+}
+function exactSignedDcapJsonBody(raw, parsed, wrapperField, label) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { body: raw, parsed };
+  }
+  if (!(wrapperField in parsed)) {
+    return { body: raw, parsed };
+  }
+  const body = extractTopLevelJsonProperty(raw, wrapperField);
+  if (body === null) {
+    throw err(
+      "DCAP_COLLATERAL_PARSE",
+      `${label} PCS wrapper contains ${wrapperField} but exact signed body bytes could not be extracted`
+    );
+  }
+  try {
+    return { body, parsed: JSON.parse(body) };
+  } catch (e) {
+    throw err("DCAP_COLLATERAL_PARSE", `${label} exact signed body is not valid JSON: ${e}`);
+  }
+}
+function extractTopLevelJsonProperty(raw, property) {
+  let offset = skipJsonWhitespace(raw, 0);
+  if (raw[offset] !== "{") return null;
+  offset++;
+  while (offset < raw.length) {
+    offset = skipJsonWhitespace(raw, offset);
+    if (raw[offset] === "}") return null;
+    if (raw[offset] === ",") {
+      offset++;
+      continue;
+    }
+    const key = readJsonString(raw, offset);
+    if (key === null) return null;
+    offset = skipJsonWhitespace(raw, key.end);
+    if (raw[offset] !== ":") return null;
+    offset = skipJsonWhitespace(raw, offset + 1);
+    const valueStart = offset;
+    const valueEnd = findJsonValueEnd(raw, valueStart);
+    if (valueEnd === null) return null;
+    if (key.value === property) return raw.slice(valueStart, valueEnd);
+    offset = valueEnd;
+  }
+  return null;
+}
+function skipJsonWhitespace(raw, offset) {
+  while (offset < raw.length && /[\t\n\r ]/u.test(raw[offset])) offset++;
+  return offset;
+}
+function readJsonString(raw, offset) {
+  if (raw[offset] !== '"') return null;
+  let cursor = offset + 1;
+  let escaped = false;
+  while (cursor < raw.length) {
+    const char = raw[cursor];
+    if (escaped) {
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === '"') {
+      const token = raw.slice(offset, cursor + 1);
+      try {
+        return { value: JSON.parse(token), end: cursor + 1 };
+      } catch {
+        return null;
+      }
+    }
+    cursor++;
+  }
+  return null;
+}
+function findJsonValueEnd(raw, offset) {
+  if (offset >= raw.length) return null;
+  if (raw[offset] === '"') return readJsonString(raw, offset)?.end ?? null;
+  if (raw[offset] === "{" || raw[offset] === "[") {
+    const stack = [raw[offset]];
+    let cursor2 = offset + 1;
+    while (cursor2 < raw.length) {
+      const char = raw[cursor2];
+      if (char === '"') {
+        const stringToken = readJsonString(raw, cursor2);
+        if (stringToken === null) return null;
+        cursor2 = stringToken.end;
+        continue;
+      }
+      if (char === "{" || char === "[") {
+        stack.push(char);
+      } else if (char === "}" || char === "]") {
+        const open = stack.pop();
+        if (char === "}" && open !== "{" || char === "]" && open !== "[") return null;
+        if (stack.length === 0) return cursor2 + 1;
+      }
+      cursor2++;
+    }
+    return null;
+  }
+  let cursor = offset;
+  while (cursor < raw.length && !/[\t\n\r ,}\]]/u.test(raw[cursor])) cursor++;
+  return cursor > offset ? cursor : null;
+}
+function assertMatchingTcbEvaluationDataNumber(tcbInfo, qeIdentity) {
+  const tcbNumber = tcbInfo.tcbEvaluationDataNumber;
+  const qeNumber = qeIdentity.tcbEvaluationDataNumber;
+  if (!isTcbEvaluationDataNumber(tcbNumber) || !isTcbEvaluationDataNumber(qeNumber)) {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      "TCB Info and QE Identity must include valid tcbEvaluationDataNumber values"
+    );
+  }
+  if (tcbNumber !== qeNumber) {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      `TCB Info tcbEvaluationDataNumber ${tcbNumber} does not match QE Identity ${qeNumber}`
+    );
+  }
+}
+function isTcbEvaluationDataNumber(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+async function verifyCollateralIssuerChain(certs, policy, label) {
+  const candidates = [certs, [...certs].reverse()];
+  let lastError;
+  for (const chain of candidates) {
+    try {
+      const rootFp = await sha256Hex(new Uint8Array(chain[chain.length - 1].rawData));
+      const expectedRootFp = policy.intelRootFingerprint?.toLowerCase() ?? INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
+      if (rootFp !== expectedRootFp) {
+        throw err(
+          "ROOT_FINGERPRINT_MISMATCH",
+          `${label} root fingerprint ${rootFp} does not match pinned ${expectedRootFp}`
+        );
+      }
+      await verifyChainSignatures(chain);
+      return chain;
+    } catch (e) {
+      lastError = e;
+    }
+  }
+  if (lastError instanceof AttestationError) throw lastError;
+  throw err("DCAP_COLLATERAL_SIGNATURE", `${label} certificate chain failed verification`);
+}
+function assertDcapJsonSignerIdentity(leaf, root, policy, label) {
+  const expectedRootFp = policy.intelRootFingerprint?.toLowerCase() ?? INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
+  const allowsSyntheticRoot = expectedRootFp !== INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
+  const allowedSubjects = allowsSyntheticRoot ? [INTEL_TCB_SIGNING_SUBJECT, TEST_TCB_SIGNING_SUBJECT] : [INTEL_TCB_SIGNING_SUBJECT];
+  if (!allowedSubjects.includes(leaf.subject)) {
+    throw err(
+      "DCAP_COLLATERAL_SIGNATURE",
+      `${label} signing certificate subject ${leaf.subject} is not an Intel PCS TCB signing identity`
+    );
+  }
+  if (leaf.issuer !== root.subject) {
+    throw err(
+      "DCAP_COLLATERAL_SIGNATURE",
+      `${label} signing certificate issuer ${leaf.issuer} does not match root ${root.subject}`
+    );
+  }
+  const basicConstraints = leaf.getExtension(x509.BasicConstraintsExtension);
+  if (basicConstraints?.ca) {
+    throw err("DCAP_COLLATERAL_SIGNATURE", `${label} signing certificate must not be a CA`);
+  }
+}
+function verifyTcbInfo(tcbInfo, pckLeaf, body, now) {
+  if (tcbInfo.id !== "TDX") {
+    throw err("TCB_STATUS_REJECTED", `TCB Info id ${String(tcbInfo.id)} is not TDX`);
+  }
+  if (tcbInfo.version !== 3 || tcbInfo.tcbType !== 0) {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      `unsupported TCB Info version=${String(tcbInfo.version)} tcbType=${String(tcbInfo.tcbType)}`
+    );
+  }
+  assertFreshDcapJsonWindow(tcbInfo, "TCB Info", now);
+  const pckTcb = extractPckTcb(pckLeaf);
+  if (typeof tcbInfo.fmspc !== "string" || tcbInfo.fmspc.toLowerCase() !== pckTcb.fmspc) {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      `TCB Info FMSPC ${String(tcbInfo.fmspc)} does not match PCK FMSPC ${pckTcb.fmspc}`
+    );
+  }
+  if (typeof tcbInfo.pceId !== "string" || tcbInfo.pceId.toLowerCase() !== pckTcb.pceId) {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      `TCB Info PCE ID ${String(tcbInfo.pceId)} does not match PCK PCE ID ${pckTcb.pceId}`
+    );
+  }
+  if (!Array.isArray(tcbInfo.tcbLevels)) {
+    throw err("TCB_STATUS_REJECTED", "TCB Info has no tcbLevels array");
+  }
+  const teeTcbSvn = body.subarray(BODY_TEE_TCB_SVN_OFF, BODY_TEE_TCB_SVN_OFF + 16);
+  const matched = tcbInfo.tcbLevels.find((level) => tdxTcbLevelMatches(level, pckTcb, teeTcbSvn));
+  if (!matched || typeof matched !== "object") {
+    throw err("TCB_STATUS_REJECTED", "no TCB Info level matches PCK SGX TCB and quote TEE_TCB_SVN");
+  }
+  const status = matched["tcbStatus"];
+  if (typeof status !== "string" || !ACCEPTED_TCB_STATUSES.has(status)) {
+    throw err("TCB_STATUS_REJECTED", `TCB status ${String(status)} is not accepted`);
+  }
+  verifyTdxModuleIdentity(tcbInfo, body, teeTcbSvn);
+}
+function verifyQeIdentity(identity, qeReport, now) {
+  if (identity.id !== "TD_QE") {
+    throw err("QE_IDENTITY_REJECTED", `QE Identity id ${String(identity.id)} is not TD_QE`);
+  }
+  if (identity.version !== 2) {
+    throw err(
+      "QE_IDENTITY_REJECTED",
+      `unsupported QE Identity version ${String(identity.version)}`
+    );
+  }
+  assertFreshDcapJsonWindow(identity, "QE Identity", now);
+  assertMaskedHexMatches({
+    actual: qeReport.subarray(SGX_REPORT_MISCSELECT_OFF, SGX_REPORT_MISCSELECT_OFF + 4),
+    expectedHex: identity.miscselect,
+    maskHex: identity.miscselectMask,
+    label: "QE Identity MISCSELECT",
+    reason: "QE_IDENTITY_REJECTED"
+  });
+  assertMaskedHexMatches({
+    actual: qeReport.subarray(SGX_REPORT_ATTRIBUTES_OFF, SGX_REPORT_ATTRIBUTES_OFF + 16),
+    expectedHex: identity.attributes,
+    maskHex: identity.attributesMask,
+    label: "QE Identity ATTRIBUTES",
+    reason: "QE_IDENTITY_REJECTED"
+  });
+  const expectedMrSigner = bytesToHex2(
+    qeReport.subarray(SGX_REPORT_MRSIGNER_OFF, SGX_REPORT_MRSIGNER_OFF + 32)
+  );
+  if (typeof identity.mrsigner !== "string" || identity.mrsigner.toLowerCase() !== expectedMrSigner) {
+    throw err(
+      "QE_IDENTITY_REJECTED",
+      `QE Identity MRSIGNER ${String(identity.mrsigner)} does not match QE report ${expectedMrSigner}`
+    );
+  }
+  const isvProdId = readU16LE(qeReport, SGX_REPORT_ISV_PROD_ID_OFF);
+  if (identity.isvprodid !== isvProdId) {
+    throw err(
+      "QE_IDENTITY_REJECTED",
+      `QE Identity ISVProdID ${String(identity.isvprodid)} does not match QE report ${isvProdId}`
+    );
+  }
+  if (!Array.isArray(identity.tcbLevels)) {
+    throw err("QE_IDENTITY_REJECTED", "QE Identity has no tcbLevels array");
+  }
+  const isvSvn = readU16LE(qeReport, SGX_REPORT_ISV_SVN_OFF);
+  const matched = identity.tcbLevels.find((level) => qeIdentityLevelMatches(level, isvSvn));
+  if (!matched || typeof matched !== "object") {
+    throw err("QE_IDENTITY_REJECTED", "no QE Identity level matches QE report ISVSVN");
+  }
+  const status = matched["tcbStatus"];
+  if (typeof status !== "string" || !ACCEPTED_QE_IDENTITY_STATUSES.has(status)) {
+    throw err("QE_IDENTITY_REJECTED", `QE Identity status ${String(status)} is not accepted`);
+  }
+}
+function tdxTcbLevelMatches(level, pckTcb, teeTcbSvn) {
+  if (!level || typeof level !== "object") return false;
+  const tcb = level["tcb"];
+  if (!tcb || typeof tcb !== "object") return false;
+  const record = tcb;
+  const sgxComponents = record["sgxtcbcomponents"];
+  if (!tcbComponentsMatch(sgxComponents, pckTcb.sgxTcbSvns, 0)) return false;
+  const pceSvn = record["pcesvn"];
+  if (typeof pceSvn !== "number" || pckTcb.pceSvn < pceSvn) return false;
+  const tdxComponents = record["tdxtcbcomponents"];
+  const tdxStartIndex = teeTcbSvn[1] === 0 ? 0 : 2;
+  return tcbComponentsMatch(tdxComponents, Array.from(teeTcbSvn), tdxStartIndex);
+}
+function tcbComponentsMatch(components, actualSvns, startIndex) {
+  if (!Array.isArray(components) || components.length < 16) return false;
+  for (let index = startIndex; index < 16; index++) {
+    const component = components[index];
+    if (!component || typeof component !== "object") return false;
+    const svn = component["svn"];
+    if (typeof svn !== "number" || actualSvns[index] < svn) return false;
+  }
+  return true;
+}
+function verifyTdxModuleIdentity(tcbInfo, body, teeTcbSvn) {
+  const moduleVersion = teeTcbSvn[1];
+  const identity = getTdxModuleIdentity(tcbInfo, moduleVersion);
+  const expectedMrSigner = bytesToHex2(
+    body.subarray(BODY_MRSIGNERSEAM_OFF, BODY_MRSIGNERSEAM_OFF + 48)
+  );
+  if (typeof identity["mrsigner"] !== "string" || identity["mrsigner"].toLowerCase() !== expectedMrSigner) {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      `TDX Module Identity MRSIGNER ${String(identity["mrsigner"])} does not match quote ${expectedMrSigner}`
+    );
+  }
+  assertMaskedHexMatches({
+    actual: body.subarray(BODY_SEAM_ATTRIBUTES_OFF, BODY_SEAM_ATTRIBUTES_OFF + 8),
+    expectedHex: identity["attributes"],
+    maskHex: identity["attributesMask"],
+    label: "TDX Module Identity ATTRIBUTES",
+    reason: "TCB_STATUS_REJECTED"
+  });
+  if (moduleVersion < 1) return;
+  const tcbLevels = identity["tcbLevels"];
+  if (!Array.isArray(tcbLevels)) {
+    throw err("TCB_STATUS_REJECTED", "TDX Module Identity has no tcbLevels array");
+  }
+  const matched = tcbLevels.find((level) => tdxModuleTcbLevelMatches(level, teeTcbSvn[0]));
+  if (!matched || typeof matched !== "object") {
+    throw err("TCB_STATUS_REJECTED", "no TDX Module Identity level matches TEE_TCB_SVN ISVSVN");
+  }
+  const status = matched["tcbStatus"];
+  if (typeof status !== "string" || !ACCEPTED_TDX_MODULE_STATUSES.has(status)) {
+    throw err("TCB_STATUS_REJECTED", `TDX Module status ${String(status)} is not accepted`);
+  }
+}
+function getTdxModuleIdentity(tcbInfo, moduleVersion) {
+  if (moduleVersion < 1) {
+    const module = tcbInfo.tdxModule;
+    if (!module || typeof module !== "object" || Array.isArray(module)) {
+      throw err("TCB_STATUS_REJECTED", "TCB Info has no tdxModule object");
+    }
+    return module;
+  }
+  const identities = tcbInfo.tdxModuleIdentities;
+  if (!Array.isArray(identities)) {
+    throw err("TCB_STATUS_REJECTED", "TCB Info has no tdxModuleIdentities array");
+  }
+  const moduleIdentity = identities.find((candidate) => {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return false;
+    const id = candidate["id"];
+    return typeof id === "string" && tdxModuleIdMatches(id, moduleVersion);
+  });
+  if (!moduleIdentity || typeof moduleIdentity !== "object") {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      `no TDX Module Identity matches TEE_TCB_SVN module version ${moduleVersion}`
+    );
+  }
+  return moduleIdentity;
+}
+function tdxModuleIdMatches(id, moduleVersion) {
+  const match = /^TDX_(\d+)$/.exec(id);
+  return match !== null && Number.parseInt(match[1], 10) === moduleVersion;
+}
+function tdxModuleTcbLevelMatches(level, isvSvn) {
+  if (!level || typeof level !== "object") return false;
+  const tcb = level["tcb"];
+  if (!tcb || typeof tcb !== "object") return false;
+  const record = tcb;
+  const required = typeof record["isvsvn"] === "number" ? record["isvsvn"] : typeof record["isvnsvn"] === "number" ? record["isvnsvn"] : void 0;
+  return typeof required === "number" && isvSvn >= required;
+}
+function qeIdentityLevelMatches(level, isvSvn) {
+  if (!level || typeof level !== "object") return false;
+  const tcb = level["tcb"];
+  if (!tcb || typeof tcb !== "object") return false;
+  const requiredIsvSvn = tcb["isvsvn"];
+  return typeof requiredIsvSvn === "number" && isvSvn >= requiredIsvSvn;
+}
+function assertMaskedHexMatches(params) {
+  const { actual, expectedHex, maskHex, label, reason } = params;
+  if (typeof expectedHex !== "string" || !isHexByteLength(expectedHex, actual.length)) {
+    throw err(reason, `${label} is missing or not ${actual.length} bytes of hex`);
+  }
+  if (typeof maskHex !== "string" || !isHexByteLength(maskHex, actual.length)) {
+    throw err(reason, `${label} mask is missing or not ${actual.length} bytes of hex`);
+  }
+  const expected = hexToBytes2(expectedHex);
+  const mask = hexToBytes2(maskHex);
+  for (let index = 0; index < actual.length; index++) {
+    if ((actual[index] & mask[index]) !== (expected[index] & mask[index])) {
+      throw err(reason, `${label} masked byte ${index} does not match signed collateral policy`);
+    }
+  }
+}
+function isHexByteLength(value, byteLength) {
+  return value.length === byteLength * 2 && /^[0-9a-f]+$/i.test(value);
+}
+function assertFreshDcapJsonWindow(value, label, now) {
+  if (typeof value.issueDate !== "string" || typeof value.nextUpdate !== "string") {
+    throw err("DCAP_COLLATERAL_PARSE", `${label} is missing issueDate or nextUpdate`);
+  }
+  const issueDate = new Date(value.issueDate);
+  const nextUpdate = new Date(value.nextUpdate);
+  if (Number.isNaN(issueDate.getTime()) || Number.isNaN(nextUpdate.getTime())) {
+    throw err("DCAP_COLLATERAL_PARSE", `${label} has invalid issueDate or nextUpdate`);
+  }
+  if (now < issueDate) {
+    throw err("TCB_STATUS_REJECTED", `${label} is not yet valid`);
+  }
+  if (now > nextUpdate) {
+    throw err("TCB_STATUS_REJECTED", `${label} is stale past nextUpdate`);
+  }
+}
+function parseCrl(pem, label) {
+  if (typeof pem !== "string" || pem.length === 0) {
+    throw err("DCAP_COLLATERAL_MISSING", `${label} is missing`);
+  }
+  try {
+    return new x509.X509Crl(pem);
+  } catch (e) {
+    throw err("DCAP_COLLATERAL_PARSE", `${label} is not a parseable X.509 CRL: ${e}`);
+  }
+}
+async function verifyCrl(crl, issuer, label, now) {
+  if (crl.issuer !== issuer.subject) {
+    throw err(
+      "DCAP_COLLATERAL_SIGNATURE",
+      `${label} issuer ${crl.issuer} does not match expected ${issuer.subject}`
+    );
+  }
+  if (now < crl.thisUpdate) {
+    throw err("TCB_STATUS_REJECTED", `${label} is not yet valid`);
+  }
+  if (!crl.nextUpdate || now > crl.nextUpdate) {
+    throw err("TCB_STATUS_REJECTED", `${label} is stale past nextUpdate`);
+  }
+  let ok;
+  try {
+    ok = await crl.verify({ publicKey: issuer });
+  } catch (e) {
+    throw err("DCAP_COLLATERAL_SIGNATURE", `${label} signature verification threw: ${e}`);
+  }
+  if (!ok) {
+    throw err("DCAP_COLLATERAL_SIGNATURE", `${label} signature verification failed`);
+  }
+}
+async function assertNotRevokedByRoot(rootCrl, cert, label) {
+  if (rootCrl.findRevoked(cert)) {
+    throw err("DCAP_COLLATERAL_REVOKED", `${label} is revoked by Intel root CRL`);
+  }
+}
+async function assertSameCertificate(actual, expected, label) {
+  const actualFp = await sha256Hex(new Uint8Array(actual.rawData));
+  const expectedFp = await sha256Hex(new Uint8Array(expected.rawData));
+  if (actualFp !== expectedFp) {
+    throw err(
+      "DCAP_COLLATERAL_SIGNATURE",
+      `${label} fingerprint ${actualFp} does not match quote chain issuer ${expectedFp}`
+    );
+  }
+}
+function parsePemCertificateChain(pem, label, minCerts) {
+  if (typeof pem !== "string" || pem.length === 0) {
+    throw err("DCAP_COLLATERAL_MISSING", `${label} is missing`);
+  }
+  const matches = pem.match(/-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/g) ?? [];
+  if (matches.length < minCerts) {
+    throw err(
+      "DCAP_COLLATERAL_PARSE",
+      `${label} has ${matches.length} cert(s), expected at least ${minCerts}`
+    );
+  }
+  return matches.map((certPem, index) => {
+    try {
+      return new x509.X509Certificate(certPem);
+    } catch (e) {
+      throw err("DCAP_COLLATERAL_PARSE", `${label} cert[${index}] is not parseable: ${e}`);
+    }
+  });
+}
+function extractPckTcb(cert) {
+  const sgxExtensions = cert.getExtension(INTEL_PCK_SGX_EXTENSIONS_OID);
+  if (sgxExtensions) {
+    return parsePckSgxExtensions(new Uint8Array(sgxExtensions.value));
+  }
+  return {
+    fmspc: extractPckExtensionHex(cert, INTEL_PCK_EXTENSION_FMSPC_OID, 6, "FMSPC"),
+    pceId: extractPckExtensionHex(cert, INTEL_PCK_EXTENSION_PCE_ID_OID, 2, "PCE ID"),
+    sgxTcbSvns: Array.from(
+      { length: 16 },
+      (_, index) => extractPckIntegerExtension(
+        cert,
+        `${INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX}${index + 1}`,
+        `SGX TCB component ${index + 1}`
+      )
+    ),
+    pceSvn: extractPckIntegerExtension(cert, INTEL_PCK_EXTENSION_PCESVN_OID, "PCESVN"),
+    cpuSvn: hexToBytes2(extractPckExtensionHex(cert, INTEL_PCK_EXTENSION_CPUSVN_OID, 16, "CPUSVN"))
+  };
+}
+function parsePckSgxExtensions(bytes) {
+  const topLevel = unwrapDerOctetStringIfPresent(bytes);
+  const extensions = derChildren(expectDerTag(readDerTlv(topLevel, 0), 48, "SGX extensions"));
+  const parsed = {};
+  for (const extension of extensions) {
+    const contextTag = contextSpecificTagNumber(extension);
+    if (contextTag === 2) {
+      parsed.pceId = bytesToHex2(readContextOctetString(extension, "PCE ID"));
+      continue;
+    }
+    if (contextTag === 3) {
+      parsed.fmspc = bytesToHex2(readContextOctetString(extension, "FMSPC"));
+      continue;
+    }
+    if (contextTag === 1) {
+      const tcb = parsePckTcbExtension(extension);
+      parsed.sgxTcbSvns = tcb.sgxTcbSvns;
+      parsed.pceSvn = tcb.pceSvn;
+      parsed.cpuSvn = tcb.cpuSvn;
+      continue;
+    }
+    const children = derChildren(expectDerTag(extension, 48, "SGX extension item"));
+    if (children.length !== 2) {
+      throw err("TCB_STATUS_REJECTED", "PCK SGX extension item does not contain OID and value");
+    }
+    const oid = readDerOid(children[0]);
+    const value = children[1];
+    if (oid === INTEL_PCK_EXTENSION_PCE_ID_OID) {
+      parsed.pceId = bytesToHex2(readPckChoiceOctetString(value, 2, "PCE ID"));
+    } else if (oid === INTEL_PCK_EXTENSION_FMSPC_OID) {
+      parsed.fmspc = bytesToHex2(readPckChoiceOctetString(value, 3, "FMSPC"));
+    } else if (oid === INTEL_PCK_EXTENSION_TCB_OID) {
+      const tcb = parsePckTcbExtension(value);
+      parsed.sgxTcbSvns = tcb.sgxTcbSvns;
+      parsed.pceSvn = tcb.pceSvn;
+      parsed.cpuSvn = tcb.cpuSvn;
+    }
+  }
+  if (parsed.fmspc === void 0 || parsed.pceId === void 0 || parsed.sgxTcbSvns === void 0 || parsed.pceSvn === void 0 || parsed.cpuSvn === void 0) {
+    throw err("TCB_STATUS_REJECTED", "PCK SGX extension is missing FMSPC, PCE ID, or TCB fields");
+  }
+  return parsed;
+}
+function parsePckTcbExtension(value) {
+  const tcbItems = pckTcbChildren(value);
+  const sgxTcbSvns = [];
+  let pceSvn;
+  let cpuSvn;
+  for (const item of tcbItems) {
+    const contextTag = contextSpecificTagNumber(item);
+    if (contextTag !== null) {
+      if (contextTag === 16) {
+        pceSvn = readContextInteger(item, "PCESVN");
+      } else if (contextTag === 17) {
+        cpuSvn = readContextOctetString(item, "CPUSVN");
+      } else if (contextTag >= 0 && contextTag <= 15) {
+        sgxTcbSvns[contextTag] = readContextInteger(item, `SGX TCB component ${contextTag + 1}`);
+      }
+      continue;
+    }
+    const children = derChildren(expectDerTag(item, 48, "PCK TCB item"));
+    if (children.length !== 2) {
+      throw err("TCB_STATUS_REJECTED", "PCK TCB item does not contain OID and value");
+    }
+    const oid = readDerOid(children[0]);
+    const valueTlv = children[1];
+    if (oid === INTEL_PCK_EXTENSION_PCESVN_OID) {
+      pceSvn = readPckChoiceInteger(valueTlv, 16, "PCESVN");
+    } else if (oid === INTEL_PCK_EXTENSION_CPUSVN_OID) {
+      cpuSvn = readPckChoiceOctetString(valueTlv, 17, "CPUSVN");
+    } else if (oid.startsWith(INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX)) {
+      const index = Number.parseInt(
+        oid.slice(INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX.length),
+        10
+      );
+      if (!Number.isInteger(index) || index < 1 || index > 16) {
+        throw err("TCB_STATUS_REJECTED", `PCK TCB component OID ${oid} is out of range`);
+      }
+      sgxTcbSvns[index - 1] = readPckChoiceInteger(
+        valueTlv,
+        index - 1,
+        `SGX TCB component ${index}`
+      );
+    }
+  }
+  if (sgxTcbSvns.length !== 16 || Array.from({ length: 16 }, (_, index) => sgxTcbSvns[index]).some((svn) => svn === void 0)) {
+    throw err("TCB_STATUS_REJECTED", "PCK TCB extension is missing SGX TCB components");
+  }
+  if (pceSvn === void 0 || cpuSvn === void 0) {
+    throw err("TCB_STATUS_REJECTED", "PCK TCB extension is missing PCESVN or CPUSVN");
+  }
+  if (cpuSvn.length !== 16) {
+    throw err("TCB_STATUS_REJECTED", `PCK CPUSVN has ${cpuSvn.length} bytes, expected 16`);
+  }
+  return { sgxTcbSvns, pceSvn, cpuSvn };
+}
+function extractPckExtensionHex(cert, oid, expectedBytes, label) {
+  const ext = cert.getExtension(oid);
+  if (!ext) {
+    throw err("TCB_STATUS_REJECTED", `PCK leaf is missing ${label} extension ${oid}`);
+  }
+  const decoded = unwrapDerOctetStringIfPresent(new Uint8Array(ext.value));
+  if (decoded.length !== expectedBytes) {
+    throw err(
+      "TCB_STATUS_REJECTED",
+      `PCK ${label} extension has ${decoded.length} bytes, expected ${expectedBytes}`
+    );
+  }
+  return bytesToHex2(decoded);
+}
+function extractPckIntegerExtension(cert, oid, label) {
+  const ext = cert.getExtension(oid);
+  if (!ext) {
+    throw err("TCB_STATUS_REJECTED", `PCK leaf is missing ${label} extension ${oid}`);
+  }
+  return readDerInteger(readDerTlv(new Uint8Array(ext.value), 0), label);
+}
+function readDerTlv(source, start) {
+  if (start + 2 > source.length) {
+    throw err("TCB_STATUS_REJECTED", "truncated DER value");
+  }
+  const tag = source[start];
+  let offset = start + 1;
+  const firstLength = source[offset++];
+  let length;
+  if ((firstLength & 128) === 0) {
+    length = firstLength;
+  } else {
+    const octets = firstLength & 127;
+    if (octets === 0 || octets > 4 || offset + octets > source.length) {
+      throw err("TCB_STATUS_REJECTED", "unsupported DER length");
+    }
+    length = 0;
+    for (let i = 0; i < octets; i++) {
+      length = length << 8 | source[offset++];
+    }
+  }
+  const valueStart = offset;
+  const valueEnd = valueStart + length;
+  if (valueEnd > source.length) {
+    throw err("TCB_STATUS_REJECTED", "DER value length exceeds buffer");
+  }
+  return { tag, start, valueStart, valueEnd, end: valueEnd, source };
+}
+function expectDerTag(tlv, tag, label) {
+  if (tlv.tag !== tag) {
+    throw err("TCB_STATUS_REJECTED", `${label} has DER tag 0x${tlv.tag.toString(16)}`);
+  }
+  return tlv;
+}
+function derChildren(tlv) {
+  const children = [];
+  let offset = tlv.valueStart;
+  while (offset < tlv.valueEnd) {
+    const child = readDerTlv(tlv.source, offset);
+    if (child.end > tlv.valueEnd) {
+      throw err("TCB_STATUS_REJECTED", "DER child exceeds parent");
+    }
+    children.push(child);
+    offset = child.end;
+  }
+  return children;
+}
+function readDerOid(tlv) {
+  expectDerTag(tlv, 6, "OID");
+  const bytes = tlv.source.subarray(tlv.valueStart, tlv.valueEnd);
+  if (bytes.length === 0) {
+    throw err("TCB_STATUS_REJECTED", "empty DER OID");
+  }
+  const parts = [Math.floor(bytes[0] / 40), bytes[0] % 40];
+  let value = 0;
+  for (const byte of bytes.subarray(1)) {
+    value = value << 7 | byte & 127;
+    if ((byte & 128) === 0) {
+      parts.push(value);
+      value = 0;
+    }
+  }
+  if (value !== 0) {
+    throw err("TCB_STATUS_REJECTED", "truncated DER OID");
+  }
+  return parts.join(".");
+}
+function readDerInteger(tlv, label) {
+  expectDerTag(tlv, 2, label);
+  const bytes = tlv.source.subarray(tlv.valueStart, tlv.valueEnd);
+  if (bytes.length === 0 || (bytes[0] & 128) !== 0) {
+    throw err("TCB_STATUS_REJECTED", `${label} is not a positive DER integer`);
+  }
+  let value = 0;
+  for (const byte of bytes) value = value << 8 | byte;
+  return value;
+}
+function readDerOctetString(tlv, label) {
+  expectDerTag(tlv, 4, label);
+  return tlv.source.subarray(tlv.valueStart, tlv.valueEnd);
+}
+function pckTcbChildren(value) {
+  if (contextSpecificTagNumber(value) === 1) {
+    if ((value.tag & 32) === 0) {
+      throw err("TCB_STATUS_REJECTED", "PCK TCB field is not constructed");
+    }
+    const children = derChildren(value);
+    if (children.length === 1 && children[0].tag === 48) {
+      return derChildren(children[0]);
+    }
+    return children;
+  }
+  return derChildren(expectDerTag(value, 48, "PCK TCB extension"));
+}
+function readPckChoiceInteger(tlv, expectedTag, label) {
+  const contextTag = contextSpecificTagNumber(tlv);
+  if (contextTag !== null) {
+    if (contextTag !== expectedTag) {
+      throw err(
+        "TCB_STATUS_REJECTED",
+        `${label} uses context tag ${contextTag}, expected ${expectedTag}`
+      );
+    }
+    return readContextInteger(tlv, label);
+  }
+  return readDerInteger(tlv, label);
+}
+function readPckChoiceOctetString(tlv, expectedTag, label) {
+  const contextTag = contextSpecificTagNumber(tlv);
+  if (contextTag !== null) {
+    if (contextTag !== expectedTag) {
+      throw err(
+        "TCB_STATUS_REJECTED",
+        `${label} uses context tag ${contextTag}, expected ${expectedTag}`
+      );
+    }
+    return readContextOctetString(tlv, label);
+  }
+  return readDerOctetString(tlv, label);
+}
+function contextSpecificTagNumber(tlv) {
+  if ((tlv.tag & 192) !== 128) return null;
+  const tagNumber = tlv.tag & 31;
+  return tagNumber === 31 ? null : tagNumber;
+}
+function readContextInner(tlv) {
+  if ((tlv.tag & 32) === 0) {
+    throw err("TCB_STATUS_REJECTED", "PCK context-specific field is not constructed");
+  }
+  const children = derChildren(tlv);
+  if (children.length !== 1) {
+    throw err("TCB_STATUS_REJECTED", "PCK context-specific field has multiple values");
+  }
+  return children[0];
+}
+function readContextInteger(tlv, label) {
+  const inner = (tlv.tag & 32) !== 0 ? readContextInner(tlv) : tlv;
+  if ((tlv.tag & 32) !== 0) return readDerInteger(inner, label);
+  return readDerIntegerValue(inner.source.subarray(inner.valueStart, inner.valueEnd), label);
+}
+function readContextOctetString(tlv, label) {
+  const inner = (tlv.tag & 32) !== 0 ? readContextInner(tlv) : tlv;
+  if ((tlv.tag & 32) !== 0) return readDerOctetString(inner, label);
+  return inner.source.subarray(inner.valueStart, inner.valueEnd);
+}
+function readDerIntegerValue(bytes, label) {
+  if (bytes.length === 0 || (bytes[0] & 128) !== 0) {
+    throw err("TCB_STATUS_REJECTED", `${label} is not a positive DER integer`);
+  }
+  let value = 0;
+  for (const byte of bytes) value = value << 8 | byte;
+  return value;
+}
+function unwrapDerOctetStringIfPresent(bytes) {
+  if (bytes.length >= 2 && bytes[0] === 4) {
+    const tlv = readDerTlv(bytes, 0);
+    if (tlv.end === bytes.length) return bytes.subarray(tlv.valueStart, tlv.valueEnd);
+  }
+  return bytes;
+}
+function hexToBytes2(hex) {
+  if (hex.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(hex)) {
+    throw err("DCAP_COLLATERAL_PARSE", "invalid hex string");
+  }
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+var MAA_JKU_PATTERN = /^https:\/\/[a-z0-9-]+\.[a-z0-9]+\.attest\.azure\.net\/certs$/;
+function b64urlDecodeStr(s) {
+  const padded = s.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - s.length % 4) % 4);
+  return atob(padded);
+}
+function b64urlDecodeBytes(s) {
+  const decoded = b64urlDecodeStr(s);
+  const out = new Uint8Array(decoded.length);
+  for (let i = 0; i < decoded.length; i++) out[i] = decoded.charCodeAt(i);
+  return out;
+}
+async function verifyAzureMaaToken(token, policy, timeoutMs = DEFAULT_AZURE_JWKS_TIMEOUT_MS) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw err("MAA_TOKEN_PARSE", `MAA token is not a valid JWT (${parts.length} parts)`);
+  }
+  const [headerB64, payloadB64, sigB64] = parts;
+  let header;
+  let payload;
+  try {
+    header = JSON.parse(b64urlDecodeStr(headerB64));
+    payload = JSON.parse(b64urlDecodeStr(payloadB64));
+  } catch (e) {
+    throw err("MAA_TOKEN_PARSE", `failed to decode MAA JWT header/payload: ${e}`);
+  }
+  const exp = payload["exp"];
+  if (typeof exp === "number" && Math.floor(Date.now() / 1e3) > exp) {
+    throw err("MAA_TOKEN_EXPIRED", `MAA JWT expired at ${new Date(exp * 1e3).toISOString()}`);
+  }
+  const jku = header["jku"];
+  const kid = header["kid"];
+  if (!jku || !kid) {
+    throw err("MAA_TOKEN_PARSE", "MAA JWT header missing jku or kid");
+  }
+  if (payload["iss"] !== policy.expectedIssuer) {
+    throw err(
+      "MAA_ISSUER_MISMATCH",
+      `MAA JWT issuer ${String(payload["iss"])} does not match pinned ${policy.expectedIssuer}`
+    );
+  }
+  if (jku !== policy.expectedJwksUrl) {
+    throw err(
+      "MAA_JWKS_MISMATCH",
+      `MAA JWT jku ${jku} does not match pinned ${policy.expectedJwksUrl}`
+    );
+  }
+  if (!MAA_JKU_PATTERN.test(policy.expectedJwksUrl)) {
+    throw err(
+      "MAA_JWKS_MISMATCH",
+      `pinned MAA JWKS URL does not match Azure attestation domain: ${policy.expectedJwksUrl}`
+    );
+  }
+  if (payload["x-ms-policy-hash"] !== policy.expectedPolicyHash) {
+    throw err(
+      "MAA_POLICY_HASH_MISMATCH",
+      `MAA policy hash ${String(payload["x-ms-policy-hash"])} does not match pinned ${policy.expectedPolicyHash}`
+    );
+  }
+  let jwks;
+  try {
+    jwks = await fetchMaaJwks(policy.expectedJwksUrl, timeoutMs);
+  } catch (e) {
+    throw err(
+      "MAA_TOKEN_SIGNATURE",
+      `failed to fetch MAA JWKS from ${policy.expectedJwksUrl}: ${e}`
+    );
+  }
+  const jwk = jwks.keys.find((k) => k.kid === kid);
+  if (!jwk) {
+    throw err("MAA_TOKEN_SIGNATURE", `no key with kid=${kid} found in MAA JWKS`);
+  }
+  let sigPubKey;
+  try {
+    sigPubKey = await crypto.subtle.importKey(
+      "jwk",
+      { kty: "RSA", n: jwk.n, e: jwk.e, alg: "RS256", ext: true },
+      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+  } catch (e) {
+    throw err("MAA_TOKEN_SIGNATURE", `failed to import MAA JWK: ${e}`);
+  }
+  const msg = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
+  const sig = b64urlDecodeBytes(sigB64);
+  const valid = await crypto.subtle.verify(
+    { name: "RSASSA-PKCS1-v1_5" },
+    sigPubKey,
+    sig,
+    msg
+  );
+  if (!valid) {
+    throw err("MAA_TOKEN_SIGNATURE", "MAA JWT RS256 signature verification failed");
+  }
+  if (payload["x-ms-compliance-status"] !== "azure-compliant-cvm") {
+    throw err(
+      "MAA_COMPLIANCE_MISMATCH",
+      `MAA compliance status: "${payload["x-ms-compliance-status"]}" (expected "azure-compliant-cvm")`
+    );
+  }
+  if (payload["tdx_td_attributes_debug"] !== false) {
+    throw err("MAA_DEBUG_BIT_SET", "MAA token reports TDX debug bit set");
+  }
+  const reportData = payload["tdx_report_data"];
+  if (typeof reportData !== "string" || !/^[0-9a-f]{128}$/i.test(reportData)) {
+    throw err("MAA_REPORTDATA_MISMATCH", "MAA token missing valid 64-byte tdx_report_data claim");
+  }
+  return {
+    reportData: reportData.toLowerCase(),
+    mrtd: readMaaMeasurement(payload, "tdx_mrtd"),
+    rtmr0: readMaaMeasurement(payload, "tdx_rtmr0"),
+    rtmr1: readMaaMeasurement(payload, "tdx_rtmr1"),
+    rtmr2: readMaaMeasurement(payload, "tdx_rtmr2"),
+    rtmr3: readMaaMeasurement(payload, "tdx_rtmr3")
+  };
+}
+function readMaaMeasurement(payload, claim) {
+  const value = payload[claim];
+  if (typeof value !== "string" || !/^[0-9a-f]{96}$/i.test(value)) {
+    throw err("MAA_REPORTDATA_MISMATCH", `MAA token missing valid ${claim} claim`);
+  }
+  return value.toLowerCase();
+}
+function assertMaaMeasurementsMatchDcap(maa, dcap) {
+  const fields = ["mrtd", "rtmr0", "rtmr1", "rtmr2", "rtmr3"];
+  for (const field of fields) {
+    if (maa[field] !== dcap[field]) {
+      throw err(
+        "MAA_REPORTDATA_MISMATCH",
+        `MAA ${field} ${maa[field]} does not match DCAP quote ${field.toUpperCase()} ${dcap[field]}`
+      );
+    }
+  }
+}
+async function fetchMaaJwks(url, timeoutMs) {
+  const boundedTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_AZURE_JWKS_TIMEOUT_MS;
+  const controller = new AbortController();
+  let timeoutId = null;
+  const timeout = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`timed out after ${boundedTimeoutMs}ms`));
+    }, boundedTimeoutMs);
+  });
+  try {
+    return await Promise.race([
+      (async () => {
+        const resp = await fetch(url, { signal: controller.signal });
+        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+        return await resp.json();
+      })(),
+      timeout
+    ]);
+  } finally {
+    if (timeoutId !== null) clearTimeout(timeoutId);
+  }
+}
+async function verifyTpmQuoteNonce(tpmQuoteB64, akPubKey, expectedNonce, expectedNoiseStaticPub, expectedBinaryHash) {
+  let raw;
+  try {
+    raw = base64ToBytes(tpmQuoteB64);
+  } catch (e) {
+    throw err("TPM_QUOTE_SIGNATURE", `failed to decode tpm_quote: ${e}`);
+  }
+  if (raw.length < 8) {
+    throw err("TPM_QUOTE_SIGNATURE", "tpm_quote too short");
+  }
+  const msgLen = new DataView(raw.buffer, raw.byteOffset).getUint32(
+    0,
+    true
+    /* little-endian */
+  );
+  if (4 + msgLen > raw.length) {
+    throw err("TPM_QUOTE_SIGNATURE", `tpm_quote msg_len=${msgLen} exceeds buffer`);
+  }
+  const tpmsAttest = raw.slice(4, 4 + msgLen);
+  const sigBlob = raw.slice(4 + msgLen);
+  if (sigBlob.length < 6) {
+    throw err("TPM_QUOTE_SIGNATURE", "TPMT_SIGNATURE too short");
+  }
+  const sigSize = sigBlob[4] << 8 | sigBlob[5];
+  const sigBytes = sigBlob.slice(6, 6 + sigSize);
+  if (sigBytes.length !== sigSize) {
+    throw err(
+      "TPM_QUOTE_SIGNATURE",
+      `TPMT_SIGNATURE truncated: need ${sigSize}, have ${sigBytes.length}`
+    );
+  }
+  const valid = await crypto.subtle.verify(
+    { name: "RSASSA-PKCS1-v1_5" },
+    akPubKey,
+    sigBytes,
+    tpmsAttest
+  );
+  if (!valid) {
+    throw err("TPM_QUOTE_SIGNATURE", "TPM AK RSA signature verification failed");
+  }
+  const qdInput = new Uint8Array(
+    expectedNonce.length + expectedNoiseStaticPub.length + expectedBinaryHash.length
+  );
+  qdInput.set(expectedNonce, 0);
+  qdInput.set(expectedNoiseStaticPub, expectedNonce.length);
+  qdInput.set(expectedBinaryHash, expectedNonce.length + expectedNoiseStaticPub.length);
+  const expectedQd = new Uint8Array(await crypto.subtle.digest("SHA-256", qdInput));
+  const extraData = readTpmsAttestExtraData(tpmsAttest);
+  if (!constantTimeEq(extraData, expectedQd)) {
+    throw err(
+      "TPM_NONCE_MISMATCH",
+      "TPMS_ATTEST extraData does not equal SHA-256(nonce || noise_pubkey || binary_hash)"
+    );
+  }
+}
+function readTpmsAttestExtraData(tpmsAttest) {
+  if (tpmsAttest.length < 10) {
+    throw err("TPM_QUOTE_SIGNATURE", "TPMS_ATTEST too short");
+  }
+  const view = new DataView(tpmsAttest.buffer, tpmsAttest.byteOffset, tpmsAttest.byteLength);
+  const magic = view.getUint32(0, false);
+  if (magic !== TPM_GENERATED_VALUE) {
+    throw err(
+      "TPM_QUOTE_SIGNATURE",
+      `TPMS_ATTEST magic ${magic.toString(16)} is not TPM_GENERATED_VALUE`
+    );
+  }
+  const attestType = view.getUint16(4, false);
+  if (attestType !== TPM_ST_ATTEST_QUOTE) {
+    throw err("TPM_QUOTE_SIGNATURE", `TPMS_ATTEST type ${attestType.toString(16)} is not quote`);
+  }
+  let offset = 6;
+  offset = readTpm2b(tpmsAttest, offset, "qualifiedSigner").nextOffset;
+  return readTpm2b(tpmsAttest, offset, "extraData").data;
+}
+function readTpm2b(bytes, offset, label) {
+  if (offset + 2 > bytes.length) {
+    throw err("TPM_QUOTE_SIGNATURE", `TPMS_ATTEST truncated before ${label} size`);
+  }
+  const size = bytes[offset] << 8 | bytes[offset + 1];
+  const start = offset + 2;
+  const end = start + size;
+  if (end > bytes.length) {
+    throw err("TPM_QUOTE_SIGNATURE", `TPMS_ATTEST truncated in ${label}`);
+  }
+  return { data: bytes.slice(start, end), nextOffset: end };
+}
+function base64ToBytes(b64) {
+  const normalized = b64.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+  const binaryStr = atob(padded);
+  const out = new Uint8Array(binaryStr.length);
+  for (let i = 0; i < binaryStr.length; i++) out[i] = binaryStr.charCodeAt(i);
+  return out;
+}
+async function verifyAzureTdxAttestation(params) {
+  const { raw, response, expectedNonce, expectedNoiseStaticPub, policy, timeoutMs } = params;
+  const body = raw.subarray(BODY_OFFSET, BODY_OFFSET + BODY_SIZE);
+  const dcapMeasurements = parseMeasurements(body);
+  const reportData = body.subarray(
+    BODY_REPORT_DATA_OFF,
+    BODY_REPORT_DATA_OFF + BODY_REPORT_DATA_LEN
+  );
+  await verifyDcapQuoteAndCollateral({ raw, body, response, policy });
+  assertDebugBitClear(body);
+  if (!response.maa_token) {
+    throw err("MAA_TOKEN_MISSING", "azure-tdx-dcap response missing maa_token");
+  }
+  if (!policy.azureMaa) {
+    throw err(
+      "MAA_TRUST_POLICY_MISSING",
+      "azure-tdx-dcap attestation requires pinned MAA issuer, JWKS URL, and policy hash"
+    );
+  }
+  const measurements = await verifyAzureMaaToken(response.maa_token, policy.azureMaa, timeoutMs);
+  const reportDataHex = bytesToHex2(reportData);
+  if (measurements.reportData !== reportDataHex) {
+    throw err(
+      "MAA_REPORTDATA_MISMATCH",
+      `MAA tdx_report_data ${measurements.reportData} does not match DCAP REPORTDATA ${reportDataHex}`
+    );
+  }
+  assertMaaMeasurementsMatchDcap(measurements, dcapMeasurements);
+  assertRuntimeMeasurementsMatch(dcapMeasurements, policy);
+  if (!response.hcl_keys_json) {
+    throw err("HCL_KEYS_MISSING", "azure-tdx-dcap response missing hcl_keys_json");
+  }
+  let hclKeysBytes;
+  try {
+    hclKeysBytes = base64ToBytes(response.hcl_keys_json);
+  } catch (e) {
+    throw err("HCL_KEYS_PARSE", `failed to decode hcl_keys_json base64: ${e}`);
+  }
+  const reportData0_32 = reportData.subarray(0, 32);
+  const hclKeysHash = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", hclKeysBytes)
+  );
+  if (!constantTimeEq(hclKeysHash, reportData0_32)) {
+    throw err(
+      "HCL_KEYS_HASH_MISMATCH",
+      "SHA-256(hcl_keys_json) does not match DCAP quote REPORTDATA[0:32]"
+    );
+  }
+  let hclKeys;
+  try {
+    hclKeys = JSON.parse(new TextDecoder().decode(hclKeysBytes));
+  } catch (e) {
+    throw err("HCL_KEYS_PARSE", `failed to parse hcl_keys_json: ${e}`);
+  }
+  const keysArray = hclKeys["keys"];
+  const akJwk = Array.isArray(keysArray) ? keysArray.find((k) => k["kid"] === "HCLAkPub") : void 0;
+  if (!akJwk) {
+    throw err("HCL_KEYS_PARSE", 'hcl_keys_json does not contain a key with kid="HCLAkPub"');
+  }
+  let akPubKey;
+  try {
+    akPubKey = await crypto.subtle.importKey(
+      "jwk",
+      { kty: "RSA", n: akJwk["n"], e: akJwk["e"], ext: true },
+      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+  } catch (e) {
+    throw err("HCL_KEYS_PARSE", `failed to import HCLAkPub from hcl_keys_json: ${e}`);
+  }
+  if (!response.tpm_quote) {
+    throw err("TPM_QUOTE_MISSING", "azure-tdx-dcap response missing tpm_quote");
+  }
+  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
+    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
+  }
+  if (response.mode === "prod" && policy.expectedBinaryHash === void 0) {
+    throw err(
+      "BINARY_HASH_MISMATCH",
+      "production Azure attestation requires a pinned coordinator binary hash"
+    );
+  }
+  if (policy.expectedBinaryHash !== void 0 && response.binary_hash.toLowerCase() !== policy.expectedBinaryHash.toLowerCase()) {
+    throw err(
+      "BINARY_HASH_MISMATCH",
+      `binary hash ${response.binary_hash.toLowerCase()} does not match the approved release pin`
+    );
+  }
+  await verifyTpmQuoteNonce(
+    response.tpm_quote,
+    akPubKey,
+    expectedNonce,
+    expectedNoiseStaticPub,
+    hexToBytes2(response.binary_hash)
+  );
+  if (response.nonce.toLowerCase() !== bytesToHex2(expectedNonce)) {
+    throw err("NONCE_FIELD_MISMATCH", `JSON nonce ${response.nonce} does not match verifier nonce`);
+  }
+  if (response.pubkey.toLowerCase() !== bytesToHex2(expectedNoiseStaticPub)) {
+    throw err(
+      "PUBKEY_FIELD_MISMATCH",
+      "attestation pubkey field does not match Noise static pubkey from handshake"
+    );
+  }
+  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
+    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
+  }
+  if (policy.requiredMode !== void 0 && response.mode !== policy.requiredMode) {
+    throw err(
+      "MODE_MISMATCH",
+      `attestation mode ${response.mode} does not match required ${policy.requiredMode}`
+    );
+  }
+  if (response.mode === "prod") {
+    if ((policy.expectedMrtd === void 0 || policy.expectedMrtd === null) && policy.allowUnpinnedProdMrtdForRelease !== true) {
+      throw err(
+        "MRTD_MISMATCH",
+        "production attestation requires a pinned MRTD but none was configured"
+      );
+    }
+    if (policy.expectedMrtd !== void 0 && policy.expectedMrtd !== null && dcapMeasurements.mrtd !== policy.expectedMrtd.toLowerCase()) {
+      throw err(
+        "MRTD_MISMATCH",
+        `MRTD ${dcapMeasurements.mrtd} does not match pinned ${policy.expectedMrtd.toLowerCase()}`
+      );
+    }
+  }
+  return {
+    mode: response.mode,
+    binaryHash: response.binary_hash,
+    runtimeProfile: response.runtime_profile,
+    mrtd: dcapMeasurements.mrtd,
+    rtmr0: dcapMeasurements.rtmr0,
+    rtmr1: dcapMeasurements.rtmr1,
+    rtmr2: dcapMeasurements.rtmr2,
+    rtmr3: dcapMeasurements.rtmr3,
+    pubkeyHex: response.pubkey.toLowerCase(),
+    localAttestation: false
+  };
+}
+function verifyLocalAttestation(params) {
+  const { response, expectedNonce, expectedNoiseStaticPub, policy } = params;
+  if (policy.allowLocalAttestation !== true) {
+    throw err(
+      "LOCAL_ATTESTATION_DISABLED",
+      "local attestation response received but local attestation is not enabled"
+    );
+  }
+  if (policy.requiredMode !== void 0 && response.mode !== policy.requiredMode) {
+    throw err(
+      "MODE_MISMATCH",
+      `attestation mode ${response.mode} does not match required ${policy.requiredMode}`
+    );
+  }
+  if (response.mode !== "dev") {
+    throw err(
+      "LOCAL_ATTESTATION_DISABLED",
+      "local attestation is only accepted for dev mode responses"
+    );
+  }
+  if (response.nonce.toLowerCase() !== bytesToHex2(expectedNonce)) {
+    throw err("NONCE_FIELD_MISMATCH", `JSON nonce ${response.nonce} does not match verifier nonce`);
+  }
+  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
+    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
+  }
+  const expectedPubHex = bytesToHex2(expectedNoiseStaticPub);
+  if (response.pubkey.toLowerCase() !== expectedPubHex) {
+    throw err(
+      "PUBKEY_FIELD_MISMATCH",
+      "local attestation pubkey field does not match Noise static pubkey from handshake"
+    );
+  }
+  return {
+    mode: response.mode,
+    binaryHash: response.binary_hash.toLowerCase(),
+    runtimeProfile: response.runtime_profile,
+    mrtd: "local-dev-no-mrtd",
+    rtmr0: "local-dev-no-rtmr0",
+    rtmr1: "local-dev-no-rtmr1",
+    rtmr2: "local-dev-no-rtmr2",
+    rtmr3: "local-dev-no-rtmr3",
+    pubkeyHex: response.pubkey.toLowerCase(),
+    localAttestation: true
+  };
+}
+function decodeQuoteB64(b64) {
+  let bin;
+  try {
+    bin = atob(b64);
+  } catch (e) {
+    throw err("QUOTE_DECODE", `quote field is not valid base64: ${e}`);
+  }
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function ensureStructure(raw) {
+  if (raw.length < HEADER_SIZE + BODY_SIZE + 4) {
+    throw err(
+      "QUOTE_STRUCTURE",
+      `quote too short: ${raw.length} bytes (need >= ${HEADER_SIZE + BODY_SIZE + 4})`
+    );
+  }
+  const version = readU16LE(raw, HEADER_VERSION_OFF);
+  const attKey = readU16LE(raw, HEADER_ATT_KEY_OFF);
+  const teeType = readU32LE(raw, HEADER_TEE_TYPE_OFF);
+  if (version !== 4) {
+    throw err("QUOTE_STRUCTURE", `unsupported quote version ${version}`);
+  }
+  if (teeType !== TDX_TEE_TYPE) {
+    throw err("QUOTE_STRUCTURE", `not a TDX quote (TEE type 0x${teeType.toString(16)})`);
+  }
+  if (attKey !== ECDSA_P256_KEY_TYPE) {
+    throw err(
+      "QUOTE_STRUCTURE",
+      `unsupported attestation key type ${attKey} (expected ECDSA-P256)`
+    );
+  }
+}
+function readSigData(raw) {
+  const sigDataLen = readU32LE(raw, SIG_DATA_LEN_OFFSET);
+  const sigStart = SIG_DATA_LEN_OFFSET + 4;
+  if (raw.length < sigStart + sigDataLen) {
+    throw err("QUOTE_STRUCTURE", "quote truncated in signature data");
+  }
+  return raw.subarray(sigStart, sigStart + sigDataLen);
+}
+function parseMeasurements(body) {
+  const m = (off) => bytesToHex2(body.subarray(off, off + MEASUREMENT_LEN));
+  return {
+    mrtd: m(BODY_MRTD_OFF),
+    rtmr0: m(BODY_RTMR0_OFF),
+    rtmr1: m(BODY_RTMR1_OFF),
+    rtmr2: m(BODY_RTMR2_OFF),
+    rtmr3: m(BODY_RTMR3_OFF),
+    tdAttr: bytesToHex2(body.subarray(BODY_TD_ATTR_OFF, BODY_TD_ATTR_OFF + 8))
+  };
+}
+var PEM_BEGIN = "-----BEGIN CERTIFICATE-----";
+var PEM_END = "-----END CERTIFICATE-----";
+var PEM_BEGIN_BYTES = new TextEncoder().encode(PEM_BEGIN);
+var PEM_END_BYTES = new TextEncoder().encode(PEM_END);
+function findBytes(hay, needle, from = 0) {
+  if (needle.length === 0) return from;
+  const last = hay.length - needle.length;
+  outer: for (let i = from; i <= last; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (hay[i + j] !== needle[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function parseQeCertificationData(sigData) {
+  if (sigData.length < SIG_QE_CERT_DATA_OFF + SIG_QE_CERT_DATA_HEADER_SIZE) {
+    throw err("QUOTE_STRUCTURE", "signature data truncated before QE certification data header");
+  }
+  const outerCertType = readU16LE(sigData, SIG_QE_CERT_DATA_OFF);
+  const outerCertSize = readU32LE(sigData, SIG_QE_CERT_DATA_OFF + 2);
+  if (outerCertType !== QE_CERT_TYPE_QE_REPORT_CERT_DATA) {
+    throw err(
+      "QUOTE_STRUCTURE",
+      `unexpected QE certification data type ${outerCertType} (expected ${QE_CERT_TYPE_QE_REPORT_CERT_DATA})`
+    );
+  }
+  const outerDataStart = SIG_QE_CERT_DATA_OFF + SIG_QE_CERT_DATA_HEADER_SIZE;
+  const outerDataEnd = outerDataStart + outerCertSize;
+  if (sigData.length < outerDataEnd) {
+    throw err("QUOTE_STRUCTURE", "signature data truncated in outer QE certification data");
+  }
+  const outerData = sigData.subarray(outerDataStart, outerDataEnd);
+  const qeReportSigOff = SIG_QE_REPORT_SIZE;
+  const qeAuthSizeOff = qeReportSigOff + SIG_QE_REPORT_SIG_SIZE;
+  const qeAuthDataOff = qeAuthSizeOff + 2;
+  if (outerData.length < qeAuthDataOff + SIG_QE_CERT_DATA_HEADER_SIZE) {
+    throw err(
+      "QUOTE_STRUCTURE",
+      "signature data truncated before QE auth_data and nested certification data"
+    );
+  }
+  const qeReport = outerData.subarray(0, SIG_QE_REPORT_SIZE);
+  const qeReportSig = outerData.subarray(qeReportSigOff, qeReportSigOff + SIG_QE_REPORT_SIG_SIZE);
+  const authSize = readU16LE(outerData, qeAuthSizeOff);
+  const qeAuthDataEnd = qeAuthDataOff + authSize;
+  if (outerData.length < qeAuthDataEnd + SIG_QE_CERT_DATA_HEADER_SIZE) {
+    throw err("QUOTE_STRUCTURE", "signature data truncated in QE auth_data");
+  }
+  const qeAuthData = outerData.subarray(qeAuthDataOff, qeAuthDataEnd);
+  const nestedCertType = readU16LE(outerData, qeAuthDataEnd);
+  const nestedCertSize = readU32LE(outerData, qeAuthDataEnd + 2);
+  if (nestedCertType !== QE_CERT_TYPE_PCK_CHAIN) {
+    throw err(
+      "PCK_CHAIN_MISSING",
+      `cert data type ${nestedCertType} is not PCK chain (expected ${QE_CERT_TYPE_PCK_CHAIN})`
+    );
+  }
+  const nestedDataEnd = qeAuthDataEnd + SIG_QE_CERT_DATA_HEADER_SIZE + nestedCertSize;
+  if (outerData.length < nestedDataEnd) {
+    throw err("QUOTE_STRUCTURE", "signature data truncated in nested QE certification data");
+  }
+  return {
+    qeReport,
+    qeReportSig,
+    qeAuthData,
+    qeCertificationData: outerData.subarray(qeAuthDataEnd, nestedDataEnd)
+  };
+}
+function extractPckChain(qeCertificationData) {
+  if (qeCertificationData.length < SIG_QE_CERT_DATA_HEADER_SIZE) {
+    throw err("PCK_CHAIN_PARSE", "nested QE certification data header truncated");
+  }
+  const certType = readU16LE(qeCertificationData, 0);
+  const certSize = readU32LE(qeCertificationData, 2);
+  if (certType !== QE_CERT_TYPE_PCK_CHAIN) {
+    throw err(
+      "PCK_CHAIN_MISSING",
+      `cert data type ${certType} is not PCK chain (expected ${QE_CERT_TYPE_PCK_CHAIN})`
+    );
+  }
+  if (qeCertificationData.length < SIG_QE_CERT_DATA_HEADER_SIZE + certSize) {
+    throw err("PCK_CHAIN_PARSE", "nested QE certification data truncated");
+  }
+  const certBytes = qeCertificationData.subarray(
+    SIG_QE_CERT_DATA_HEADER_SIZE,
+    SIG_QE_CERT_DATA_HEADER_SIZE + certSize
+  );
+  const certs = [];
+  let cursor = 0;
+  while (cursor < certBytes.length) {
+    const begin = findBytes(certBytes, PEM_BEGIN_BYTES, cursor);
+    if (begin === -1) break;
+    const endTag = findBytes(certBytes, PEM_END_BYTES, begin);
+    if (endTag === -1) {
+      throw err("PCK_CHAIN_PARSE", "unterminated PEM block");
+    }
+    const end = endTag + PEM_END_BYTES.length;
+    const pem = new TextDecoder("utf-8").decode(certBytes.subarray(begin, end));
+    try {
+      certs.push(new x509.X509Certificate(pem));
+    } catch (e) {
+      throw err("PCK_CHAIN_PARSE", `failed to parse PEM cert: ${e}`);
+    }
+    cursor = end;
+  }
+  if (certs.length === 0) {
+    throw err("PCK_CHAIN_MISSING", "no parseable certs in PCK chain");
+  }
+  if (certs.length < 3) {
+    throw err(
+      "PCK_CHAIN_MISSING",
+      `PCK chain has only ${certs.length} cert(s); Intel DCAP requires leaf + CA + Root (min 3)`
+    );
+  }
+  return certs;
+}
+async function verifyChainSignatures(chain) {
+  const now = /* @__PURE__ */ new Date();
+  for (let i = 0; i < chain.length - 1; i++) {
+    const cert = chain[i];
+    if (now < cert.notBefore) {
+      throw err(
+        "PCK_CHAIN_SIGNATURE",
+        `cert[${i}] (${cert.subject}) is not yet valid (notBefore=${cert.notBefore.toISOString()})`
+      );
+    }
+    if (now > cert.notAfter) {
+      throw err(
+        "PCK_CHAIN_SIGNATURE",
+        `cert[${i}] (${cert.subject}) has expired (notAfter=${cert.notAfter.toISOString()})`
+      );
+    }
+    let ok;
+    try {
+      ok = await chain[i].verify({ publicKey: chain[i + 1].publicKey });
+    } catch (e) {
+      throw err(
+        "PCK_CHAIN_SIGNATURE",
+        `cert[${i}] (${chain[i].subject}) signature verification threw: ${e}`
+      );
+    }
+    if (!ok) {
+      throw err(
+        "PCK_CHAIN_SIGNATURE",
+        `cert[${i}] (${chain[i].subject}) signature does not verify against issuer cert[${i + 1}]`
+      );
+    }
+  }
+  const root = chain[chain.length - 1];
+  if (now < root.notBefore) {
+    throw err(
+      "PCK_CHAIN_SIGNATURE",
+      `root cert (${root.subject}) is not yet valid (notBefore=${root.notBefore.toISOString()})`
+    );
+  }
+  if (now > root.notAfter) {
+    throw err(
+      "PCK_CHAIN_SIGNATURE",
+      `root cert (${root.subject}) has expired (notAfter=${root.notAfter.toISOString()})`
+    );
+  }
+  let rootOk;
+  try {
+    rootOk = await root.verify({ publicKey: root.publicKey });
+  } catch (e) {
+    throw err(
+      "PCK_CHAIN_SIGNATURE",
+      `root cert (${root.subject}) self-signature verification threw: ${e}`
+    );
+  }
+  if (!rootOk) {
+    throw err("PCK_CHAIN_SIGNATURE", `root cert (${root.subject}) is not self-signed`);
+  }
+  for (let i = 1; i < chain.length; i++) {
+    const bc = chain[i].getExtension(x509.BasicConstraintsExtension);
+    if (!bc || !bc.ca) {
+      throw err(
+        "PCK_CHAIN_SIGNATURE",
+        `cert[${i}] (${chain[i].subject}) is not a CA cert (BasicConstraints.cA is not true)`
+      );
+    }
+  }
+}
+async function leafSpki(leaf) {
+  const key = await leaf.publicKey.export();
+  const spki = await crypto.subtle.exportKey("spki", key);
+  return new Uint8Array(spki);
+}
+function rawXyToSpki(xy) {
+  if (xy.length !== 64) {
+    throw err("QUOTE_STRUCTURE", `attestation pubkey must be 64 bytes (got ${xy.length})`);
+  }
+  const uncompressed = new Uint8Array(65);
+  uncompressed[0] = 4;
+  uncompressed.set(xy, 1);
+  const prefix = new Uint8Array([
+    48,
+    89,
+    48,
+    19,
+    6,
+    7,
+    42,
+    134,
+    72,
+    206,
+    61,
+    2,
+    1,
+    6,
+    8,
+    42,
+    134,
+    72,
+    206,
+    61,
+    3,
+    1,
+    7,
+    3,
+    66,
+    0
+  ]);
+  return concat(prefix, uncompressed);
+}
+async function verifyP256Signature(spki, rsSig, data, failureReason, what) {
+  if (rsSig.length !== 64) {
+    throw err(failureReason, `${what}: signature must be 64 bytes (r||s)`);
+  }
+  let key;
+  try {
+    key = await crypto.subtle.importKey(
+      "spki",
+      spki,
+      { name: "ECDSA", namedCurve: "P-256" },
+      false,
+      ["verify"]
+    );
+  } catch (e) {
+    throw err(failureReason, `${what}: failed to import key: ${e}`);
+  }
+  const ok = await crypto.subtle.verify(
+    { name: "ECDSA", hash: "SHA-256" },
+    key,
+    rsSig,
+    data
+  );
+  if (!ok) {
+    throw err(failureReason, `${what}: ECDSA verification failed`);
+  }
+}
+async function sha256(data) {
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", data));
+}
+async function sha256Hex(data) {
+  return bytesToHex2(await sha256(data));
+}
+function readU16LE(buf, off) {
+  return buf[off] | buf[off + 1] << 8;
+}
+function readU32LE(buf, off) {
+  return (buf[off] | buf[off + 1] << 8 | buf[off + 2] << 16 | buf[off + 3] << 24) >>> 0;
+}
+function constantTimeEq(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+function concat(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+function bytesToHex2(b) {
+  let s = "";
+  for (let i = 0; i < b.length; i++) s += b[i].toString(16).padStart(2, "0");
+  return s;
+}
+var PROTOCOL_NAME = "Noise_XX_25519_ChaChaPoly_SHA256";
+function noiseNonce(n) {
+  const buf = new Uint8Array(12);
+  const view = new DataView(buf.buffer);
+  view.setUint32(4, n & 4294967295, true);
+  view.setUint32(8, Math.floor(n / 4294967296) & 4294967295, true);
+  return buf;
+}
+function hkdf2(ck, ikm) {
+  const mac1 = new HMAC(SHA256, ck);
+  mac1.update(ikm);
+  const temp = mac1.digest();
+  const mac2 = new HMAC(SHA256, temp);
+  mac2.update(new Uint8Array([1]));
+  const out1 = mac2.digest();
+  const mac3 = new HMAC(SHA256, temp);
+  mac3.update(out1);
+  mac3.update(new Uint8Array([2]));
+  const out2 = mac3.digest();
+  return [out1, out2];
+}
+function createSymState() {
+  const proto = new TextEncoder().encode(PROTOCOL_NAME);
+  const h0 = new Uint8Array(32);
+  h0.set(proto);
+  const ck0 = new Uint8Array(32);
+  ck0.set(h0);
+  const ss = {
+    h: h0,
+    ck: ck0,
+    k: null,
+    n: 0,
+    mixHash(data) {
+      const combined = new Uint8Array(this.h.length + data.length);
+      combined.set(this.h);
+      combined.set(data, this.h.length);
+      this.h = hash(combined);
+    },
+    mixKey(ikm) {
+      const [newCk, newK] = hkdf2(this.ck, ikm);
+      this.ck = newCk;
+      this.k = newK;
+      this.n = 0;
+    },
+    encryptAndHash(plaintext) {
+      if (!this.k) {
+        this.mixHash(plaintext);
+        return new Uint8Array(plaintext);
+      }
+      const aead = new ChaCha20Poly1305(this.k);
+      const ct = aead.seal(noiseNonce(this.n), plaintext, this.h);
+      this.n++;
+      this.mixHash(ct);
+      return ct;
+    },
+    decryptAndHash(ciphertext) {
+      if (!this.k) {
+        this.mixHash(ciphertext);
+        return new Uint8Array(ciphertext);
+      }
+      const aead = new ChaCha20Poly1305(this.k);
+      const pt = aead.open(noiseNonce(this.n), ciphertext, this.h);
+      if (!pt) throw new Error("Noise: AEAD decryption failed");
+      this.n++;
+      this.mixHash(ciphertext);
+      return pt;
+    },
+    split() {
+      const [k1, k2] = hkdf2(this.ck, new Uint8Array(0));
+      return [k1, k2];
+    }
+  };
+  ss.mixHash(new Uint8Array(0));
+  return ss;
+}
+function createNoiseTransport(sendKey, recvKey) {
+  let sendN = 0;
+  let recvN = 0;
+  return {
+    encrypt(plaintext) {
+      const aead = new ChaCha20Poly1305(sendKey);
+      const ct = aead.seal(noiseNonce(sendN), plaintext, void 0);
+      sendN++;
+      return ct;
+    },
+    decrypt(ciphertext) {
+      const aead = new ChaCha20Poly1305(recvKey);
+      const pt = aead.open(noiseNonce(recvN), ciphertext, void 0);
+      if (!pt) throw new Error("Noise: transport decryption failed");
+      recvN++;
+      return pt;
+    }
+  };
+}
+function createNoiseXXInitiator() {
+  const staticKeyPair = generateKeyPair();
+  const ephKeyPair = generateKeyPair();
+  const ss = createSymState();
+  let remoteEphPub = null;
+  let remoteStaticPub = null;
+  return {
+    get remoteStaticPublicKey() {
+      return remoteStaticPub;
+    },
+    writeMessage1() {
+      ss.mixHash(ephKeyPair.publicKey);
+      return new Uint8Array(ephKeyPair.publicKey);
+    },
+    readMessage2(msg) {
+      if (msg.length < 96) {
+        throw new Error(`noise msg2: expected >=96 bytes, got ${msg.length}`);
+      }
+      remoteEphPub = msg.slice(0, 32);
+      ss.mixHash(remoteEphPub);
+      const dhEE = sharedKey(ephKeyPair.secretKey, remoteEphPub);
+      ss.mixKey(dhEE);
+      remoteStaticPub = ss.decryptAndHash(msg.slice(32, 80));
+      const dhES = sharedKey(ephKeyPair.secretKey, remoteStaticPub);
+      ss.mixKey(dhES);
+      if (msg.length > 80) {
+        ss.decryptAndHash(msg.slice(80));
+      }
+    },
+    writeMessage3() {
+      if (!remoteEphPub) {
+        throw new Error("noise msg3: must call readMessage2 first");
+      }
+      const encS = ss.encryptAndHash(staticKeyPair.publicKey);
+      const dhSE = sharedKey(staticKeyPair.secretKey, remoteEphPub);
+      ss.mixKey(dhSE);
+      const encPayload = ss.encryptAndHash(new Uint8Array(0));
+      const message = new Uint8Array(encS.length + encPayload.length);
+      message.set(encS);
+      message.set(encPayload, encS.length);
+      const [sendKey, recvKey] = ss.split();
+      return { message, transport: createNoiseTransport(sendKey, recvKey) };
+    }
+  };
+}
+
+// src/session/secureChannel.ts
+var ATTEST_REQUEST_PREFIX = new TextEncoder().encode("invisible-attest-v1\0");
+var DEFAULT_CHANNEL_TIMEOUT_MS = 3e4;
+async function establishSecureChannel(options) {
+  const { transport, endpoint, nonce } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_CHANNEL_TIMEOUT_MS;
+  if (transport.state() !== "open") {
+    throw new TransportError("CONNECTION_LOST", "secure channel requires an open transport");
+  }
+  const inbound = createFrameReader(transport);
+  try {
+    const initiator = createNoiseXXInitiator();
+    transport.send(initiator.writeMessage1());
+    const msg2 = await inbound.next(timeoutMs);
+    try {
+      initiator.readMessage2(msg2);
+    } catch (cause) {
+      throw new TransportError("NOISE_HANDSHAKE_FAILED", `readMessage2 failed: ${String(cause)}`, {
+        cause
+      });
+    }
+    const remoteStaticPublicKey = initiator.remoteStaticPublicKey;
+    if (!remoteStaticPublicKey) {
+      throw new TransportError(
+        "NOISE_HANDSHAKE_FAILED",
+        "missing responder static pubkey after readMessage2"
+      );
+    }
+    let pending;
+    try {
+      const result = initiator.writeMessage3();
+      transport.send(result.message);
+      pending = result.transport;
+    } catch (cause) {
+      throw new TransportError("NOISE_HANDSHAKE_FAILED", `writeMessage3 failed: ${String(cause)}`, {
+        cause
+      });
+    }
+    const nonceHex = bytesToHex3(nonce);
+    transport.send(pending.encrypt(encodeAttestationRequest(nonceHex)));
+    const responseFrame = await inbound.next(timeoutMs);
+    let response;
+    try {
+      response = decodeAttestationResponse(pending.decrypt(responseFrame));
+    } catch (cause) {
+      if (cause instanceof AttestationError) throw cause;
+      throw new AttestationError(
+        "NOT_ATTESTED",
+        `failed to decode attestation response: ${String(cause)}`,
+        { cause }
+      );
+    }
+    const policy = toAttestationPolicy(endpoint);
+    const attestation = await verifyAttestation({
+      response,
+      expectedNonce: nonce,
+      expectedNoiseStaticPub: remoteStaticPublicKey,
+      policy,
+      timeoutMs
+    });
+    inbound.detach();
+    return promoteChannel({ transport, cipher: pending, attestation, remoteStaticPublicKey });
+  } catch (err2) {
+    inbound.detach();
+    throw err2;
+  }
+}
+function toAttestationPolicy(endpoint) {
+  const pin = endpoint.releasePin;
+  const loopback = isLoopbackUrl(endpoint.wsUrl);
+  const allowLocalAttestation = endpoint.allowLocalAttestation === true && loopback && endpoint.requiredMode !== "prod";
+  const policy = {
+    ...pin.intelRootFingerprint ? { intelRootFingerprint: pin.intelRootFingerprint } : {},
+    // "auto" leaves the mode unconstrained; "prod"/"dev" are passed through.
+    ...endpoint.requiredMode !== "auto" ? { requiredMode: endpoint.requiredMode } : {},
+    // Keep the release pin active in prod and auto mode. Dev local attestations
+    // ignore the MRTD pin inside the verifier.
+    expectedMrtd: pin.mrtd,
+    ...pin.binaryHash ? { expectedBinaryHash: pin.binaryHash } : {},
+    ...pin.runtimeProfile ? { expectedRuntimeProfile: pin.runtimeProfile } : {},
+    ...pin.runtimeMeasurements ? { expectedRuntimeMeasurements: pin.runtimeMeasurements } : {},
+    allowMissingDcapCollateral: pin.allowMissingDcapCollateral === true,
+    allowLocalAttestation
+  };
+  if (pin.azureMaa) {
+    policy.azureMaa = {
+      expectedIssuer: pin.azureMaa.issuer,
+      expectedJwksUrl: pin.azureMaa.jwksUrl,
+      expectedPolicyHash: pin.azureMaa.policyHash
+    };
+  }
+  return policy;
+}
+function promoteChannel(params) {
+  const { transport, cipher, attestation, remoteStaticPublicKey } = params;
+  const handlers = /* @__PURE__ */ new Set();
+  const fatalHandlers = /* @__PURE__ */ new Set();
+  let attestationWaiter = null;
+  let closed = false;
+  const unsubscribeRaw = transport.onMessage((frame) => {
+    if (closed) return;
+    let plaintext;
+    try {
+      plaintext = cipher.decrypt(frame);
+    } catch (cause) {
+      const error = new TransportError(
+        "NOISE_HANDSHAKE_FAILED",
+        `secure channel decrypt failed: ${String(cause)}`,
+        { cause }
+      );
+      fail(error);
+      return;
+    }
+    if (attestationWaiter !== null) {
+      const decoded = decodeAttestationControlFrame(plaintext);
+      if (decoded.kind === "response") {
+        const waiter = attestationWaiter;
+        attestationWaiter = null;
+        clearTimeout(waiter.timer);
+        waiter.resolve(decoded.response);
+        return;
+      }
+      if (decoded.kind === "invalid") {
+        const waiter = attestationWaiter;
+        attestationWaiter = null;
+        clearTimeout(waiter.timer);
+        waiter.reject(decoded.error);
+        return;
+      }
+    }
+    for (const handler of handlers) handler(plaintext);
+  });
+  const unsubscribeState = transport.onStateChange((state) => {
+    if (closed) return;
+    if (state === "closing" || state === "closed") {
+      fail(new TransportError("CONNECTION_LOST", "secure channel transport closed"));
+    }
+  });
+  function close() {
+    if (closed) return;
+    closed = true;
+    handlers.clear();
+    fatalHandlers.clear();
+    if (attestationWaiter !== null) {
+      const waiter = attestationWaiter;
+      attestationWaiter = null;
+      clearTimeout(waiter.timer);
+      waiter.reject(new TransportError("CONNECTION_LOST", "secure channel is closed"));
+    }
+    unsubscribeRaw();
+    unsubscribeState();
+  }
+  function fail(error) {
+    if (closed) return;
+    const notifyHandlers = [...fatalHandlers];
+    for (const handler of notifyHandlers) handler(error);
+    if (!closed) {
+      close();
+      transport.close();
+    }
+  }
+  return {
+    attestation,
+    remoteStaticPublicKey,
+    requestAttestation(nonceHex, timeoutMs) {
+      if (closed) {
+        return Promise.reject(new TransportError("CONNECTION_LOST", "secure channel is closed"));
+      }
+      if (attestationWaiter !== null) {
+        return Promise.reject(
+          new AttestationError("NOT_ATTESTED", "re-attestation is already in flight")
+        );
+      }
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          if (attestationWaiter === null) return;
+          attestationWaiter = null;
+          reject(
+            new AttestationError("NOT_ATTESTED", `re-attestation timed out after ${timeoutMs}ms`)
+          );
+        }, timeoutMs);
+        attestationWaiter = { resolve, reject, timer };
+        try {
+          transport.send(cipher.encrypt(encodeAttestationRequest(nonceHex)));
+        } catch (cause) {
+          if (attestationWaiter === null) return;
+          attestationWaiter = null;
+          clearTimeout(timer);
+          reject(cause instanceof Error ? cause : new Error(String(cause)));
+        }
+      });
+    },
+    send(plaintext) {
+      if (closed) {
+        throw new TransportError("CONNECTION_LOST", "secure channel is closed");
+      }
+      transport.send(cipher.encrypt(plaintext));
+    },
+    onMessage(handler) {
+      handlers.add(handler);
+      return () => handlers.delete(handler);
+    },
+    onFatal(handler) {
+      fatalHandlers.add(handler);
+      return () => fatalHandlers.delete(handler);
+    },
+    close
+  };
+}
+function createFrameReader(transport) {
+  const queue = [];
+  let waiter = null;
+  let detached = false;
+  const unsubscribeMessage = transport.onMessage((frame) => {
+    if (detached) return;
+    if (waiter) {
+      const w = waiter;
+      waiter = null;
+      w.resolve(frame);
+    } else {
+      queue.push(frame);
+    }
+  });
+  const unsubscribeState = transport.onStateChange((state) => {
+    if (detached) return;
+    if (state === "closing" || state === "closed") {
+      const w = waiter;
+      waiter = null;
+      w?.reject(
+        new TransportError("CONNECTION_LOST", "transport closed during handshake/attestation")
+      );
+    }
+  });
+  function detach() {
+    if (detached) return;
+    detached = true;
+    unsubscribeMessage();
+    unsubscribeState();
+    queue.length = 0;
+  }
+  return {
+    next(timeoutMs) {
+      if (detached) {
+        return Promise.reject(new TransportError("CONNECTION_LOST", "frame reader detached"));
+      }
+      const queued = queue.shift();
+      if (queued) return Promise.resolve(queued);
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          if (waiter) {
+            waiter = null;
+            reject(
+              new TransportError(
+                "NOISE_HANDSHAKE_FAILED",
+                `timed out waiting for a handshake frame after ${timeoutMs}ms`
+              )
+            );
+          }
+        }, timeoutMs);
+        waiter = {
+          resolve: (f) => {
+            clearTimeout(timer);
+            resolve(f);
+          },
+          reject: (e) => {
+            clearTimeout(timer);
+            reject(e);
+          }
+        };
+      });
+    },
+    detach
+  };
+}
+function decodeAttestationControlFrame(plaintext) {
+  const text = new TextDecoder().decode(plaintext);
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return { kind: "app" };
+  }
+  try {
+    assertAttestResponse(body);
+    return { kind: "response", response: body };
+  } catch (cause) {
+    if (looksLikeAttestationResponse(body)) {
+      return {
+        kind: "invalid",
+        error: cause instanceof AttestationError ? cause : new AttestationError("NOT_ATTESTED", String(cause), { cause })
+      };
+    }
+    return { kind: "app" };
+  }
+}
+function looksLikeAttestationResponse(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const body = value;
+  return "quote" in body || "nonce" in body || "pubkey" in body || "binary_hash" in body || "local_attestation" in body || "maa_token" in body || "tpm_quote" in body || "hcl_keys_json" in body;
+}
+function encodeAttestationRequest(nonceHex) {
+  const nonce = new TextEncoder().encode(nonceHex);
+  const out = new Uint8Array(ATTEST_REQUEST_PREFIX.length + nonce.length);
+  out.set(ATTEST_REQUEST_PREFIX);
+  out.set(nonce, ATTEST_REQUEST_PREFIX.length);
+  return out;
+}
+function decodeAttestationResponse(plaintext) {
+  const text = new TextDecoder().decode(plaintext);
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch (cause) {
+    throw new AttestationError(
+      "NOT_ATTESTED",
+      `attestation response is not valid JSON: ${String(cause)}`,
+      { cause }
+    );
+  }
+  assertAttestResponse(body);
+  return body;
+}
+function isLoopbackUrl(value) {
+  try {
+    return isLoopbackHostname(new URL(value).hostname);
+  } catch {
+    return false;
+  }
+}
+function isLoopbackHostname(hostname) {
+  const normalized = hostname.toLowerCase();
+  if (normalized === "localhost" || normalized === "::1" || normalized === "[::1]") {
+    return true;
+  }
+  if (isLoopbackIpv4(normalized)) {
+    return true;
+  }
+  if (!normalized.startsWith("[::ffff:") || !normalized.endsWith("]")) {
+    return false;
+  }
+  const mapped = normalized.slice("[::ffff:".length, -1);
+  if (isLoopbackIpv4(mapped)) {
+    return true;
+  }
+  const parts = mapped.split(":");
+  if (parts.length !== 2) {
+    return false;
+  }
+  const high = Number.parseInt(parts[0] ?? "", 16);
+  const low = Number.parseInt(parts[1] ?? "", 16);
+  if (!Number.isInteger(high) || !Number.isInteger(low) || high < 0 || high > 65535 || low < 0 || low > 65535) {
+    return false;
+  }
+  return (high << 16 | low) >>> 24 === 127;
+}
+function isLoopbackIpv4(hostname) {
+  const parts = hostname.split(".");
+  return parts.length === 4 && parts.every((part) => /^\d+$/.test(part)) && Number(parts[0]) === 127 && parts.every((part) => Number(part) >= 0 && Number(part) <= 255);
+}
+function bytesToHex3(b) {
+  let s = "";
+  for (let i = 0; i < b.length; i++) s += b[i].toString(16).padStart(2, "0");
+  return s;
+}
+
+// src/transport/handshake.ts
+async function establishAttestedChannel(params) {
+  const { transport, endpoint, nonce, timeoutMs } = params;
+  const channel = await establishSecureChannel({ transport, endpoint, nonce, timeoutMs });
+  const handshake = {
+    noiseStaticPublicKey: channel.remoteStaticPublicKey,
+    channel
+  };
+  const attestation = {
+    mrtd: channel.attestation.mrtd,
+    mode: channel.attestation.mode,
+    binaryHash: channel.attestation.binaryHash,
+    runtimeProfile: channel.attestation.runtimeProfile,
+    pubkeyHex: channel.attestation.pubkeyHex,
+    localAttestation: channel.attestation.localAttestation,
+    rtmr0: channel.attestation.rtmr0,
+    rtmr1: channel.attestation.rtmr1,
+    rtmr2: channel.attestation.rtmr2,
+    rtmr3: channel.attestation.rtmr3,
+    verifiedAtMs: Date.now()
+  };
+  void toAttestationPolicy(endpoint);
+  return { channel, handshake, attestation };
+}
+
+// src/schemas/payoutPolicy.schema.json
+var payoutPolicy_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://invisible.exchange/schemas/sdk/payoutPolicy.schema.json",
+  title: "PayoutPolicy",
+  description: "Where and how a contract's output is delivered. V0 normal-user requests accept exactly one destination. Validated locally before submission (spec sections 4.3.1 and 10.1).",
+  type: "object",
+  additionalProperties: false,
+  required: ["destinations"],
+  properties: {
+    destinations: {
+      type: "array",
+      minItems: 1,
+      description: "V0 normal-user requests accept exactly one destination. Multi-address receive is not supported yet.",
+      items: { $ref: "#/$defs/payoutDestination" }
+    },
+    totalDeadlineMs: {
+      type: "integer",
+      minimum: 0,
+      description: "Payout-window selector in milliseconds: 0 for instant, or a currently supported scheduled window duration."
+    },
+    batchExclusionId: {
+      type: "string",
+      description: "Not supported in V0 normal-user requests. Reserved for V1 campaign-scoped batch exclusion; never a stable actor identity."
+    }
+  },
+  $defs: {
+    payoutDestination: {
+      title: "PayoutDestination",
+      type: "object",
+      additionalProperties: false,
+      required: ["address", "sharePercent"],
+      properties: {
+        address: {
+          type: "string",
+          description: "Base58 Solana account address."
+        },
+        sharePercent: {
+          type: "number",
+          minimum: 0,
+          maximum: 100,
+          description: "Share of the payout. Sums to 100 across destinations."
+        },
+        minDelayMs: {
+          type: "integer",
+          minimum: 0,
+          description: "Not supported in V0 normal-user requests; the SDK rejects this field because the current runtime does not honor per-destination delay bounds."
+        },
+        maxDelayMs: {
+          type: "integer",
+          minimum: 0,
+          description: "Not supported in V0 normal-user requests; the SDK rejects this field because the current runtime does not honor per-destination delay bounds."
+        },
+        minLamports: { type: "integer", minimum: 0 }
+      }
+    }
+  }
+};
+
+// src/schemas/coordinatorPoolConfig.schema.json
+var coordinatorPoolConfig_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://invisible.exchange/schemas/sdk/coordinatorPoolConfig.schema.json",
+  title: "CoordinatorPoolConfig",
+  description: "The coordinator endpoint pool a session connects through (spec section 6.1). No hostname is baked in; callers supply endpoints (or opt into a preset).",
+  type: "object",
+  additionalProperties: false,
+  required: ["endpoints"],
+  properties: {
+    endpoints: {
+      type: "array",
+      minItems: 1,
+      items: { $ref: "#/$defs/coordinatorEndpoint" }
+    },
+    reattestEveryMs: { type: "integer", minimum: 1 },
+    failoverDebounceMs: { type: "integer", minimum: 0 },
+    maxReconnectAttempts: { type: "integer", minimum: 0 },
+    noiseTransportTimeoutMs: { type: "integer", minimum: 1 },
+    preferLeader: { type: "boolean" },
+    allowedRoles: {
+      type: "array",
+      items: { enum: ["leader", "watcher"] }
+    }
+  },
+  $defs: {
+    coordinatorEndpoint: {
+      title: "CoordinatorEndpoint",
+      type: "object",
+      additionalProperties: false,
+      required: ["wsUrl", "expectedHostname", "releasePin", "requiredMode"],
+      allOf: [
+        {
+          if: {
+            properties: {
+              releasePin: {
+                type: "object",
+                required: ["allowMissingDcapCollateral"],
+                properties: {
+                  allowMissingDcapCollateral: { const: true }
+                }
+              }
+            },
+            required: ["releasePin"]
+          },
+          then: {
+            properties: {
+              requiredMode: { const: "dev" }
+            }
+          }
+        }
+      ],
+      properties: {
+        wsUrl: { type: "string", description: "wss://<host>/ws-noise" },
+        expectedHostname: {
+          type: "string",
+          description: "Must match the SNI / TLS certificate host."
+        },
+        releasePin: { $ref: "#/$defs/releasePin" },
+        requiredMode: { enum: ["prod", "dev", "auto"] },
+        allowLocalAttestation: {
+          type: "boolean",
+          description: "Explicit local-dev fallback opt-in. Honored only for loopback non-prod endpoints."
+        },
+        roleHint: { enum: ["leader", "watcher"] },
+        weight: { type: "number", minimum: 0 }
+      }
+    },
+    releasePin: {
+      title: "CoordinatorReleasePin",
+      type: "object",
+      additionalProperties: false,
+      required: ["mrtd"],
+      properties: {
+        mrtd: { type: "string", description: "Hex MRTD release pin." },
+        binaryHash: {
+          type: "string",
+          pattern: "^[0-9a-fA-F]{64}$",
+          description: "Optional SHA-256 hash of the approved coordinator binary; required for production Azure attestation."
+        },
+        runtimeProfile: {
+          enum: [
+            "prod-hardened",
+            "prod-devnet-simplified",
+            "prod-devnet-simplified-locked",
+            "azure-tdx-v0-agentless"
+          ],
+          description: "Optional compile-time coordinator runtime profile; production simplified deployments must pin it."
+        },
+        runtimeMeasurements: {
+          $ref: "#/$defs/runtimeMeasurements",
+          description: "Approved RTMR0..RTMR3 values. Required for the agentless Azure TDX V0 profile."
+        },
+        intelRootFingerprint: {
+          type: "string",
+          description: "Hex SHA-256 of the Intel root cert."
+        },
+        allowMissingDcapCollateral: {
+          type: "boolean",
+          description: "Temporary non-prod legacy escape hatch for coordinators that do not yet emit Intel DCAP collateral."
+        },
+        azureMaa: { $ref: "#/$defs/azureMaaPin" }
+      }
+    },
+    runtimeMeasurements: {
+      title: "RuntimeMeasurements",
+      type: "object",
+      additionalProperties: false,
+      required: ["rtmr0", "rtmr1", "rtmr2", "rtmr3"],
+      properties: {
+        rtmr0: { type: "string", pattern: "^[0-9a-fA-F]{96}$" },
+        rtmr1: { type: "string", pattern: "^[0-9a-fA-F]{96}$" },
+        rtmr2: { type: "string", pattern: "^[0-9a-fA-F]{96}$" },
+        rtmr3: { type: "string", pattern: "^[0-9a-fA-F]{96}$" }
+      }
+    },
+    azureMaaPin: {
+      title: "AzureMaaPin",
+      type: "object",
+      additionalProperties: false,
+      required: ["issuer", "jwksUrl", "policyHash"],
+      properties: {
+        issuer: { type: "string" },
+        jwksUrl: { type: "string" },
+        policyHash: { type: "string" }
+      }
+    }
+  }
+};
+
+// src/schemas/lpPositionView.schema.json
+var lpPositionView_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://invisible.exchange/schemas/sdk/lpPositionView.schema.json",
+  title: "LpPositionView",
+  description: "The actor-safe LP position projection (spec section 4.4.1). Earned fees are per-position, never aggregated globally.",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "status",
+    "targetShardCount",
+    "authPublicKey",
+    "refillPublicKey",
+    "withdrawalCommitment",
+    "committedLamports",
+    "earnedLamports",
+    "refillThreshold",
+    "shards",
+    "createdAt"
+  ],
+  properties: {
+    id: { type: "string", description: "lp_position_id" },
+    status: { enum: ["dkg_pending", "active", "withdrawing", "closed"] },
+    targetShardCount: { type: "integer", minimum: 0, maximum: 300 },
+    authPublicKey: {
+      type: "string",
+      description: "Derived from the LP Position Code; signs LP commands."
+    },
+    refillPublicKey: { type: "string", description: "Ed25519, 32 bytes." },
+    withdrawalCommitment: {
+      type: "string",
+      description: "SHA256(withdrawal_secret)."
+    },
+    committedLamports: { type: "integer", minimum: 0 },
+    earnedLamports: { type: "integer", minimum: 0 },
+    refillThreshold: { type: "integer", minimum: 0 },
+    shards: {
+      type: "array",
+      description: "LpInventoryShard[] from the protocol package; opaque to the SDK skeleton.",
+      items: { type: "object" }
+    },
+    createdAt: { type: "integer", minimum: 0 },
+    redemptionPermission: {
+      type: "object",
+      additionalProperties: false,
+      required: ["state", "grantRevision", "observedAtMs"],
+      properties: {
+        state: { enum: ["unknown", "locked", "enabled"] },
+        grantRevision: { type: "integer", minimum: 0 },
+        observedAtMs: { type: "integer", minimum: 0 }
+      }
+    }
+  }
+};
+
+// src/schemas/storageEnvelope.schema.json
+var storageEnvelope_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://invisible.exchange/schemas/sdk/storageEnvelope.schema.json",
+  title: "StorageEnvelope",
+  description: "Optional wrapped form for callers or future encrypted storage adapters (spec section 7). Current browser and extension adapters persist caller-supplied bytes; callers decide whether those bytes are plaintext, wrapped, or encrypted.",
+  type: "object",
+  additionalProperties: false,
+  required: ["namespace", "key", "alg", "ciphertext", "createdAtMs"],
+  properties: {
+    namespace: {
+      type: "string",
+      minLength: 1
+    },
+    key: {
+      type: "string",
+      minLength: 1
+    },
+    alg: {
+      enum: ["AES-GCM", "none"],
+      description: "Wrapping algorithm. `none` means the caller supplied bytes without an envelope-level transform."
+    },
+    ciphertext: {
+      type: "string",
+      description: "Base64url-encoded wrapped bytes, encrypted bytes, or caller-supplied plaintext bytes when alg is `none`."
+    },
+    iv: {
+      type: "string",
+      description: "Base64url-encoded AES-GCM nonce; required when alg is AES-GCM."
+    },
+    createdAtMs: {
+      type: "integer",
+      minimum: 0
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: { alg: { const: "AES-GCM" } },
+        required: ["alg"]
+      },
+      then: {
+        properties: { iv: { type: "string" } },
+        required: ["iv"]
+      }
+    }
+  ]
+};
+
+// src/validation/ajv.ts
+var ajv = new Ajv2020({ allErrors: true, strict: true });
+var validatePayoutPolicyShape = ajv.compile(payoutPolicy_schema_default);
+var validateCoordinatorPoolConfigShape = ajv.compile(coordinatorPoolConfig_schema_default);
+ajv.compile(lpPositionView_schema_default);
+ajv.compile(storageEnvelope_schema_default);
+function formatAjvErrors(errors) {
+  if (!errors || errors.length === 0) return "schema validation failed";
+  return errors.map((e) => `${e.instancePath || "(root)"} ${e.message ?? "is invalid"}`.trim()).join("; ");
+}
+
+// src/attestation/reattest.ts
+var DEFAULT_REATTEST_TIMEOUT_MS = 3e4;
+async function reattest(state, endpoint, timeoutMs = DEFAULT_REATTEST_TIMEOUT_MS) {
+  const { channel, remoteStaticPublicKey } = state;
+  if (channel === null || remoteStaticPublicKey === null) {
+    throw new TransportError("CONNECTION_LOST", "re-attestation requires a live attested channel");
+  }
+  const nonce = crypto.getRandomValues(new Uint8Array(32));
+  const response = await channel.requestAttestation(toHex(nonce), timeoutMs);
+  const metadata = await verifyAttestation({
+    response,
+    expectedNonce: nonce,
+    expectedNoiseStaticPub: remoteStaticPublicKey,
+    policy: toAttestationPolicy(endpoint),
+    timeoutMs
+  });
+  return {
+    mrtd: metadata.mrtd,
+    mode: metadata.mode,
+    binaryHash: metadata.binaryHash,
+    runtimeProfile: metadata.runtimeProfile,
+    pubkeyHex: metadata.pubkeyHex,
+    localAttestation: metadata.localAttestation,
+    rtmr0: metadata.rtmr0,
+    rtmr1: metadata.rtmr1,
+    rtmr2: metadata.rtmr2,
+    rtmr3: metadata.rtmr3,
+    verifiedAtMs: Date.now()
+  };
+}
+function reattestSerialized(state, endpoint, timeoutMs = DEFAULT_REATTEST_TIMEOUT_MS) {
+  if (state.reattestPromise !== null) {
+    return state.reattestPromise;
+  }
+  const promise = Promise.resolve().then(() => reattest(state, endpoint, timeoutMs)).finally(() => {
+    if (state.reattestPromise === promise) {
+      state.reattestPromise = null;
+    }
+  });
+  state.reattestPromise = promise;
+  return promise;
+}
+function toHex(b) {
+  let s = "";
+  for (let i = 0; i < b.length; i++) s += b[i].toString(16).padStart(2, "0");
+  return s;
+}
+
+// src/session/createSession.ts
+var REATTEST_EVERY_MS = 9e5;
+async function createSessionInternal(options) {
+  const { coordinator } = options;
+  if (options.clientPersistence !== void 0 && typeof options.clientPersistence !== "boolean") {
+    throw new TypeError("clientPersistence must be a boolean");
+  }
+  if (!validateCoordinatorPoolConfigShape(coordinator)) {
+    throw new Error(
+      `invalid coordinator pool config: ${formatAjvErrors(validateCoordinatorPoolConfigShape.errors)}`
+    );
+  }
+  const endpoint = coordinator.endpoints[0];
+  assertExpectedHostname(endpoint);
+  const clientPersistence = options.clientPersistence === true ? await resolveClientPersistence(true, options.storage) : disabledClientPersistence();
+  const timeoutMs = coordinator.noiseTransportTimeoutMs;
+  const transport = options.transport ?? noiseWebSocketTransport({ wsUrl: endpoint.wsUrl, connectTimeoutMs: timeoutMs });
+  await transport.connect(options.signal);
+  const nonce = crypto.getRandomValues(new Uint8Array(32));
+  let established;
+  try {
+    established = await abortableSessionEstablishment(
+      establishAttestedChannel({ transport, endpoint, nonce, timeoutMs }),
+      transport,
+      options.signal
+    );
+  } catch (err2) {
+    transport.close();
+    throw err2;
+  }
+  const state = {
+    attested: true,
+    transport,
+    pool: coordinator,
+    attestation: established.attestation,
+    channel: established.channel,
+    nonce,
+    remoteStaticPublicKey: established.handshake.noiseStaticPublicKey,
+    reattestTimer: null,
+    reattestPromise: null,
+    lastFatalError: null,
+    policyViolationHandlers: /* @__PURE__ */ new Set(),
+    clientPersistence,
+    close() {
+      closeSessionState(this);
+    }
+  };
+  established.channel.onFatal((error) => failSessionClosed(state, error));
+  scheduleReattest(state, endpoint);
+  return createSessionHandle(state);
+}
+function abortableSessionEstablishment(establishment, transport, signal) {
+  if (signal === void 0) return establishment;
+  if (signal.aborted) {
+    transport.close();
+    return Promise.reject(createSessionAbortError());
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      transport.close();
+      reject(createSessionAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    void establishment.then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
+}
+function createSessionAbortError() {
+  return new TransportError("CONNECTION_LOST", "session establishment aborted");
+}
+var createSession = createSessionInternal;
+function assertExpectedHostname(endpoint) {
+  let hostname;
+  try {
+    hostname = new URL(endpoint.wsUrl).hostname;
+  } catch (err2) {
+    const error = new Error(`invalid coordinator wsUrl: ${endpoint.wsUrl}`);
+    error.cause = err2;
+    throw error;
+  }
+  if (hostname.toLowerCase() !== endpoint.expectedHostname.toLowerCase()) {
+    throw new Error(
+      `coordinator endpoint hostname ${hostname} does not match expectedHostname ${endpoint.expectedHostname}`
+    );
+  }
+}
+function closeSession(session) {
+  getSessionState(session).close();
+}
+function scheduleReattest(state, endpoint) {
+  if (state.channel === null) return;
+  const reattestEveryMs = state.pool.reattestEveryMs ?? REATTEST_EVERY_MS;
+  const timer = setTimeout(() => {
+    void runReattest(state, endpoint);
+  }, reattestEveryMs);
+  if (typeof timer === "object" && timer !== null && "unref" in timer) {
+    timer.unref();
+  }
+  state.reattestTimer = timer;
+}
+async function runReattest(state, endpoint) {
+  state.reattestTimer = null;
+  if (state.channel === null || state.nonce === null || state.remoteStaticPublicKey === null) {
+    return;
+  }
+  try {
+    state.attestation = await reattestSerialized(
+      state,
+      endpoint,
+      state.pool.noiseTransportTimeoutMs
+    );
+    state.attested = true;
+    scheduleReattest(state, endpoint);
+  } catch (err2) {
+    const error = err2 instanceof Error ? err2 : new Error(String(err2));
+    failSessionClosed(state, error);
+  }
+}
+
+export { INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256, closeSession, createExponentialBackoff, createSession, createSessionInternal, createStateController, disabledClientPersistence, formatAjvErrors, getPersistedTransfer, isLoopbackUrl, listPersistedTransfers, noiseWebSocketTransport, persistTransferAllocation, persistTransferDkgMetadata, persistTransferReady, persistTransferRecoveryCode, persistTransferStatus, persistTransferTerminal, purgePersistedTransfers, readPersistedTransferForResume, reattestSerialized, removePersistedTransfer, validatePayoutPolicyShape };
+//# sourceMappingURL=chunk-Y7AK6RBV.js.map
+//# sourceMappingURL=chunk-Y7AK6RBV.js.map