@piprail/sdk 2.8.0 → 2.10.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
 
+var _chunkO4UQOZ4Zcjs = require('./chunk-O4UQOZ4Z.cjs');
 
 
+var _chunkCQQI5IJXcjs = require('./chunk-CQQI5IJX.cjs');
 
 
 
@@ -24,7 +26,12 @@
 
 
 
-var _chunkVPENSVOIcjs = require('./chunk-VPENSVOI.cjs');
+
+
+
+
+
+var _chunkMWBT7MCEcjs = require('./chunk-MWBT7MCE.cjs');
 
 // src/drivers/registry.ts
 var byFamily = /* @__PURE__ */ new Map();
@@ -53,13 +60,13 @@ function resolveNetwork(opts) {
   const family = familyForChain(opts.chain);
   const driver = byFamily.get(family);
   if (!driver) {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedNetworkError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedNetworkError)(
       `No driver registered for the "${family}" family \u2014 it may not be mounted yet (use the async resolveNetwork()).`
     );
   }
   const net = driver.resolve(opts);
   if (!net) {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedNetworkError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedNetworkError)(
       `The ${family} driver didn't recognise this chain input.`
     );
   }
@@ -320,12 +327,12 @@ function resolveChain(input, rpcUrlOverride) {
 
 var _accounts = require('viem/accounts');
 function createWalletAdapter(config, resolved) {
-  _chunkVPENSVOIcjs.assertNoLegacyWalletKey.call(void 0, config, "EVM");
+  _chunkMWBT7MCEcjs.assertNoLegacyWalletKey.call(void 0, config, "EVM");
   if ("key" in config) {
     const key = config.key;
     if (typeof key !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(key)) {
       const hint = typeof key === "string" && !key.startsWith("0x") ? " (got a non-0x string \u2014 a base58/seed key belongs to another family; pass { key } as the EVM chain's 0x\u2026 hex secret)." : " (expected 0x followed by 64 hex characters).";
-      throw new (0, _chunkVPENSVOIcjs.WrongFamilyError)(
+      throw new (0, _chunkMWBT7MCEcjs.WrongFamilyError)(
         `chain is EVM; the wallet { key } is not a valid 0x\u2026 32-byte hex private key${hint}`
       );
     }
@@ -333,7 +340,7 @@ function createWalletAdapter(config, resolved) {
     try {
       account = _accounts.privateKeyToAccount.call(void 0, key);
     } catch (err) {
-      throw new (0, _chunkVPENSVOIcjs.WrongFamilyError)(
+      throw new (0, _chunkMWBT7MCEcjs.WrongFamilyError)(
         `chain is EVM; the wallet { key } is not a valid 0x\u2026 32-byte hex private key: ${err instanceof Error ? err.message : String(err)}.`
       );
     }
@@ -343,12 +350,12 @@ function createWalletAdapter(config, resolved) {
   }
   const wc = config.walletClient;
   if (!wc.account) {
-    throw new (0, _chunkVPENSVOIcjs.WrongFamilyError)(
+    throw new (0, _chunkMWBT7MCEcjs.WrongFamilyError)(
       "chain is EVM; the provided walletClient has no attached account. Use `createWalletClient({ account, chain, transport })`, or pass { key }."
     );
   }
   if (wc.chain && wc.chain.id !== resolved.chainId) {
-    throw new (0, _chunkVPENSVOIcjs.WrongChainError)(
+    throw new (0, _chunkMWBT7MCEcjs.WrongChainError)(
       `PipRailClient: walletClient is on chain ${wc.chain.id} but the SDK was configured with chain ${resolved.chainId}. They must match.`
     );
   }
@@ -678,7 +685,7 @@ async function payExactEvm(input) {
     code = void 0;
   }
   if (code && code !== "0x") {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
       `exact buyer rail requires an EOA signer; ${account.address} is a contract / EIP-1271 / EIP-7702-delegated account (no recoverable ECDSA signature). Pay via onchain-proof.`
     );
   }
@@ -688,13 +695,13 @@ async function payExactEvm(input) {
     domain = await readExactDomain(publicClient, accept.asset);
   }
   if (!domain) {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
       `exact: couldn't derive the EIP-712 domain for ${accept.asset} on ${accept.network}. Either it isn't an EIP-3009 token (USDT needs Permit2; native/plain ERC-20 aren't exact-payable) \u2014 pay via onchain-proof \u2014 OR your RPC couldn't read it (transient): if the gate advertised eip3009, pass a reliable rpcUrl and retry.`
     );
   }
   const g = globalThis.crypto;
   if (!_optionalChain([g, 'optionalAccess', _5 => _5.getRandomValues])) {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
       "this runtime lacks Web Crypto (globalThis.crypto.getRandomValues); the exact rail needs a CSPRNG nonce."
     );
   }
@@ -951,7 +958,7 @@ async function verifyAndSettleExactEvm(input) {
       args: writeArgs
     });
   } catch (err) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `exact settle: the merchant relayer failed to broadcast transferWithAuthorization (${shorten(err instanceof Error ? err.message : String(err))}). The payer's authorization is still valid and unused \u2014 fund/fix the relayer and the payer can retry.`,
       { cause: err }
     );
@@ -963,7 +970,7 @@ async function verifyAndSettleExactEvm(input) {
       return { ok: false, error: "tx_reverted", detail: `Settlement tx ${txHash} reverted on-chain.` };
     }
   } catch (err) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `exact settle: broadcast ${txHash} but couldn't confirm it (${shorten(err instanceof Error ? err.message : String(err))}).`,
       { cause: err }
     );
@@ -1094,7 +1101,7 @@ function shorten2(msg) {
 function randomPermit2Nonce() {
   const g = globalThis.crypto;
   if (!_optionalChain([g, 'optionalAccess', _8 => _8.getRandomValues])) {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
       "this runtime lacks Web Crypto (globalThis.crypto.getRandomValues); the permit2 rail needs a CSPRNG nonce."
     );
   }
@@ -1113,7 +1120,7 @@ async function ensurePermit2Allowance(input) {
       args: [account.address, PERMIT2_ADDRESS]
     });
   } catch (err) {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
       `permit2: couldn't read the Permit2 allowance for ${token} (${shorten2(err instanceof Error ? err.message : String(err))}).`
     );
   }
@@ -1130,7 +1137,7 @@ async function ensurePermit2Allowance(input) {
     await publicClient.waitForTransactionReceipt({ hash, confirmations: 1 });
     return hash;
   } catch (err) {
-    throw _nullishCoalesce(_chunkVPENSVOIcjs.toInsufficientFundsError.call(void 0, err), () => ( new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw _nullishCoalesce(_chunkMWBT7MCEcjs.toInsufficientFundsError.call(void 0, err), () => ( new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `permit2: the one-time Permit2 approval for ${token} failed to broadcast (${shorten2(err instanceof Error ? err.message : String(err))}).`,
       { cause: err }
     )));
@@ -1145,7 +1152,7 @@ async function payPermit2Evm(input) {
     code = void 0;
   }
   if (code && code !== "0x") {
-    throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
       `permit2 buyer rail requires an EOA signer; ${account.address} is a contract / EIP-1271 / EIP-7702-delegated account. Pay via onchain-proof.`
     );
   }
@@ -1320,7 +1327,7 @@ async function verifyAndSettlePermit2Evm(input) {
       args: settleArgs
     });
   } catch (err) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `permit2 settle: the merchant relayer failed to broadcast the proxy settle (${shorten2(err instanceof Error ? err.message : String(err))}). The payer's signature is still valid and its nonce unused \u2014 fund/fix the relayer and the payer can retry.`,
       { cause: err }
     );
@@ -1332,7 +1339,7 @@ async function verifyAndSettlePermit2Evm(input) {
       return { ok: false, error: "tx_reverted", detail: `Settlement tx ${txHash} reverted on-chain.` };
     }
   } catch (err) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `permit2 settle: broadcast ${txHash} but couldn't confirm it (${shorten2(err instanceof Error ? err.message : String(err))}).`,
       { cause: err }
     );
@@ -1353,144 +1360,540 @@ async function verifyAndSettlePermit2Evm(input) {
   };
 }
 
-// src/x402.ts
-var HEADER_REQUIRED = "payment-required";
-var HEADER_SIGNATURE = "payment-signature";
-var HEADER_RESPONSE = "payment-response";
-var HEADER_SIGNATURE_V1 = "x-payment";
-var HEADER_RESPONSE_V1 = "x-payment-response";
-function encodeBase64(str) {
-  if (typeof Buffer !== "undefined") return Buffer.from(str, "utf8").toString("base64");
-  if (typeof btoa === "function" && typeof TextEncoder !== "undefined") {
-    const bytes = new TextEncoder().encode(str);
-    let binary = "";
-    for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
-    return btoa(binary);
+// src/drivers/evm/upto.ts
+
+
+
+
+var X402_UPTO_PERMIT2_PROXY = "0x4020A4f3b7b90ccA423B9fabCc0CE57C6C240002";
+var UPTO_PROXY_CHAIN_IDS = /* @__PURE__ */ new Set([
+  1,
+  // Ethereum
+  8453,
+  // Base
+  42161,
+  // Arbitrum
+  10,
+  // Optimism
+  137,
+  // Polygon
+  56
+  // BNB
+]);
+function isUptoProxyChain(chainId) {
+  return UPTO_PROXY_CHAIN_IDS.has(chainId);
+}
+var PERMIT2_UPTO_WITNESS_TYPES = {
+  PermitWitnessTransferFrom: PERMIT2_WITNESS_TYPES.PermitWitnessTransferFrom,
+  TokenPermissions: PERMIT2_WITNESS_TYPES.TokenPermissions,
+  Witness: [
+    { name: "to", type: "address" },
+    { name: "facilitator", type: "address" },
+    { name: "validAfter", type: "uint256" }
+  ]
+};
+var x402UptoProxyAbi = [
+  {
+    type: "function",
+    name: "settle",
+    stateMutability: "nonpayable",
+    outputs: [],
+    inputs: [
+      {
+        name: "permit",
+        type: "tuple",
+        components: [
+          {
+            name: "permitted",
+            type: "tuple",
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          { name: "nonce", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ]
+      },
+      { name: "amount", type: "uint256" },
+      { name: "owner", type: "address" },
+      {
+        name: "witness",
+        type: "tuple",
+        components: [
+          { name: "to", type: "address" },
+          { name: "facilitator", type: "address" },
+          { name: "validAfter", type: "uint256" }
+        ]
+      },
+      { name: "signature", type: "bytes" }
+    ]
   }
-  throw new Error("No base64 encoder available in this runtime.");
+];
+function shorten3(msg) {
+  const oneLine = msg.replace(/\s+/g, " ").trim();
+  return oneLine.length > 200 ? `${oneLine.slice(0, 200)}\u2026` : oneLine;
 }
-function decodeBase64(b64) {
-  if (typeof Buffer !== "undefined") return Buffer.from(b64, "base64").toString("utf8");
-  if (typeof atob === "function" && typeof TextDecoder !== "undefined") {
-    const binary = atob(b64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-    return new TextDecoder().decode(bytes);
+function randomPermit2Nonce2() {
+  const g = globalThis.crypto;
+  if (!_optionalChain([g, 'optionalAccess', _9 => _9.getRandomValues])) {
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
+      "this runtime lacks Web Crypto (globalThis.crypto.getRandomValues); the upto rail needs a CSPRNG nonce."
+    );
   }
-  throw new Error("No base64 decoder available in this runtime.");
+  const raw = new Uint8Array(32);
+  g.getRandomValues(raw);
+  return BigInt(`0x${[...raw].map((b) => b.toString(16).padStart(2, "0")).join("")}`);
 }
-function fromBase64Json(b64) {
+async function payUptoEvm(input) {
+  const { publicClient, walletClient, account, chainId, chain, accept } = input;
+  let code;
   try {
-    return JSON.parse(decodeBase64(b64));
+    code = await publicClient.getCode({ address: account.address });
   } catch (e16) {
-    return null;
+    code = void 0;
   }
-}
-function toBase64Json(value) {
-  return encodeBase64(JSON.stringify(value));
-}
-function networkForChain(chainId) {
-  return `eip155:${chainId}`;
-}
-function chainIdFromNetwork(network) {
-  const match = /^eip155:(\d+)$/.exec(network);
-  if (!match || !match[1]) return null;
-  const n = Number(match[1]);
-  return Number.isSafeInteger(n) && n > 0 ? n : null;
-}
-function buildChallengeHeader(challenge) {
-  return toBase64Json(challenge);
-}
-function buildReceiptHeader(receipt) {
-  return toBase64Json(receipt);
-}
-function buildSignatureHeader(signature) {
-  return toBase64Json(signature);
-}
-function buildExactSignatureHeader(input) {
-  return toBase64Json({ x402Version: 2, accepted: input.accepted, payload: input.payload });
-}
-async function parseChallenge(response) {
-  const headerValue = response.headers.get(HEADER_REQUIRED);
-  if (headerValue) {
-    const parsed = fromBase64Json(headerValue);
-    if (isValidChallenge(parsed)) return parsed;
+  if (code && code !== "0x") {
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
+      `upto buyer rail requires an EOA signer; ${account.address} is a contract / EIP-1271 / EIP-7702-delegated account. Pay via onchain-proof.`
+    );
   }
-  try {
-    const body = await response.clone().json();
-    if (isValidChallenge(body)) return body;
-  } catch (e17) {
+  const facilitatorAddress = _optionalChain([accept, 'access', _10 => _10.extra, 'optionalAccess', _11 => _11.facilitatorAddress]);
+  if (typeof facilitatorAddress !== "string" || facilitatorAddress.length === 0) {
+    throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
+      `upto: the rail carries no extra.facilitatorAddress to bind into witness.facilitator \u2014 refusing to sign.`
+    );
   }
-  return null;
-}
-function parseReceipt(response) {
-  const headerValue = _nullishCoalesce(response.headers.get(HEADER_RESPONSE), () => ( response.headers.get(HEADER_RESPONSE_V1)));
-  if (!headerValue) return null;
-  const parsed = fromBase64Json(headerValue);
-  return isValidReceipt(parsed) ? parsed : null;
-}
-function parseSettleResponse(response) {
-  const headerValue = _nullishCoalesce(response.headers.get(HEADER_RESPONSE), () => ( response.headers.get(HEADER_RESPONSE_V1)));
-  if (!headerValue) return null;
-  const parsed = fromBase64Json(headerValue);
-  if (!parsed || typeof parsed !== "object" || typeof parsed.success !== "boolean") return null;
+  const token = _viem.getAddress.call(void 0, accept.asset);
+  const payTo = _viem.getAddress.call(void 0, accept.payTo);
+  const facilitator = _viem.getAddress.call(void 0, facilitatorAddress);
+  const value = BigInt(accept.amount);
+  const approvalTx = await ensurePermit2Allowance({
+    publicClient,
+    walletClient,
+    account,
+    chain,
+    token,
+    amount: value
+  });
+  const nonce = randomPermit2Nonce2();
+  const deadline = BigInt(Math.floor(Date.now() / 1e3) + accept.maxTimeoutSeconds);
+  const validAfter = 0n;
+  const spender = _viem.getAddress.call(void 0, X402_UPTO_PERMIT2_PROXY);
+  const from = account.address;
+  const signature = await walletClient.signTypedData({
+    account,
+    domain: { name: "Permit2", chainId, verifyingContract: PERMIT2_ADDRESS },
+    types: PERMIT2_UPTO_WITNESS_TYPES,
+    primaryType: "PermitWitnessTransferFrom",
+    message: {
+      permitted: { token, amount: value },
+      spender,
+      nonce,
+      deadline,
+      witness: { to: payTo, facilitator, validAfter }
+    }
+  });
+  const permit2Authorization = {
+    permitted: { token, amount: value.toString() },
+    from,
+    spender,
+    nonce: nonce.toString(),
+    deadline: deadline.toString(),
+    witness: { to: payTo, facilitator, validAfter: validAfter.toString() }
+  };
   return {
-    success: parsed.success,
-    ...typeof parsed.transaction === "string" ? { transaction: parsed.transaction } : {},
-    ...typeof parsed.network === "string" ? { network: parsed.network } : {},
-    ...typeof parsed.payer === "string" ? { payer: parsed.payer } : {},
-    ...typeof parsed.errorReason === "string" ? { errorReason: parsed.errorReason } : {}
+    payload: { signature, permit2Authorization },
+    payerFrom: from,
+    nonce: nonce.toString(),
+    ...approvalTx ? { approvalTx } : {}
   };
 }
-function parseSignatureHeader(value) {
-  const parsed = fromBase64Json(value);
-  if (!parsed || typeof parsed !== "object") return null;
-  const v = parsed;
-  const accepted = v.accepted;
-  const scheme = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _9 => _9.scheme]), () => ( v.scheme));
-  if (scheme !== "onchain-proof") return null;
-  const payload = v.payload;
-  if (!payload || typeof payload.txHash !== "string" || typeof payload.nonce !== "string") {
-    return null;
+function resolveUptoRailEvm(input) {
+  const { asset, relayerAddress, proxySupported, domain } = input;
+  if (asset === "native") return null;
+  if (!proxySupported()) return null;
+  const extra = { facilitatorAddress: _viem.getAddress.call(void 0, relayerAddress) };
+  if (domain) {
+    extra.name = domain.name;
+    extra.version = domain.version;
   }
-  return parsed;
+  return { method: "permit2-upto", extra };
 }
-function parseExactPaymentHeader(value) {
-  const parsed = fromBase64Json(value);
-  if (!parsed || typeof parsed !== "object") return null;
-  const v = parsed;
-  const accepted = _nullishCoalesce(v.accepted, () => ( null));
-  const scheme = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _10 => _10.scheme]), () => ( v.scheme));
-  if (scheme !== "exact") return null;
-  const network = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _11 => _11.network]), () => ( v.network));
-  if (typeof network !== "string") return null;
-  const payload = v.payload;
-  if (!payload || typeof payload !== "object") return null;
-  const x402Version = typeof v.x402Version === "number" ? v.x402Version : 2;
-  const asset = accepted && typeof accepted.asset === "string" ? accepted.asset : void 0;
-  const base2 = { x402Version, network, ...asset ? { asset } : {}, raw: v };
-  if (typeof payload.signedDelegateAction === "string") {
-    return { ...base2, method: "near", payload: { signedDelegateAction: payload.signedDelegateAction } };
+async function verifyAndSettleUptoEvm(input) {
+  const { publicClient, walletClient, account, chain, payload, accept, settleAmount } = input;
+  const token = _viem.getAddress.call(void 0, accept.asset);
+  const payTo = _viem.getAddress.call(void 0, accept.payTo);
+  const maxAmount = BigInt(accept.amount);
+  const proxy = _viem.getAddress.call(void 0, X402_UPTO_PERMIT2_PROXY);
+  const relayerAddress = _viem.getAddress.call(void 0, account.address);
+  let from;
+  let spender;
+  let permittedToken;
+  let witnessTo;
+  let witnessFacilitator;
+  let permittedAmount;
+  let nonce;
+  let deadline;
+  let validAfter;
+  const signature = payload.signature;
+  try {
+    const pa = payload.permit2Authorization;
+    from = _viem.getAddress.call(void 0, pa.from);
+    spender = _viem.getAddress.call(void 0, pa.spender);
+    permittedToken = _viem.getAddress.call(void 0, pa.permitted.token);
+    witnessTo = _viem.getAddress.call(void 0, pa.witness.to);
+    witnessFacilitator = _viem.getAddress.call(void 0, pa.witness.facilitator);
+    permittedAmount = BigInt(pa.permitted.amount);
+    nonce = BigInt(pa.nonce);
+    deadline = BigInt(pa.deadline);
+    validAfter = BigInt(pa.witness.validAfter);
+    if (!/^0x[0-9a-fA-F]+$/.test(signature)) throw new Error("signature must be hex");
+  } catch (err) {
+    return {
+      ok: false,
+      error: "signature_invalid",
+      detail: `Malformed upto authorization: ${err instanceof Error ? err.message : String(err)}.`
+    };
   }
-  if (typeof payload.transaction === "string" && typeof payload.senderAuth === "string") {
-    return { ...base2, method: "aptos", payload: { transaction: payload.transaction, senderAuth: payload.senderAuth } };
+  if (witnessTo !== payTo) {
+    return { ok: false, error: "wrong_recipient", detail: `Authorization pays witness.to ${witnessTo}, not ${payTo}.` };
   }
-  if (typeof payload.transaction === "string") {
-    return { ...base2, method: "svm", payload: { transaction: payload.transaction } };
+  if (permittedToken !== token) {
+    return { ok: false, error: "signature_invalid", detail: `Authorization permits token ${permittedToken}, not the rail's ${token}.` };
   }
-  if (Array.isArray(payload.paymentGroup)) {
-    const group = payload.paymentGroup;
-    const index = payload.paymentIndex;
-    if (group.length === 0 || group.length > 16 || !group.every((t) => typeof t === "string") || typeof index !== "number" || !Number.isInteger(index) || index < 0 || index >= group.length) {
-      return null;
-    }
-    return {
-      ...base2,
-      method: "algorand",
-      payload: { paymentIndex: index, paymentGroup: group }
-    };
+  if (spender !== proxy) {
+    return { ok: false, error: "signature_invalid", detail: `Authorization spender ${spender} is not the x402UptoPermit2Proxy ${proxy}; it can't be settled here.` };
   }
-  const signature = payload.signature;
+  if (witnessFacilitator !== relayerAddress) {
+    return { ok: false, error: "signature_invalid", detail: `Authorization binds facilitator ${witnessFacilitator}, not this relayer ${relayerAddress}; only the bound facilitator can settle.` };
+  }
+  if (permittedAmount < maxAmount) {
+    return { ok: false, error: "amount_too_low", detail: `Permitted (signed MAX) ${permittedAmount} is below the rail max ${maxAmount}.` };
+  }
+  if (permittedAmount > maxAmount) {
+    return { ok: false, error: "upto_settle_exceeds_max", detail: `Permitted (signed MAX) ${permittedAmount} exceeds the advertised rail max ${maxAmount}; sign exactly the ceiling.` };
+  }
+  if (settleAmount < 0n) {
+    return { ok: false, error: "upto_settle_exceeds_max", detail: `Settle amount ${settleAmount} is negative.` };
+  }
+  if (settleAmount > permittedAmount) {
+    return { ok: false, error: "upto_settle_exceeds_max", detail: `Settle amount ${settleAmount} exceeds the signed MAX ${permittedAmount}.` };
+  }
+  const now = BigInt(Math.floor(Date.now() / 1e3));
+  if (deadline <= now) {
+    return { ok: false, error: "payment_expired", detail: `Permit2 deadline ${deadline} <= now ${now}.` };
+  }
+  let fromCode;
+  try {
+    fromCode = await publicClient.getCode({ address: from });
+  } catch (e17) {
+    return { ok: false, error: "tx_not_found", detail: `Could not read code at ${from} (transient RPC) \u2014 retry.` };
+  }
+  if (!(fromCode && fromCode !== "0x")) {
+    let recovered;
+    try {
+      recovered = await _viem.recoverTypedDataAddress.call(void 0, {
+        domain: { name: "Permit2", chainId: chain.id, verifyingContract: PERMIT2_ADDRESS },
+        types: PERMIT2_UPTO_WITNESS_TYPES,
+        primaryType: "PermitWitnessTransferFrom",
+        message: {
+          permitted: { token: permittedToken, amount: permittedAmount },
+          spender,
+          nonce,
+          deadline,
+          witness: { to: witnessTo, facilitator: witnessFacilitator, validAfter }
+        },
+        signature
+      });
+    } catch (err) {
+      return { ok: false, error: "signature_invalid", detail: `Not a valid EIP-712 signature: ${shorten3(err instanceof Error ? err.message : String(err))}.` };
+    }
+    if (recovered !== from) {
+      return { ok: false, error: "signature_invalid", detail: `Signature recovered to ${recovered}, not the authorizer ${from}.` };
+    }
+  }
+  if (settleAmount === 0n) {
+    return {
+      ok: true,
+      receipt: {
+        scheme: "upto",
+        success: true,
+        network: accept.network,
+        transaction: "",
+        asset: accept.asset,
+        amount: "0",
+        payer: from,
+        payTo: accept.payTo,
+        verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  try {
+    const word = nonce >> 8n;
+    const bit = nonce & 0xffn;
+    const bitmap = await publicClient.readContract({
+      address: PERMIT2_ADDRESS,
+      abi: permit2NonceBitmapAbi,
+      functionName: "nonceBitmap",
+      args: [from, word]
+    });
+    if ((bitmap >> bit & 1n) === 1n) {
+      return { ok: false, error: "tx_already_used", detail: `Permit2 nonce ${nonce} already used or invalidated for ${from}.` };
+    }
+  } catch (e18) {
+    return { ok: false, error: "tx_not_found", detail: "Could not read the Permit2 nonce bitmap (transient RPC) \u2014 retry." };
+  }
+  const settleArgs = [
+    { permitted: { token: permittedToken, amount: permittedAmount }, nonce, deadline },
+    settleAmount,
+    from,
+    { to: witnessTo, facilitator: witnessFacilitator, validAfter },
+    signature
+  ];
+  try {
+    await publicClient.simulateContract({
+      account,
+      address: proxy,
+      abi: x402UptoProxyAbi,
+      functionName: "settle",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: settleArgs
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/nonce|invalidated|used/i.test(msg)) return { ok: false, error: "tx_already_used", detail: "Permit2 nonce is used or invalidated." };
+    if (/expired|deadline|too early|not yet/i.test(msg)) return { ok: false, error: "payment_expired", detail: shorten3(msg) };
+    if (/exceeds.*permitted|AmountExceeds/i.test(msg)) return { ok: false, error: "upto_settle_exceeds_max", detail: shorten3(msg) };
+    if (/facilitator|Unauthorized/i.test(msg)) return { ok: false, error: "signature_invalid", detail: shorten3(msg) };
+    if (/signature/i.test(msg)) return { ok: false, error: "signature_invalid", detail: shorten3(msg) };
+    return { ok: false, error: "tx_reverted", detail: `upto settle would revert: ${shorten3(msg)}` };
+  }
+  let txHash;
+  try {
+    txHash = await walletClient.writeContract({
+      account,
+      chain,
+      address: proxy,
+      abi: x402UptoProxyAbi,
+      functionName: "settle",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      args: settleArgs
+    });
+  } catch (err) {
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
+      `upto settle: the merchant relayer failed to broadcast the proxy settle (${shorten3(err instanceof Error ? err.message : String(err))}). The payer's signature is still valid and its nonce unused \u2014 fund/fix the relayer and the payer can retry.`,
+      { cause: err }
+    );
+  }
+  try {
+    const confirmations = _nullishCoalesce(accept.extra.minConfirmations, () => ( 1));
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash, confirmations });
+    if (receipt.status !== "success") {
+      return { ok: false, error: "tx_reverted", detail: `Settlement tx ${txHash} reverted on-chain.` };
+    }
+  } catch (err) {
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
+      `upto settle: broadcast ${txHash} but couldn't confirm it (${shorten3(err instanceof Error ? err.message : String(err))}).`,
+      { cause: err }
+    );
+  }
+  return {
+    ok: true,
+    receipt: {
+      scheme: "upto",
+      success: true,
+      network: accept.network,
+      transaction: txHash,
+      asset: accept.asset,
+      // The ACTUAL settled amount (≤ max) — what the buyer reads back to record metered spend.
+      amount: settleAmount.toString(),
+      payer: from,
+      payTo: accept.payTo,
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+
+// src/x402.ts
+var HEADER_REQUIRED = "payment-required";
+var HEADER_SIGNATURE = "payment-signature";
+var HEADER_RESPONSE = "payment-response";
+var HEADER_SIGNATURE_V1 = "x-payment";
+var HEADER_RESPONSE_V1 = "x-payment-response";
+function encodeBase64(str) {
+  if (typeof Buffer !== "undefined") return Buffer.from(str, "utf8").toString("base64");
+  if (typeof btoa === "function" && typeof TextEncoder !== "undefined") {
+    const bytes = new TextEncoder().encode(str);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+  }
+  throw new Error("No base64 encoder available in this runtime.");
+}
+function decodeBase64(b64) {
+  if (typeof Buffer !== "undefined") return Buffer.from(b64, "base64").toString("utf8");
+  if (typeof atob === "function" && typeof TextDecoder !== "undefined") {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  }
+  throw new Error("No base64 decoder available in this runtime.");
+}
+function fromBase64Json(b64) {
+  try {
+    return JSON.parse(decodeBase64(b64));
+  } catch (e19) {
+    return null;
+  }
+}
+function decodeBase64Json(value) {
+  return fromBase64Json(value);
+}
+function toBase64Json(value) {
+  return encodeBase64(JSON.stringify(value));
+}
+function networkForChain(chainId) {
+  return `eip155:${chainId}`;
+}
+function chainIdFromNetwork(network) {
+  const match = /^eip155:(\d+)$/.exec(network);
+  if (!match || !match[1]) return null;
+  const n = Number(match[1]);
+  return Number.isSafeInteger(n) && n > 0 ? n : null;
+}
+function buildChallengeHeader(challenge) {
+  return toBase64Json(challenge);
+}
+function buildReceiptHeader(receipt, extensions) {
+  return toBase64Json(extensions ? { ...receipt, extensions } : receipt);
+}
+var EXT_OFFER_RECEIPT = "offer-receipt";
+function buildReceiptExtension(bundle) {
+  const info = { settlement: bundle.receipt, resource: bundle.resource };
+  if (typeof bundle.decimals === "number") info.decimals = bundle.decimals;
+  if (bundle.attestation) info.receipt = bundle.attestation;
+  return { [EXT_OFFER_RECEIPT]: { info } };
+}
+function buildSignatureHeader(signature) {
+  return toBase64Json(signature);
+}
+function buildExactSignatureHeader(input) {
+  return toBase64Json({ x402Version: 2, accepted: input.accepted, payload: input.payload });
+}
+function buildUptoSignatureHeader(input) {
+  return toBase64Json({ x402Version: 2, accepted: input.accepted, payload: input.payload });
+}
+async function parseChallenge(response) {
+  const headerValue = response.headers.get(HEADER_REQUIRED);
+  if (headerValue) {
+    const parsed = fromBase64Json(headerValue);
+    if (isValidChallenge(parsed)) return parsed;
+  }
+  try {
+    const body = await response.clone().json();
+    if (isValidChallenge(body)) return body;
+  } catch (e20) {
+  }
+  return null;
+}
+function parseReceipt(response) {
+  const headerValue = _nullishCoalesce(response.headers.get(HEADER_RESPONSE), () => ( response.headers.get(HEADER_RESPONSE_V1)));
+  if (!headerValue) return null;
+  const parsed = fromBase64Json(headerValue);
+  return isValidReceipt(parsed) ? parsed : null;
+}
+function parseReceiptExtension(response) {
+  const headerValue = _nullishCoalesce(response.headers.get(HEADER_RESPONSE), () => ( response.headers.get(HEADER_RESPONSE_V1)));
+  if (!headerValue) return null;
+  const parsed = fromBase64Json(headerValue);
+  if (!parsed || typeof parsed !== "object") return null;
+  const ext = parsed.extensions;
+  const block = _optionalChain([ext, 'optionalAccess', _12 => _12[EXT_OFFER_RECEIPT]]);
+  const info = _optionalChain([block, 'optionalAccess', _13 => _13.info]);
+  if (!info) return null;
+  const settlement = isValidReceipt(info.settlement) ? info.settlement : isValidReceipt(info.receipt) ? info.receipt : void 0;
+  if (!settlement) return null;
+  const attestation = info.receipt && info.receipt !== settlement ? info.receipt : void 0;
+  const res = info.resource;
+  return {
+    piprail: "1",
+    receipt: settlement,
+    resource: { url: res && typeof res.url === "string" ? res.url : "" },
+    ...typeof info.decimals === "number" ? { decimals: info.decimals } : {},
+    ...attestation ? { attestation } : {}
+  };
+}
+function parseSettleResponse(response) {
+  const headerValue = _nullishCoalesce(response.headers.get(HEADER_RESPONSE), () => ( response.headers.get(HEADER_RESPONSE_V1)));
+  if (!headerValue) return null;
+  const parsed = fromBase64Json(headerValue);
+  if (!parsed || typeof parsed !== "object" || typeof parsed.success !== "boolean") return null;
+  return {
+    success: parsed.success,
+    ...typeof parsed.transaction === "string" ? { transaction: parsed.transaction } : {},
+    ...typeof parsed.network === "string" ? { network: parsed.network } : {},
+    ...typeof parsed.payer === "string" ? { payer: parsed.payer } : {},
+    ...typeof parsed.errorReason === "string" ? { errorReason: parsed.errorReason } : {},
+    // The upto SettleResponse's REQUIRED `amount` (actual settled atomic units) — string
+    // passthrough so the upto buyer records ACTUAL, not MAX. Absent on onchain-proof/exact.
+    ...typeof parsed.amount === "string" ? { amount: parsed.amount } : {}
+  };
+}
+function parseSignatureObject(parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  const v = parsed;
+  const accepted = v.accepted;
+  const scheme = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _14 => _14.scheme]), () => ( v.scheme));
+  if (scheme !== "onchain-proof") return null;
+  const payload = v.payload;
+  if (!payload || typeof payload.txHash !== "string" || typeof payload.nonce !== "string") {
+    return null;
+  }
+  return parsed;
+}
+function parseSignatureHeader(value) {
+  return parseSignatureObject(fromBase64Json(value));
+}
+function parseExactPaymentHeader(value) {
+  return parseExactObject(fromBase64Json(value));
+}
+function parseExactObject(parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  const v = parsed;
+  const accepted = _nullishCoalesce(v.accepted, () => ( null));
+  const scheme = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _15 => _15.scheme]), () => ( v.scheme));
+  if (scheme !== "exact") return null;
+  const network = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _16 => _16.network]), () => ( v.network));
+  if (typeof network !== "string") return null;
+  const payload = v.payload;
+  if (!payload || typeof payload !== "object") return null;
+  const x402Version = typeof v.x402Version === "number" ? v.x402Version : 2;
+  const asset = accepted && typeof accepted.asset === "string" ? accepted.asset : void 0;
+  const base2 = { x402Version, network, ...asset ? { asset } : {}, raw: v };
+  if (typeof payload.signedDelegateAction === "string") {
+    return { ...base2, method: "near", payload: { signedDelegateAction: payload.signedDelegateAction } };
+  }
+  if (typeof payload.transaction === "string" && typeof payload.senderAuth === "string") {
+    return { ...base2, method: "aptos", payload: { transaction: payload.transaction, senderAuth: payload.senderAuth } };
+  }
+  if (typeof payload.transaction === "string") {
+    return { ...base2, method: "svm", payload: { transaction: payload.transaction } };
+  }
+  if (Array.isArray(payload.paymentGroup)) {
+    const group = payload.paymentGroup;
+    const index = payload.paymentIndex;
+    if (group.length === 0 || group.length > 16 || !group.every((t) => typeof t === "string") || typeof index !== "number" || !Number.isInteger(index) || index < 0 || index >= group.length) {
+      return null;
+    }
+    return {
+      ...base2,
+      method: "algorand",
+      payload: { paymentIndex: index, paymentGroup: group }
+    };
+  }
+  const signature = payload.signature;
   if (typeof signature !== "string") return null;
   const authorization = payload.authorization;
   if (authorization && typeof authorization === "object") {
@@ -1521,6 +1924,42 @@ function parseExactPaymentHeader(value) {
   }
   return null;
 }
+function parseUptoPaymentHeader(value) {
+  return parseUptoObject(fromBase64Json(value));
+}
+function parseUptoObject(parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  const v = parsed;
+  const accepted = _nullishCoalesce(v.accepted, () => ( null));
+  const scheme = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _17 => _17.scheme]), () => ( v.scheme));
+  if (scheme !== "upto") return null;
+  const network = _nullishCoalesce(_optionalChain([accepted, 'optionalAccess', _18 => _18.network]), () => ( v.network));
+  if (typeof network !== "string") return null;
+  const payload = v.payload;
+  if (!payload || typeof payload !== "object") return null;
+  const signature = payload.signature;
+  if (typeof signature !== "string") return null;
+  const p2 = payload.permit2Authorization;
+  if (!p2 || typeof p2 !== "object") return null;
+  const permitted = p2.permitted;
+  const witness = p2.witness;
+  if (!permitted || typeof permitted !== "object" || !witness || typeof witness !== "object") return null;
+  if (typeof permitted.token !== "string" || typeof permitted.amount !== "string") return null;
+  if (typeof witness.to !== "string" || typeof witness.facilitator !== "string" || typeof witness.validAfter !== "string") {
+    return null;
+  }
+  for (const k of ["from", "spender", "nonce", "deadline"]) {
+    if (typeof p2[k] !== "string") return null;
+  }
+  const x402Version = typeof v.x402Version === "number" ? v.x402Version : 2;
+  const asset = accepted && typeof accepted.asset === "string" ? accepted.asset : void 0;
+  const base2 = { x402Version, network, ...asset ? { asset } : {}, raw: v };
+  return {
+    ...base2,
+    method: "permit2-upto",
+    payload: { signature, permit2Authorization: p2 }
+  };
+}
 function isValidChallenge(value) {
   if (!value || typeof value !== "object") return false;
   const v = value;
@@ -1533,7 +1972,7 @@ function isValidChallenge(value) {
 function isValidReceipt(value) {
   if (!value || typeof value !== "object") return false;
   const v = value;
-  if (v.scheme !== "onchain-proof" && v.scheme !== "exact") return false;
+  if (v.scheme !== "onchain-proof" && v.scheme !== "exact" && v.scheme !== "upto") return false;
   if (typeof v.transaction !== "string" && typeof v.txHash !== "string") return false;
   if (typeof v.payer !== "string") return false;
   return true;
@@ -1556,7 +1995,7 @@ var evmDriver = {
     let resolved;
     try {
       resolved = resolveChain(opts.chain, opts.rpcUrl);
-    } catch (e18) {
+    } catch (e21) {
       return null;
     }
     return makeEvmNetwork(resolved);
@@ -1584,15 +2023,15 @@ function makeEvmNetwork(resolved) {
         const info = resolved.tokens[token.toUpperCase()];
         if (!info) {
           const known = Object.keys(resolved.tokens).join(", ") || "(none built in)";
-          throw new (0, _chunkVPENSVOIcjs.UnknownTokenError)(
+          throw new (0, _chunkMWBT7MCEcjs.UnknownTokenError)(
             `token "${token}" isn't built in for ${resolved.chain.name} (known: ${known}). Pass { address, decimals } instead, or use 'native'.`
           );
         }
         return { asset: info.address, decimals: info.decimals, symbol: info.symbol };
       }
-      _chunkVPENSVOIcjs.rejectForeignToken.call(void 0, token, "evm", network);
+      _chunkMWBT7MCEcjs.rejectForeignToken.call(void 0, token, "evm", network);
       if (!("address" in token)) {
-        throw new (0, _chunkVPENSVOIcjs.WrongFamilyError)(
+        throw new (0, _chunkMWBT7MCEcjs.WrongFamilyError)(
           `chain ${network} is EVM; a custom token must be { address, decimals }.`
         );
       }
@@ -1612,7 +2051,7 @@ function makeEvmNetwork(resolved) {
       let normalized;
       try {
         normalized = _viem.getAddress.call(void 0, asset);
-      } catch (e19) {
+      } catch (e22) {
         return null;
       }
       for (const info of Object.values(resolved.tokens)) {
@@ -1624,20 +2063,20 @@ function makeEvmNetwork(resolved) {
     },
     assertValidPayTo(payTo) {
       if (!_viem.isAddress.call(void 0, payTo)) {
-        throw new (0, _chunkVPENSVOIcjs.WrongFamilyError)(
+        throw new (0, _chunkMWBT7MCEcjs.WrongFamilyError)(
           `chain ${network} is EVM, but payTo "${payTo}" is not a valid 0x address.`
         );
       }
     },
     bindWallet(wallet) {
       if (typeof wallet !== "object" || wallet === null) {
-        throw new (0, _chunkVPENSVOIcjs.WrongFamilyError)(
+        throw new (0, _chunkMWBT7MCEcjs.WrongFamilyError)(
           `chain ${network} is EVM; wallet must be { key } (0x\u2026 hex) or { walletClient }.`
         );
       }
-      _chunkVPENSVOIcjs.assertNoLegacyWalletKey.call(void 0, wallet, "EVM");
+      _chunkMWBT7MCEcjs.assertNoLegacyWalletKey.call(void 0, wallet, "EVM");
       if (!("key" in wallet) && !("walletClient" in wallet)) {
-        throw new (0, _chunkVPENSVOIcjs.WrongFamilyError)(
+        throw new (0, _chunkMWBT7MCEcjs.WrongFamilyError)(
           `chain ${network} is EVM; wallet must be { key } (0x\u2026 hex) or { walletClient }.`
         );
       }
@@ -1654,12 +2093,12 @@ function makeEvmNetwork(resolved) {
         });
       } catch (err) {
         if (isViemInsufficientFunds(err)) {
-          throw new (0, _chunkVPENSVOIcjs.InsufficientFundsError)(
+          throw new (0, _chunkMWBT7MCEcjs.InsufficientFundsError)(
             err instanceof Error ? err.message : "Insufficient funds for payment.",
             { cause: err }
           );
         }
-        throw _nullishCoalesce(_chunkVPENSVOIcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+        throw _nullishCoalesce(_chunkMWBT7MCEcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
       }
     },
     async confirm(ref, minConfirmations) {
@@ -1670,7 +2109,7 @@ function makeEvmNetwork(resolved) {
         });
         return { height: receipt.blockNumber.toString() };
       } catch (err) {
-        throw new (0, _chunkVPENSVOIcjs.ConfirmationTimeoutError)(
+        throw new (0, _chunkMWBT7MCEcjs.ConfirmationTimeoutError)(
           `EVM tx ${ref} did not reach ${minConfirmations} confirmation(s) in time.`,
           { cause: err }
         );
@@ -1680,7 +2119,7 @@ function makeEvmNetwork(resolved) {
       const { decimals, symbol } = resolved.chain.nativeCurrency;
       if (accept.scheme === "exact") {
         const permit2 = accept.extra.assetTransferMethod === "permit2";
-        return _chunkVPENSVOIcjs.nativeCost.call(void 0, {
+        return _chunkMWBT7MCEcjs.nativeCost.call(void 0, {
           symbol,
           decimals,
           fee: 0n,
@@ -1691,16 +2130,16 @@ function makeEvmNetwork(resolved) {
       const gasLimit = accept.asset === "native" ? 21000n : 65000n;
       try {
         const gasPrice = await publicClient.getGasPrice();
-        return _chunkVPENSVOIcjs.nativeCost.call(void 0, {
+        return _chunkMWBT7MCEcjs.nativeCost.call(void 0, {
           symbol,
           decimals,
           fee: gasPrice * gasLimit,
           basis: "estimated",
           detail: `~${gasLimit} gas @ ${gasPrice} wei/gas`
         });
-      } catch (e20) {
+      } catch (e23) {
         const gasPrice = 5000000000n;
-        return _chunkVPENSVOIcjs.nativeCost.call(void 0, {
+        return _chunkMWBT7MCEcjs.nativeCost.call(void 0, {
           symbol,
           decimals,
           fee: gasPrice * gasLimit,
@@ -1721,7 +2160,7 @@ function makeEvmNetwork(resolved) {
           functionName: "balanceOf",
           args: [owner]
         });
-      } catch (e21) {
+      } catch (e24) {
         token = null;
       }
       return { token, native };
@@ -1741,6 +2180,12 @@ function makeEvmNetwork(resolved) {
         signMessage: (message) => a.walletClient.signMessage({ account: a.account, message })
       };
     },
+    // Tier-2 service-delivery attestation (EVM-only) — sign the official offer-receipt
+    // EIP-712 RECEIPT_TYPES with the bound (payTo) wallet. Chain-independent (domain
+    // chainId is hardcoded 1); viem lives in ./receipt.ts (a lazy chunk).
+    signReceipt(wallet, input) {
+      return _chunkCQQI5IJXcjs.signReceiptEvm.call(void 0, wallet, input);
+    },
     async verify(ref, accept) {
       return verifyEvm({
         publicClient,
@@ -1824,6 +2269,43 @@ function makeEvmNetwork(resolved) {
         payload,
         accept
       });
+    },
+    // Standard x402 `upto` (metered) rail — EVM-Permit2 ONLY. The metered sibling of the
+    // exact trio. resolveUptoRail advertises (Permit2-only, proxy-gated, relayer = facilitator);
+    // payUpto signs the MAX with witness.facilitator bound; settleUptoSelf self-settles the actual.
+    async resolveUptoRail({ asset, relayer }) {
+      const relayerAddress = relayer._native.account.address;
+      const domain = asset === "native" ? null : await readExactDomain(publicClient, asset).catch(() => null);
+      return resolveUptoRailEvm({
+        asset,
+        relayerAddress,
+        proxySupported: () => isUptoProxyChain(resolved.chainId),
+        domain
+      });
+    },
+    async payUpto(wallet, accept) {
+      const a = wallet._native;
+      const { payload, payerFrom, nonce } = await payUptoEvm({
+        publicClient,
+        walletClient: a.walletClient,
+        account: a.account,
+        chainId: resolved.chainId,
+        chain: resolved.chain,
+        accept
+      });
+      return { payload, accepted: accept, payerFrom, nonce };
+    },
+    async settleUptoSelf({ relayer, payload, accept, settleAmount }) {
+      const a = relayer._native;
+      return verifyAndSettleUptoEvm({
+        publicClient,
+        walletClient: a.walletClient,
+        account: a.account,
+        chain: resolved.chain,
+        payload,
+        accept,
+        settleAmount
+      });
     }
   };
 }
@@ -1840,9 +2322,9 @@ var loaders = {
   solana: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./solana-L342QCSV.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./solana-MYF4HBO4.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `Solana selected, but its packages aren't installed. Run: npm install @solana/web3.js @solana/spl-token bs58`,
         { cause }
       );
@@ -1852,9 +2334,9 @@ var loaders = {
   ton: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./ton-LZKJWYHV.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./ton-AOR3EURW.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `TON selected, but its packages aren't installed. Run: npm install @ton/ton @ton/core @ton/crypto`,
         { cause }
       );
@@ -1864,9 +2346,9 @@ var loaders = {
   stellar: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./stellar-YEXRVR3W.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./stellar-CRWBSX4E.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `Stellar selected, but its package isn't installed. Run: npm install @stellar/stellar-sdk`,
         { cause }
       );
@@ -1876,9 +2358,9 @@ var loaders = {
   xrpl: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./xrpl-K3U3SBF4.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./xrpl-Y6SQNYLC.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `XRPL selected, but its package isn't installed. Run: npm install xrpl`,
         { cause }
       );
@@ -1888,9 +2370,9 @@ var loaders = {
   tron: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./tron-DQU4WTGQ.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./tron-OMXB6EW2.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `Tron selected, but its package isn't installed. Run: npm install tronweb`,
         { cause }
       );
@@ -1900,9 +2382,9 @@ var loaders = {
   sui: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./sui-EFRSCDWN.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./sui-Y4RLKKE2.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `Sui selected, but its package isn't installed. Run: npm install @mysten/sui`,
         { cause }
       );
@@ -1912,9 +2394,9 @@ var loaders = {
   near: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./near-NYFMX2KA.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./near-6KAQVVG2.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `NEAR selected, but its package isn't installed. Run: npm install near-api-js`,
         { cause }
       );
@@ -1924,9 +2406,9 @@ var loaders = {
   aptos: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./aptos-CVHLVMAF.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./aptos-GHJPO6JJ.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `Aptos selected, but its package isn't installed. Run: npm install @aptos-labs/ts-sdk`,
         { cause }
       );
@@ -1936,9 +2418,9 @@ var loaders = {
   algorand: async () => {
     let mod;
     try {
-      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./algorand-EKD34T4Q.cjs")));
+      mod = await Promise.resolve().then(() => _interopRequireWildcard(require("./algorand-FCEECDG6.cjs")));
     } catch (cause) {
-      throw new (0, _chunkVPENSVOIcjs.MissingDriverError)(
+      throw new (0, _chunkMWBT7MCEcjs.MissingDriverError)(
         `Algorand selected, but its package isn't installed. Run: npm install algosdk`,
         { cause }
       );
@@ -2105,7 +2587,7 @@ function fieldTokens(r) {
   try {
     const u = new URL(r.resource);
     pathText = `${u.hostname} ${u.pathname}`;
-  } catch (e22) {
+  } catch (e25) {
   }
   return [
     [tokenize(r.name), FIELD_WEIGHTS.name],
@@ -2160,7 +2642,7 @@ function sortResources(items, sort, order) {
 async function safeSearch(run) {
   try {
     return await run();
-  } catch (e23) {
+  } catch (e26) {
     return [];
   }
 }
@@ -2299,7 +2781,7 @@ async function register402Index(input) {
     if (res.ok) {
       const body = await res.json().catch(() => ({}));
       const msg = typeof body.message === "string" && body.message.length > 0 ? body.message : void 0;
-      const live = _optionalChain([body, 'access', _12 => _12.service, 'optionalAccess', _13 => _13.status]) === "active";
+      const live = _optionalChain([body, 'access', _19 => _19.service, 'optionalAccess', _20 => _20.status]) === "active";
       return {
         source: "402index",
         ok: true,
@@ -2326,7 +2808,7 @@ async function readIndexError(res) {
       (p) => typeof p === "string" && p.length > 0
     );
     return parts.length ? [...new Set(parts)].join(" \u2014 ") : void 0;
-  } catch (e24) {
+  } catch (e27) {
     return void 0;
   }
 }
@@ -2436,11 +2918,11 @@ async function readSiwxInfo(res) {
   try {
     const body = await res.json();
     const ext = body.extensions;
-    const siwx = _optionalChain([ext, 'optionalAccess', _14 => _14["sign-in-with-x"]]);
-    const info = _nullishCoalesce(_optionalChain([siwx, 'optionalAccess', _15 => _15.info]), () => ( siwx));
-    if (info && info.chainId == null && Array.isArray(_optionalChain([siwx, 'optionalAccess', _16 => _16.supportedChains]))) {
+    const siwx = _optionalChain([ext, 'optionalAccess', _21 => _21["sign-in-with-x"]]);
+    const info = _nullishCoalesce(_optionalChain([siwx, 'optionalAccess', _22 => _22.info]), () => ( siwx));
+    if (info && info.chainId == null && Array.isArray(_optionalChain([siwx, 'optionalAccess', _23 => _23.supportedChains]))) {
       const evm = siwx.supportedChains.find(
-        (c) => typeof _optionalChain([c, 'optionalAccess', _17 => _17.chainId]) === "string" && c.chainId.startsWith("eip155:")
+        (c) => typeof _optionalChain([c, 'optionalAccess', _24 => _24.chainId]) === "string" && c.chainId.startsWith("eip155:")
       );
       if (evm && typeof evm.chainId === "string") info.chainId = evm.chainId;
     }
@@ -2448,7 +2930,7 @@ async function readSiwxInfo(res) {
       return info;
     }
     return null;
-  } catch (e25) {
+  } catch (e28) {
     return null;
   }
 }
@@ -2545,7 +3027,7 @@ function hostOf(url) {
   try {
     const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(url) ? url : `https://${url}`;
     return new URL(withScheme).hostname || url;
-  } catch (e26) {
+  } catch (e29) {
     return url;
   }
 }
@@ -2582,6 +3064,53 @@ function encodeBase642(str) {
 }
 
 // src/policy.ts
+var DENOM_PRECISION = _chunkMWBT7MCEcjs.MAX_DECIMALS;
+var BUILTIN_DENOMS = {
+  USDC: "USD",
+  USDT: "USD",
+  USD1: "USD",
+  FDUSD: "USD",
+  RLUSD: "USD",
+  EURC: "EUR"
+};
+function denomOf(symbol, asset, policy) {
+  if (asset === "native") return void 0;
+  const norm = (v) => typeof v === "string" && v.trim() !== "" ? v.trim().toUpperCase() : void 0;
+  const override = _optionalChain([policy, 'optionalAccess', _25 => _25.denomFor]);
+  if (override && typeof override === "object") {
+    if (asset && asset in override) {
+      const d = norm(override[asset]);
+      if (d) return d;
+    }
+    if (symbol) {
+      const hit = Object.entries(override).find(([k]) => k.trim().toUpperCase() === symbol.trim().toUpperCase());
+      if (hit) {
+        const d = norm(hit[1]);
+        if (d) return d;
+      }
+    }
+  }
+  if (symbol) {
+    const builtin = BUILTIN_DENOMS[symbol.trim().toUpperCase()];
+    if (builtin) return builtin;
+  }
+  return void 0;
+}
+function scaleToDenom(amountBase, decimals) {
+  if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > DENOM_PRECISION) return null;
+  return amountBase * 10n ** BigInt(DENOM_PRECISION - decimals);
+}
+function capForDenom(caps, denom) {
+  if (!caps || typeof caps !== "object") return void 0;
+  const target = denom.trim().toUpperCase();
+  let best;
+  for (const [k, v] of Object.entries(caps)) {
+    if (typeof k !== "string" || typeof v !== "string") continue;
+    if (k.trim().toUpperCase() !== target) continue;
+    if (best === void 0 || Number(v) < Number(best)) best = v;
+  }
+  return best;
+}
 var ALLOW = { allowed: true };
 var deny = (code, reason) => ({
   allowed: false,
@@ -2648,7 +3177,7 @@ function evaluatePolicy(intent, policy, spentForAssetBase, ctx) {
     }
   }
   if (policy.maxAmount !== void 0) {
-    const cap = _chunkVPENSVOIcjs.floorUnits.call(void 0, policy.maxAmount, intent.decimals);
+    const cap = _chunkMWBT7MCEcjs.floorUnits.call(void 0, policy.maxAmount, intent.decimals);
     if (intent.amountBase > cap) {
       return deny(
         "MAX_AMOUNT",
@@ -2657,7 +3186,7 @@ function evaluatePolicy(intent, policy, spentForAssetBase, ctx) {
     }
   }
   if (policy.maxTotal !== void 0) {
-    const cap = _chunkVPENSVOIcjs.floorUnits.call(void 0, policy.maxTotal, intent.decimals);
+    const cap = _chunkMWBT7MCEcjs.floorUnits.call(void 0, policy.maxTotal, intent.decimals);
     if (spentForAssetBase + intent.amountBase > cap) {
       return deny(
         "MAX_TOTAL",
@@ -2665,8 +3194,36 @@ function evaluatePolicy(intent, policy, spentForAssetBase, ctx) {
       );
     }
   }
+  if (ctx && policy.maxTotalPerDenom) {
+    const denom = denomOf(intent.symbol, intent.asset, policy);
+    const capStr = denom ? capForDenom(policy.maxTotalPerDenom, denom) : void 0;
+    if (denom && capStr !== void 0) {
+      const thisScaled = scaleToDenom(intent.amountBase, intent.decimals);
+      if (thisScaled === null) {
+        return deny(
+          "MAX_TOTAL_DENOM",
+          `token for ${denom} has more than ${DENOM_PRECISION} decimals \u2014 refusing to count it toward policy.maxTotalPerDenom.${denom} on trust (it can't be summed safely).`
+        );
+      }
+      const capScaled = _chunkMWBT7MCEcjs.floorUnits.call(void 0, capStr, DENOM_PRECISION);
+      if ((_nullishCoalesce(ctx.spentInDenomScaled, () => ( 0n))) + thisScaled > capScaled) {
+        return deny(
+          "MAX_TOTAL_DENOM",
+          `this payment would push total ${denom} spend past policy.maxTotalPerDenom.${denom} (${capStr}) \u2014 summed across every ${denom} token and chain.`
+        );
+      }
+    }
+  }
+  if (ctx && policy.maxPayments !== void 0) {
+    if ((_nullishCoalesce(ctx.paymentCount, () => ( 0))) + 1 > policy.maxPayments) {
+      return deny(
+        "MAX_PAYMENTS",
+        `this payment would exceed policy.maxPayments (${policy.maxPayments}); already settled ${_nullishCoalesce(ctx.paymentCount, () => ( 0))}.`
+      );
+    }
+  }
   if (ctx && policy.windowTotal !== void 0 && policy.windowSeconds !== void 0) {
-    const cap = _chunkVPENSVOIcjs.floorUnits.call(void 0, policy.windowTotal, intent.decimals);
+    const cap = _chunkMWBT7MCEcjs.floorUnits.call(void 0, policy.windowTotal, intent.decimals);
     if (ctx.spentInWindowBase + intent.amountBase > cap) {
       return deny(
         "WINDOW_TOTAL",
@@ -2674,44 +3231,150 @@ function evaluatePolicy(intent, policy, spentForAssetBase, ctx) {
       );
     }
   }
+  if (ctx && policy.maxPaymentsPerWindow !== void 0 && policy.windowSeconds !== void 0) {
+    if ((_nullishCoalesce(ctx.paymentCountInWindow, () => ( 0))) + 1 > policy.maxPaymentsPerWindow) {
+      return deny(
+        "WINDOW_COUNT",
+        `this payment would exceed policy.maxPaymentsPerWindow (${policy.maxPaymentsPerWindow}) within the last ${policy.windowSeconds}s.`
+      );
+    }
+  }
   return ALLOW;
 }
 
 // src/ledger.ts
 var keyFor = (network, asset) => `${network}|${asset}`;
-var SpendLedger = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
+var SpendLedger = (_class = class {
   __init() {this.records = []}
   __init2() {this.buckets = /* @__PURE__ */ new Map()}
+  /** Per-denomination running total, scaled to {@link DENOM_PRECISION}. Keyed by the
+   *  UPPERCASE denomination so lookups are case-insensitive. */
+  __init3() {this.denomTotals = /* @__PURE__ */ new Map()}
+  /** Threshold keys already warned (`warnAtFraction` fires once per crossing per cap).
+   *  Lives on the LEDGER — not the client — so clients SHARING one (a cross-chain
+   *  MultiChainPayer) dedupe together: a denomination/count threshold fires once across the
+   *  whole shared budget, not once per chain. */
+  __init4() {this.warned = /* @__PURE__ */ new Set()}
+  
   /**
    * Session clock origin (epoch-ms) — process/session start = ledger
    * construction. In-memory; a new process is a new session. The client reads it
    * to compute the `ttlSeconds` deadline and the rolling-window slice.
    */
-  __init3() {this.sessionStart = Date.now()}
-  /** Record a settled payment. `decimals` is the TRUE token decimals (for the
-   *  per-asset running total used by maxTotal + the formatted summary). */
-  record(r, decimals) {
-    this.records.push(r);
-    const key = keyFor(r.network, r.asset);
+  __init5() {this.sessionStart = Date.now()}
+  /**
+   * @param store Optional durable {@link SpendStore}. When supplied, the ledger
+   *   HYDRATES from `store.load()` here (so prior spend resumes after a restart) and
+   *   `append()`s every settled payment. A throwing/absent store fails SAFE to an
+   *   empty in-memory ledger — it never blocks construction (ERRORS.md: never throw).
+   */
+  constructor(store) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);
+    this.store = store;
+    if (store) {
+      let seed = [];
+      try {
+        seed = _nullishCoalesce(store.load(), () => ( []));
+      } catch (e30) {
+        seed = [];
+      }
+      for (const r of seed) this.ingest(r, _nullishCoalesce(_optionalChain([r, 'optionalAccess', _26 => _26.decimals]), () => ( 0)), _optionalChain([r, 'optionalAccess', _27 => _27.denom]));
+    }
+  }
+  /**
+   * A record is safe to tally iff its `amountBase` is a non-negative integer STRING and its
+   * `decimals` is an integer in `[0, MAX_DECIMALS]`. The live `record()` path always passes
+   * (the client validated the quote), but a hydrated record comes from an UNTRUSTED store
+   * (a tampered/corrupt/future-version JSONL line), so we gate it here — a bad record is
+   * dropped rather than allowed to throw `BigInt(...)`/`formatUnits(...)` later and brick a
+   * read or the constructor.
+   */
+  isTallyable(r, decimals) {
+    return !!r && typeof r.amountBase === "string" && /^\d+$/.test(r.amountBase) && Number.isInteger(decimals) && decimals >= 0 && decimals <= _chunkMWBT7MCEcjs.MAX_DECIMALS;
+  }
+  /** Apply a record to the in-memory tallies (records + per-asset bucket + denom total).
+   *  Shared by {@link record} and constructor hydration; does NOT persist. Returns the
+   *  stored record, or `null` when the record is corrupt and was skipped. */
+  ingest(r, decimals, denom) {
+    if (!this.isTallyable(r, decimals)) return null;
+    const denomStr = typeof denom === "string" && denom.trim() !== "" ? denom : void 0;
+    const rec = { ...r, decimals, ...denomStr ? { denom: denomStr } : {} };
+    this.records.push(rec);
+    const key = keyFor(rec.network, rec.asset);
     const bucket = this.buckets.get(key);
     if (bucket) {
-      bucket.total += BigInt(r.amountBase);
+      bucket.total += BigInt(rec.amountBase);
       bucket.count += 1;
-      if (!bucket.symbol && r.symbol) bucket.symbol = r.symbol;
+      if (!bucket.symbol && rec.symbol) bucket.symbol = rec.symbol;
     } else {
       this.buckets.set(key, {
-        network: r.network,
-        asset: r.asset,
-        symbol: r.symbol,
+        network: rec.network,
+        asset: rec.asset,
+        symbol: rec.symbol,
         decimals,
-        total: BigInt(r.amountBase),
+        total: BigInt(rec.amountBase),
         count: 1
       });
     }
+    if (denomStr) {
+      const scaled = scaleToDenom(BigInt(rec.amountBase), decimals);
+      if (scaled !== null) {
+        const k = denomStr.toUpperCase();
+        this.denomTotals.set(k, (_nullishCoalesce(this.denomTotals.get(k), () => ( 0n))) + scaled);
+      }
+    }
+    return rec;
+  }
+  /** Record a settled payment. `decimals` is the TRUE token decimals (for the
+   *  per-asset running total + the formatted summary). `denom` is the unit-of-account
+   *  the payment counts toward in the grand total (or omit for none). Persists to the
+   *  {@link SpendStore} when one is configured (a failed append never throws). */
+  record(r, decimals, denom) {
+    const rec = this.ingest(r, decimals, denom);
+    if (rec && this.store) {
+      try {
+        this.store.append(rec);
+      } catch (e31) {
+      }
+    }
   }
   /** Running total (base units) already spent on this (network, asset). */
   totalFor(network, asset) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _18 => _18.buckets, 'access', _19 => _19.get, 'call', _20 => _20(keyFor(network, asset)), 'optionalAccess', _21 => _21.total]), () => ( 0n));
+    return _nullishCoalesce(_optionalChain([this, 'access', _28 => _28.buckets, 'access', _29 => _29.get, 'call', _30 => _30(keyFor(network, asset)), 'optionalAccess', _31 => _31.total]), () => ( 0n));
+  }
+  /**
+   * Running grand total for a DENOMINATION, scaled to {@link DENOM_PRECISION} (so
+   * tokens of different decimals add up exactly). Summed across every token of that
+   * denomination and every chain this ledger has seen. Powers `maxTotalPerDenom`.
+   * `0n` for a denomination never spent on. Case-insensitive.
+   */
+  totalForDenom(denom) {
+    return _nullishCoalesce(this.denomTotals.get(denom.toUpperCase()), () => ( 0n));
+  }
+  /** Total number of settled payments (across every chain + token). Powers `maxPayments`. */
+  count() {
+    return this.records.length;
+  }
+  /** Mark a `warnAtFraction` threshold key as fired; returns `true` the FIRST time (so the
+   *  caller emits the `budget-threshold` event once) and `false` thereafter. Shared across
+   *  every client on this ledger, so a cross-chain threshold fires once for the whole budget. */
+  markWarned(key) {
+    if (this.warned.has(key)) return false;
+    this.warned.add(key);
+    return true;
+  }
+  /**
+   * Number of settled payments whose `at` (ISO) is at or after `sinceMs` (epoch-ms),
+   * across every chain + token. Backs the rolling payment-count cap
+   * (`maxPaymentsPerWindow`, `sinceMs = now - windowSeconds*1000`). Linear scan —
+   * negligible at agent-session cardinality and only when a window count cap is set.
+   */
+  countSince(sinceMs) {
+    let n = 0;
+    for (const r of this.records) {
+      const t = Date.parse(r.at);
+      if (Number.isNaN(t) || t >= sinceMs) n += 1;
+    }
+    return n;
   }
   /**
    * Sum of base-unit amounts for (network, asset) whose record `at` (ISO
@@ -2723,9 +3386,9 @@ var SpendLedger = (_class = class {constructor() { _class.prototype.__init.call(
   totalSince(network, asset, sinceMs) {
     let sum = 0n;
     for (const r of this.records) {
-      if (r.network === network && r.asset === asset && Date.parse(r.at) >= sinceMs) {
-        sum += BigInt(r.amountBase);
-      }
+      if (r.network !== network || r.asset !== asset) continue;
+      const t = Date.parse(r.at);
+      if (Number.isNaN(t) || t >= sinceMs) sum += BigInt(r.amountBase);
     }
     return sum;
   }
@@ -2745,6 +3408,14 @@ var SpendLedger = (_class = class {constructor() { _class.prototype.__init.call(
       totalBase: b.total
     }));
   }
+  /**
+   * The per-denomination grand totals, as read-only tuples — `denom` and the running
+   * `totalScaled` (at {@link DENOM_PRECISION}). Lets the client compose the grand-total
+   * budget view; the cap math lives in the client. A never-spent denomination is absent.
+   */
+  denomBuckets() {
+    return [...this.denomTotals.entries()].map(([denom, totalScaled]) => ({ denom, totalScaled }));
+  }
   /** An immutable snapshot of all spend so far. */
   summary() {
     return {
@@ -2755,9 +3426,15 @@ var SpendLedger = (_class = class {constructor() { _class.prototype.__init.call(
         symbol: b.symbol,
         decimals: b.decimals,
         totalBase: b.total.toString(),
-        totalFormatted: _chunkVPENSVOIcjs.formatUnits.call(void 0, b.total, b.decimals),
+        totalFormatted: _chunkMWBT7MCEcjs.formatUnits.call(void 0, b.total, b.decimals),
         count: b.count
       })),
+      byDenom: [...this.denomTotals.entries()].map(([denom, scaled]) => ({
+        denom,
+        totalScaled: scaled.toString(),
+        totalFormatted: _chunkMWBT7MCEcjs.formatUnits.call(void 0, scaled, DENOM_PRECISION),
+        count: this.records.filter((r) => _optionalChain([r, 'access', _32 => _32.denom, 'optionalAccess', _33 => _33.toUpperCase, 'call', _34 => _34()]) === denom).length
+      })),
       records: [...this.records]
     };
   }
@@ -2771,24 +3448,41 @@ var RECIPIENT_FIX = {
   NOT_OPTED_IN: "the recipient must opt into this asset once (a 0-amount self-transfer)",
   INACTIVE: "the recipient account doesn't exist yet \u2014 fund it with the chain's base reserve to activate it"
 };
+var RECEIPT_VERIFY_WINDOW_SECONDS = 100 * 365 * 24 * 60 * 60;
 var PipRailClient = (_class2 = class {
   
   
   
   
-  // Per-asset tally of everything this client has paid (powers spent() and the
-  // policy's maxTotal cap).
-  __init4() {this.ledger = new SpendLedger()}
+  // Per-asset (+ per-denomination + count) tally of everything this client has paid —
+  // powers spent()/budget() and the maxTotal/maxTotalPerDenom/maxPayments caps. Either
+  // its own (optionally store-backed) ledger, or a SHARED one injected so the grand
+  // total + count caps span several chains (MultiChainPayer.fromWallets).
+  
+  // `warnAtFraction` threshold dedup lives on the LEDGER (`ledger.markWarned`), so clients
+  // sharing one ledger (a cross-chain MultiChainPayer) fire each threshold once for the whole
+  // shared budget — not once per chain.
   // Resolved lazily on first request — this is what lets Solana (and future
   // families) auto-mount with no setup call.
   
-  constructor(opts) {;_class2.prototype.__init4.call(this);
+  // The verifiable receipt from the most recent settled fetch (null if the server emitted
+  // none). Captured pure (no chain read) and surfaced via lastReceipt(); the resource URL is
+  // stamped from the URL this client actually fetched (authoritative over the gate's default).
+  __init6() {this.lastReceiptValue = null}
+  constructor(opts) {;_class2.prototype.__init6.call(this);
     this.opts = opts;
     this.maxRetries = Math.max(1, _nullishCoalesce(opts.maxPaymentRetries, () => ( 3)));
     this.retryTimeoutMs = _nullishCoalesce(opts.retryTimeoutMs, () => ( 3e4));
     this.onEvent = _nullishCoalesce(opts.onEvent, () => ( (() => void 0)));
+    if (opts.ledger && opts.spendStore) {
+      throw new TypeError(
+        "Pass either `ledger` (a shared SpendLedger) or `spendStore`, not both \u2014 a shared ledger already owns its store."
+      );
+    }
+    this.ledger = _nullishCoalesce(opts.ledger, () => ( new SpendLedger(opts.spendStore)));
     this.assertPolicyAmountCaps(opts.policy);
     this.assertPolicyTimeOptions(opts.policy);
+    this.assertPolicySpendControls(opts.policy);
   }
   /**
    * Fail LOUDLY at construction on a malformed amount cap — a security boundary
@@ -2809,6 +3503,65 @@ var PipRailClient = (_class2 = class {
         );
       }
     }
+    if (policy.maxTotalPerDenom !== void 0) {
+      const m = policy.maxTotalPerDenom;
+      const proto = m && typeof m === "object" ? Object.getPrototypeOf(m) : false;
+      if (!m || typeof m !== "object" || Array.isArray(m) || proto !== Object.prototype && proto !== null) {
+        throw new TypeError(
+          `policy.maxTotalPerDenom must be a plain { DENOM: amount } object (e.g. { USD: '20.00' }); got ${JSON.stringify(policy.maxTotalPerDenom)}.`
+        );
+      }
+      for (const [denom, v] of Object.entries(policy.maxTotalPerDenom)) {
+        if (denom.trim() === "") {
+          throw new TypeError("policy.maxTotalPerDenom has a blank denomination key.");
+        }
+        if (typeof v !== "string" || !/^\d+(\.\d+)?$/.test(v)) {
+          throw new TypeError(
+            `policy.maxTotalPerDenom.${denom} must be a non-negative decimal string (e.g. '20.00'); got ${JSON.stringify(v)}.`
+          );
+        }
+      }
+    }
+    if (policy.denomFor !== void 0) {
+      const m = policy.denomFor;
+      if (!m || typeof m !== "object" || Array.isArray(m)) {
+        throw new TypeError(`policy.denomFor must be a { token: DENOM } object; got ${JSON.stringify(m)}.`);
+      }
+      for (const [k, v] of Object.entries(policy.denomFor)) {
+        if (typeof v !== "string" || v.trim() === "") {
+          throw new TypeError(`policy.denomFor.${k} must be a non-empty denomination string; got ${JSON.stringify(v)}.`);
+        }
+      }
+    }
+  }
+  /**
+   * Fail LOUDLY at construction on a misconfigured count / threshold control (a
+   * programmer error → `TypeError`): payment counts must be positive safe integers,
+   * `maxPaymentsPerWindow` needs `windowSeconds` (it shares the window), and
+   * `warnAtFraction` must be in (0, 1].
+   */
+  assertPolicySpendControls(policy) {
+    if (!policy) return;
+    for (const field of ["maxPayments", "maxPaymentsPerWindow"]) {
+      const v = policy[field];
+      if (v === void 0) continue;
+      if (!Number.isSafeInteger(v) || v <= 0) {
+        throw new TypeError(`policy.${field} must be a positive integer; got ${JSON.stringify(v)}.`);
+      }
+    }
+    if (policy.maxPaymentsPerWindow !== void 0 && policy.windowSeconds === void 0) {
+      throw new TypeError(
+        "policy.maxPaymentsPerWindow needs policy.windowSeconds (the rolling window it counts within) \u2014 set both, or neither."
+      );
+    }
+    if (policy.warnAtFraction !== void 0) {
+      const f = policy.warnAtFraction;
+      if (typeof f !== "number" || !(f > 0 && f <= 1)) {
+        throw new TypeError(
+          `policy.warnAtFraction must be a number in (0, 1] (e.g. 0.8); got ${JSON.stringify(f)}.`
+        );
+      }
+    }
   }
   /**
    * Fail LOUDLY at construction on a misconfigured time policy — a security
@@ -2823,11 +3576,17 @@ var PipRailClient = (_class2 = class {
     if (!policy) return;
     const hasWindowTotal = policy.windowTotal !== void 0;
     const hasWindowSeconds = policy.windowSeconds !== void 0;
-    if (hasWindowTotal !== hasWindowSeconds) {
+    const hasWindowCount = policy.maxPaymentsPerWindow !== void 0;
+    if (hasWindowTotal && !hasWindowSeconds) {
       throw new TypeError(
         "policy.windowTotal and policy.windowSeconds must be set together \u2014 a rolling-window cap can't be half-armed (set both, or neither)."
       );
     }
+    if (hasWindowSeconds && !hasWindowTotal && !hasWindowCount) {
+      throw new TypeError(
+        "policy.windowSeconds must be set together with policy.windowTotal and/or policy.maxPaymentsPerWindow \u2014 a window width alone bounds nothing."
+      );
+    }
     if (hasWindowSeconds && !(Number.isSafeInteger(policy.windowSeconds) && policy.windowSeconds > 0)) {
       throw new TypeError("policy.windowSeconds must be a positive integer number of seconds.");
     }
@@ -2839,13 +3598,144 @@ var PipRailClient = (_class2 = class {
         );
       }
     }
+    if (policy.expiresAt !== void 0) {
+      const at = policy.expiresAt;
+      if (!Number.isSafeInteger(at) || Math.abs(at) > 864e13) {
+        throw new TypeError(
+          `policy.expiresAt must be an absolute epoch-MILLISECONDS integer (like Date.now()); got ${JSON.stringify(at)}.`
+        );
+      }
+    }
   }
   /** Emit an observability event, never letting a throwing handler break the
    * payment flow (mirrors the server gate's `onPaid` isolation). */
   safeEmit(event) {
     try {
       this.onEvent(event);
-    } catch (e27) {
+    } catch (e32) {
+    }
+  }
+  /**
+   * Capture the verifiable receipt from a settled response (pure — no chain read), stamping
+   * the resource URL this client actually fetched (authoritative over the gate's default ''). A
+   * settled fetch with no receipt extension sets it to `null` so {@link lastReceipt} reflects the
+   * latest fetch. Never throws — a malformed header just yields `null`.
+   */
+  captureReceipt(response, url) {
+    try {
+      const parsed = parseReceiptExtension(response);
+      this.lastReceiptValue = parsed ? { ...parsed, resource: { url } } : null;
+    } catch (e33) {
+      this.lastReceiptValue = null;
+    }
+  }
+  /**
+   * The verifiable {@link PipRailReceipt} from the most recent settled `fetch` — the
+   * self-contained record the buyer KEEPS and anyone re-verifies against the chain
+   * (see {@link PipRailClient.verifyReceipt}). `null` when the last settled fetch carried
+   * no receipt (the gate's `receipts` option was off) or no payment has settled yet. Pure.
+   */
+  lastReceipt() {
+    return this.lastReceiptValue;
+  }
+  /**
+   * Re-verify ANY {@link PipRailReceipt} against the chain — the anyone-can-run primitive.
+   * Re-reads `receipt.transaction` via the receipt's own network driver and re-derives
+   * `payTo`/`asset`/`payer` from the tx, **never trusting the receipt's claims**: a forged
+   * `payTo`/`asset`/over-stated `amount` makes the driver's `verify()` fail (`ok:false`); a
+   * forged `payer` surfaces as `matchesClaims:false`. Static + WALLET-FREE — a third party
+   * verifies with only a chain + RPC, no PipRail account. **Never throws** (an RPC error or a
+   * malformed receipt → `{ ok:false, error }`). Viem-free here — the chain read happens inside
+   * the lazily-mounted family driver (the protocol layer pulls no chain libs). Durable for
+   * digest-bound families; recency-bounded for the account-watch families (see
+   * {@link ReceiptVerification}).
+   */
+  static async verifyReceipt(receipt, opts) {
+    const r = _optionalChain([receipt, 'optionalAccess', _35 => _35.receipt]);
+    if (!r || typeof r !== "object") {
+      return { ok: false, onChain: { payTo: "", asset: "", amount: "", payer: "" }, matchesClaims: false, ageSeconds: 0, error: "tx_not_found" };
+    }
+    const claimed = { payTo: _nullishCoalesce(r.payTo, () => ( "")), asset: _nullishCoalesce(r.asset, () => ( "")), amount: _nullishCoalesce(r.amount, () => ( "")), payer: _nullishCoalesce(r.payer, () => ( "")) };
+    const ageSeconds = receiptAgeSeconds(r.verifiedAt);
+    try {
+      const chain = chainSelectorForNetwork(r.network, _optionalChain([opts, 'optionalAccess', _36 => _36.rpcUrl]));
+      const net = await resolveNetwork2({
+        chain,
+        ..._optionalChain([opts, 'optionalAccess', _37 => _37.rpcUrl]) ? { rpcUrl: opts.rpcUrl } : {}
+      });
+      const accept = {
+        scheme: "onchain-proof",
+        network: r.network,
+        amount: r.amount,
+        asset: r.asset,
+        payTo: r.payTo,
+        maxTimeoutSeconds: RECEIPT_VERIFY_WINDOW_SECONDS,
+        extra: {
+          nonce: _nullishCoalesce(r.nonce, () => ( "")),
+          // the challenge/memo nonce — REQUIRED for Template-A re-verify
+          decimals: _nullishCoalesce(receipt.decimals, () => ( 6)),
+          // B10c — Stellar/XRPL/TON re-scale by it; 6 = USDC fallback
+          minConfirmations: 0,
+          amountFormatted: ""
+        }
+      };
+      const ref = familyForChain(chain) === "near" ? `${r.payer}:${r.transaction}` : r.transaction;
+      const result = await net.verify(ref, accept);
+      if (!result.ok) {
+        return { ok: false, onChain: claimed, matchesClaims: false, ageSeconds, error: result.error };
+      }
+      const oc = result.receipt;
+      const onChain = { payTo: oc.payTo, asset: oc.asset, amount: oc.amount, payer: oc.payer };
+      const matchesClaims = sameAddress(oc.payer, r.payer);
+      return { ok: true, onChain, matchesClaims, ageSeconds };
+    } catch (e34) {
+      return { ok: false, onChain: claimed, matchesClaims: false, ageSeconds, error: "tx_not_found" };
+    }
+  }
+  /**
+   * Verify the OPTIONAL Tier-2 service-delivery attestation on a {@link PipRailReceipt}
+   * — the merchant's signed proof that the resource was actually SERVED (the one thing
+   * the chain can't attest). For an EVM EIP-712 attestation this re-recovers the signer
+   * from the signature over the official `offer-receipt` typed data and checks
+   * `recover === receipt.payTo` (spec §4.5.1 / §5.5) — the classic EIP-712 footgun made
+   * safe (`recoverTypedDataAddress` returns a WRONG address rather than throwing on a bad
+   * signature, so the equality check is the real verification). A tampered signature →
+   * `{ ok:false }`, never a throw.
+   *
+   * Static + wallet-free. **Never throws** (a malformed/absent attestation, an unsupported
+   * format, or a recovery fault → `{ ok:false, reason }`). Viem-free HERE — the recover runs
+   * inside the lazily-imported EVM receipt driver (a lazy chunk), so the protocol layer pulls
+   * no chain libs. The JWS format defers to R3 (`{ ok:false, reason:'jws-not-loaded' }`).
+   */
+  static async verifyAttestation(receipt) {
+    const att = _optionalChain([receipt, 'optionalAccess', _38 => _38.attestation]);
+    if (!att || typeof att !== "object" || typeof att.signature !== "string") {
+      return { ok: false, reason: "no-attestation" };
+    }
+    if (att.format === "jws") {
+      return { ok: false, reason: "jws-not-loaded" };
+    }
+    const r = receipt.receipt;
+    if (!r || typeof r !== "object") return { ok: false, reason: "no-receipt" };
+    const payload = _nullishCoalesce(att.payload, () => ( {}));
+    const network = typeof payload.network === "string" ? payload.network : r.network;
+    const resourceUrl = typeof payload.resourceUrl === "string" ? payload.resourceUrl : _nullishCoalesce(_optionalChain([receipt, 'access', _39 => _39.resource, 'optionalAccess', _40 => _40.url]), () => ( ""));
+    const payer = typeof payload.payer === "string" ? payload.payer : r.payer;
+    const issuedAt = typeof payload.issuedAt === "number" ? payload.issuedAt : receiptIssuedAtSeconds(r.verifiedAt);
+    const transaction = typeof payload.transaction === "string" ? payload.transaction : _nullishCoalesce(r.transaction, () => ( ""));
+    try {
+      const { verifyReceiptAttestationEvm } = await Promise.resolve().then(() => _interopRequireWildcard(require("./receipt-QCDPMWNF.cjs")));
+      return await verifyReceiptAttestationEvm({
+        payTo: r.payTo,
+        network,
+        resourceUrl,
+        payer,
+        issuedAt,
+        transaction,
+        signature: att.signature
+      });
+    } catch (e35) {
+      return { ok: false, reason: "verify-failed" };
     }
   }
   /** Auto-mount the chain's driver, resolve the network, and bind the wallet — once. */
@@ -2875,7 +3765,7 @@ var PipRailClient = (_class2 = class {
    * as-is) or a plain object (serialised as JSON).
    */
   post(url, body, init) {
-    const headers = new Headers(_optionalChain([init, 'optionalAccess', _22 => _22.headers]));
+    const headers = new Headers(_optionalChain([init, 'optionalAccess', _41 => _41.headers]));
     let payload;
     if (body === void 0 || body === null) {
       payload = void 0;
@@ -2906,7 +3796,7 @@ var PipRailClient = (_class2 = class {
    * "0.05 USDC on Base, within budget → pay it." No funds move.
    */
   async quote(url, init) {
-    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _23 => _23.method]), () => ( "GET")) });
+    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _42 => _42.method]), () => ( "GET")) });
     if (res.status !== 402) return null;
     const { quote } = await this.resolveChallenge(url, res, this.resolveSchemes());
     return quote;
@@ -2925,22 +3815,37 @@ var PipRailClient = (_class2 = class {
    * on Tron, where a USD₮ transfer can cost real TRX.
    */
   async estimateCost(url, init) {
-    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _24 => _24.method]), () => ( "GET")) });
+    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _43 => _43.method]), () => ( "GET")) });
     if (res.status !== 402) return null;
-    const { net, accept, quote } = await this.resolveChallenge(url, res, this.resolveSchemes());
-    const cost = await net.estimateCost(accept);
-    return { quote, cost };
+    try {
+      const { net, accept, quote } = await this.resolveChallenge(url, res, this.resolveSchemes());
+      const cost = await net.estimateCost(accept);
+      return { quote, cost };
+    } catch (err) {
+      if (err instanceof _chunkMWBT7MCEcjs.InvalidEnvelopeError) return null;
+      throw err;
+    }
   }
   /** Aggregated snapshot of every payment this client has settled — total
-   *  count, cumulative spend per token, and the individual records. */
+   *  count, cumulative spend per token, cumulative spend per denomination (the
+   *  cross-token grand total), and the individual records. */
   spent() {
     return this.ledger.summary();
   }
+  /** The CONFIGURED spend policy, read back unchanged — so an agent can self-check
+   *  its WHOLE leash (caps, allowlists, time, denom + count limits) without hitting a
+   *  decline. `undefined` when no policy is set. Pure; never throws. */
+  policy() {
+    return this.opts.policy;
+  }
   /**
    * Read-only budget + time leash for a Mode-A (headless) agent — the policy IS
    * the consent, and this is how the agent SEES what's left of it before paying.
-   * Composes the in-memory ledger with the configured policy; never throws, moves
-   * no funds. PROCESS-SCOPED — every figure resets on restart (see {@link SessionBudget}).
+   * Composes the ledger with the configured policy: the per-asset money leash
+   * (`byAsset`), the cross-token GRAND TOTAL per denomination (`byDenom`, present
+   * from the start), and the payment-COUNT leash (`counts`). Never throws, moves no
+   * funds. The money/count figures persist if a `spendStore` is set; the time
+   * envelope is process-scoped (see {@link SessionBudget}).
    */
   budget() {
     const view = this.sessionView();
@@ -2948,12 +3853,57 @@ var PipRailClient = (_class2 = class {
     return {
       session: {
         start,
-        expiresAt: _optionalChain([view, 'optionalAccess', _25 => _25.expiresAt]) != null ? new Date(view.expiresAt).toISOString() : null,
-        secondsRemaining: _nullishCoalesce(_optionalChain([view, 'optionalAccess', _26 => _26.secondsRemaining]), () => ( null))
+        expiresAt: _optionalChain([view, 'optionalAccess', _44 => _44.expiresAt]) != null ? new Date(view.expiresAt).toISOString() : null,
+        secondsRemaining: _nullishCoalesce(_optionalChain([view, 'optionalAccess', _45 => _45.secondsRemaining]), () => ( null))
       },
-      byAsset: this.remaining()
+      byAsset: this.remaining(),
+      byDenom: this.denomRemaining(),
+      counts: this.countStatus()
     };
   }
+  /**
+   * The cross-token GRAND-TOTAL leash — one row per denomination capped by
+   * `policy.maxTotalPerDenom`. Unlike `remaining()`, rows exist from the START
+   * (the cap is a single declared number, so headroom is previewable before any
+   * spend). `[]` when no `maxTotalPerDenom` is set. Pure; never throws; never a
+   * price-converted figure (tokens grouped as one unit, each 1:1).
+   */
+  denomRemaining() {
+    const caps = _optionalChain([this, 'access', _46 => _46.opts, 'access', _47 => _47.policy, 'optionalAccess', _48 => _48.maxTotalPerDenom]);
+    if (!caps) return [];
+    return Object.entries(caps).map(([rawDenom, capStr]) => {
+      const denom = rawDenom.toUpperCase();
+      const spentScaled = this.ledger.totalForDenom(denom);
+      const capScaled = _chunkMWBT7MCEcjs.floorUnits.call(void 0, capStr, DENOM_PRECISION);
+      const remainingScaled = capScaled > spentScaled ? capScaled - spentScaled : 0n;
+      const fraction = capScaled === 0n ? spentScaled > 0n ? 1 : 0 : Number(spentScaled * 1000000n / capScaled) / 1e6;
+      return {
+        denom,
+        spentFormatted: _chunkMWBT7MCEcjs.formatUnits.call(void 0, spentScaled, DENOM_PRECISION),
+        capFormatted: _chunkMWBT7MCEcjs.formatUnits.call(void 0, capScaled, DENOM_PRECISION),
+        remainingFormatted: _chunkMWBT7MCEcjs.formatUnits.call(void 0, remainingScaled, DENOM_PRECISION),
+        fraction
+      };
+    });
+  }
+  /** The payment-COUNT leash — settled count so far + the configured lifetime/window
+   *  caps and what's left. Pure; never throws. */
+  countStatus() {
+    const policy = this.opts.policy;
+    const settled = this.ledger.count();
+    const out = { settled };
+    if (_optionalChain([policy, 'optionalAccess', _49 => _49.maxPayments]) !== void 0) {
+      out.lifetimeCap = policy.maxPayments;
+      out.lifetimeRemaining = Math.max(0, policy.maxPayments - settled);
+    }
+    if (_optionalChain([policy, 'optionalAccess', _50 => _50.maxPaymentsPerWindow]) !== void 0 && policy.windowSeconds !== void 0) {
+      const windowSettled = this.ledger.countSince(Date.now() - policy.windowSeconds * 1e3);
+      out.windowCap = policy.maxPaymentsPerWindow;
+      out.windowSettled = windowSettled;
+      out.windowRemaining = Math.max(0, policy.maxPaymentsPerWindow - windowSettled);
+    }
+    return out;
+  }
   /**
    * Per-(network, asset) remaining budget — ONE row per pair the ledger already
    * holds (decimals are known only after the first spend), so a fresh client with
@@ -2962,7 +3912,7 @@ var PipRailClient = (_class2 = class {
    * never throws, never sums across tokens (no price oracle). PROCESS-SCOPED.
    */
   remaining() {
-    const maxTotal = _optionalChain([this, 'access', _27 => _27.opts, 'access', _28 => _28.policy, 'optionalAccess', _29 => _29.maxTotal]);
+    const maxTotal = _optionalChain([this, 'access', _51 => _51.opts, 'access', _52 => _52.policy, 'optionalAccess', _53 => _53.maxTotal]);
     return this.ledger.assetBuckets().map((b) => {
       const base2 = {
         network: b.network,
@@ -2972,13 +3922,13 @@ var PipRailClient = (_class2 = class {
         spentBase: b.totalBase.toString()
       };
       if (maxTotal === void 0) return base2;
-      const capBase = _chunkVPENSVOIcjs.floorUnits.call(void 0, maxTotal, b.decimals);
+      const capBase = _chunkMWBT7MCEcjs.floorUnits.call(void 0, maxTotal, b.decimals);
       const remainingBase = capBase > b.totalBase ? capBase - b.totalBase : 0n;
       return {
         ...base2,
         capBase: capBase.toString(),
         remainingBase: remainingBase.toString(),
-        remainingFormatted: _chunkVPENSVOIcjs.formatUnits.call(void 0, remainingBase, b.decimals)
+        remainingFormatted: _chunkMWBT7MCEcjs.formatUnits.call(void 0, remainingBase, b.decimals)
       };
     });
   }
@@ -3014,15 +3964,15 @@ var PipRailClient = (_class2 = class {
    * the plan yourself. No funds move.
    */
   async planPayment(url, init) {
-    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _30 => _30.method]), () => ( "GET")) });
+    const res = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _54 => _54.method]), () => ( "GET")) });
     if (res.status !== 402) return null;
     const challenge = await parseChallenge(res);
     if (!challenge) {
-      throw new (0, _chunkVPENSVOIcjs.InvalidEnvelopeError)("402 response did not include a parseable x402 challenge.");
+      throw new (0, _chunkMWBT7MCEcjs.InvalidEnvelopeError)("402 response did not include a parseable x402 challenge.");
     }
     const { net, wallet } = await this.ensure();
     if (!wallet) {
-      throw new (0, _chunkVPENSVOIcjs.WalletRequiredError)(
+      throw new (0, _chunkMWBT7MCEcjs.WalletRequiredError)(
         "planPayment needs a wallet (it checks YOUR balance, gas, and recipient-readiness). This client is read-only \u2014 construct it with a `wallet` to plan or pay."
       );
     }
@@ -3195,40 +4145,48 @@ var PipRailClient = (_class2 = class {
    * streams throw `NonReplayableBodyError`.
    */
   async fetch(url, init) {
-    const body = _optionalChain([init, 'optionalAccess', _31 => _31.body]);
+    const body = _optionalChain([init, 'optionalAccess', _55 => _55.body]);
     if (body !== void 0 && body !== null && !isReplayableBodyInit(body)) {
-      throw new (0, _chunkVPENSVOIcjs.NonReplayableBodyError)(
+      throw new (0, _chunkMWBT7MCEcjs.NonReplayableBodyError)(
         "fetch(): init.body is not replayable. Pass a string, FormData, URLSearchParams, ArrayBuffer, or Blob \u2014 not a ReadableStream."
       );
     }
     const firstResponse = await fetch(url, init);
     if (firstResponse.status !== 402) return firstResponse;
-    const schemes = this.resolveSchemes(_optionalChain([init, 'optionalAccess', _32 => _32.schemes]));
+    const schemes = this.resolveSchemes(_optionalChain([init, 'optionalAccess', _56 => _56.schemes]));
     const resolved = await this.resolveChallenge(url, firstResponse, schemes);
     const { net, wallet, challenge } = resolved;
     if (!wallet) {
-      throw new (0, _chunkVPENSVOIcjs.WalletRequiredError)(
+      throw new (0, _chunkMWBT7MCEcjs.WalletRequiredError)(
         "Paying a 402 needs a wallet to sign + settle. This client is read-only \u2014 construct it with a `wallet` to pay (quote/discover/register still work without one)."
       );
     }
     let accept = resolved.accept;
     let quote = resolved.quote;
-    const autoRoute = _nullishCoalesce(_nullishCoalesce(_optionalChain([init, 'optionalAccess', _33 => _33.autoRoute]), () => ( this.opts.autoRoute)), () => ( false));
+    const autoRoute = _nullishCoalesce(_nullishCoalesce(_optionalChain([init, 'optionalAccess', _57 => _57.autoRoute]), () => ( this.opts.autoRoute)), () => ( false));
     if (autoRoute) {
       const plan = await this.planFromChallenge(net, wallet, challenge, url, schemes);
       if (!plan.best) {
         const reason = _nullishCoalesce(plan.fundingHint, () => ( "No rail is settleable for this payment."));
         this.safeEmit({ kind: "payment-failed", reason });
-        throw new (0, _chunkVPENSVOIcjs.PaymentDeclinedError)(reason);
+        throw new (0, _chunkMWBT7MCEcjs.PaymentDeclinedError)(reason);
       }
       accept = plan.best.accept;
       quote = plan.best.quote;
     }
     this.safeEmit({ kind: "payment-required", challenge, accept });
     await this.authorize(quote);
+    if (accept.scheme === "upto") {
+      return this.payUptoRail(net, wallet, accept, url, init, quote);
+    }
     if (accept.scheme === "exact") {
       return this.payExactRail(net, wallet, accept, url, init, quote);
     }
+    if (accept.scheme !== "onchain-proof") {
+      throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
+        `internal: unrouted accept scheme '${accept.scheme}' reached the onchain-proof pay path.`
+      );
+    }
     const { ref, confirmed } = await this.payAndConfirm(net, wallet, accept);
     const response = await this.retryWithProof(url, init, accept, ref, confirmed);
     this.recordSpend(quote, ref);
@@ -3243,7 +4201,7 @@ var PipRailClient = (_class2 = class {
   async resolveChallenge(url, response, schemes) {
     const challenge = await parseChallenge(response);
     if (!challenge) {
-      throw new (0, _chunkVPENSVOIcjs.InvalidEnvelopeError)(
+      throw new (0, _chunkMWBT7MCEcjs.InvalidEnvelopeError)(
         "402 response did not include a parseable x402 challenge."
       );
     }
@@ -3254,7 +4212,7 @@ var PipRailClient = (_class2 = class {
         (a) => a.scheme === "exact" && this.supportsNetwork(net, a.network)
       );
       if (schemes.includes("exact") && exactOnNet && typeof net.payExact !== "function") {
-        throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
+        throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
           `This 402 offers a standard 'exact' rail on ${net.network}, but the ${net.family} family can't pay 'exact' (supported on EVM, Solana, Algorand + NEAR today), and no 'onchain-proof' rail was offered.`
         );
       }
@@ -3263,13 +4221,13 @@ var PipRailClient = (_class2 = class {
           (a) => a.scheme === "exact" && this.supportsNetwork(net, a.network) && net.describeAsset(a.asset) != null
         );
         if (payable) {
-          throw new (0, _chunkVPENSVOIcjs.NoCompatibleAcceptError)(
+          throw new (0, _chunkMWBT7MCEcjs.NoCompatibleAcceptError)(
             `This 402 is payable only via the standard 'exact' rail on ${net.network}, which is OFF by default. Enable it: new PipRailClient({ \u2026, schemes: ['onchain-proof', 'exact'] }) or per call fetch(url, { schemes: ['exact'] }) (MCP: PIPRAIL_SCHEMES=onchain-proof,exact).`
           );
         }
       }
       const networks = [...new Set(challenge.accepts.map((a) => a.network))].join(", ");
-      throw new (0, _chunkVPENSVOIcjs.NoCompatibleAcceptError)(
+      throw new (0, _chunkMWBT7MCEcjs.NoCompatibleAcceptError)(
         `No accepts[] entry payable by this client on ${net.network} (schemes: ${schemes.join(", ")}; challenge offered: ${networks || "none"}).`
       );
     }
@@ -3315,6 +4273,13 @@ var PipRailClient = (_class2 = class {
         )
       );
     }
+    if (schemes.includes("upto")) {
+      out.push(
+        ...challenge.accepts.filter(
+          (a) => a.scheme === "upto" && this.supportsNetwork(net, a.network) && typeof net.payUpto === "function" && net.describeAsset(a.asset) != null && typeof _optionalChain([a, 'access', _58 => _58.extra, 'optionalAccess', _59 => _59.facilitatorAddress]) === "string" && a.extra.facilitatorAddress.length > 0 && Number.isInteger(a.maxTimeoutSeconds) && a.maxTimeoutSeconds > 0
+        )
+      );
+    }
     return out;
   }
   /** Build the full {@link PaymentPlan} from an already-parsed challenge + bound
@@ -3336,11 +4301,11 @@ var PipRailClient = (_class2 = class {
         ...session ? { session } : {}
       };
     }
-    const analysed = await Promise.all(
+    const analysed = (await Promise.all(
       candidates.map(
-        (accept) => this.analyzeRail(net, wallet, accept, url, challenge.resource.description)
+        (accept) => this.analyzeRail(net, wallet, accept, url, challenge.resource.description).catch(() => null)
       )
-    );
+    )).filter((o) => o !== null);
     const options = rankOptions(analysed);
     const best = _nullishCoalesce(options.find((o) => o.state === "payable"), () => ( null));
     const status = best ? "ready" : options.some((o) => o.state === "unknown") ? "unknown" : "blocked";
@@ -3364,14 +4329,14 @@ var PipRailClient = (_class2 = class {
     const rr = await net.recipientReady(accept.payTo, accept.asset).catch(() => ({ ready: "unknown" }));
     const amount = BigInt(accept.amount);
     const fee = safeBig(cost.fee);
-    const isExact = accept.scheme === "exact";
+    const isExact = accept.scheme === "exact" || accept.scheme === "upto";
     const isNative = accept.asset === "native";
     const blockers = [];
     const warnings = [];
     const shortfall = {};
     if (!quote.withinPolicy) {
       blockers.push(
-        quote.policyCode === "SESSION_EXPIRED" || quote.policyCode === "WINDOW_TOTAL" ? "OUTSIDE_WINDOW" : "OUTSIDE_POLICY"
+        quote.policyCode === "SESSION_EXPIRED" || quote.policyCode === "WINDOW_TOTAL" || quote.policyCode === "WINDOW_COUNT" ? "OUTSIDE_WINDOW" : "OUTSIDE_POLICY"
       );
     }
     if (quote.symbolMismatch) warnings.push("SYMBOL_MISMATCH");
@@ -3382,21 +4347,21 @@ var PipRailClient = (_class2 = class {
     if (isExact) {
       if (tokenKnown && bal.token < amount) {
         blockers.push("INSUFFICIENT_TOKEN");
-        shortfall.token = _chunkVPENSVOIcjs.formatUnits.call(void 0, amount - bal.token, quote.decimals);
+        shortfall.token = _chunkMWBT7MCEcjs.formatUnits.call(void 0, amount - bal.token, quote.decimals);
       }
     } else if (isNative) {
       if (nativeKnown && bal.native < amount + fee) {
         blockers.push("INSUFFICIENT_TOKEN");
-        shortfall.token = _chunkVPENSVOIcjs.formatUnits.call(void 0, amount + fee - bal.native, quote.decimals);
+        shortfall.token = _chunkMWBT7MCEcjs.formatUnits.call(void 0, amount + fee - bal.native, quote.decimals);
       }
     } else {
       if (tokenKnown && bal.token < amount) {
         blockers.push("INSUFFICIENT_TOKEN");
-        shortfall.token = _chunkVPENSVOIcjs.formatUnits.call(void 0, amount - bal.token, quote.decimals);
+        shortfall.token = _chunkMWBT7MCEcjs.formatUnits.call(void 0, amount - bal.token, quote.decimals);
       }
       if (nativeKnown && bal.native < fee) {
         blockers.push("INSUFFICIENT_GAS");
-        shortfall.native = _chunkVPENSVOIcjs.formatUnits.call(void 0, fee - bal.native, cost.feeDecimals);
+        shortfall.native = _chunkMWBT7MCEcjs.formatUnits.call(void 0, fee - bal.native, cost.feeDecimals);
       } else if (nativeKnown && fee > 0n && bal.native < fee * 3n / 2n) {
         warnings.push("THIN_GAS_MARGIN");
       }
@@ -3421,8 +4386,8 @@ var PipRailClient = (_class2 = class {
       blockers,
       warnings,
       balance: {
-        token: bal.token != null ? _chunkVPENSVOIcjs.formatUnits.call(void 0, bal.token, quote.decimals) : null,
-        native: bal.native != null ? _chunkVPENSVOIcjs.formatUnits.call(void 0, bal.native, cost.feeDecimals) : null
+        token: bal.token != null ? _chunkMWBT7MCEcjs.formatUnits.call(void 0, bal.token, quote.decimals) : null,
+        native: bal.native != null ? _chunkMWBT7MCEcjs.formatUnits.call(void 0, bal.native, cost.feeDecimals) : null
       },
       need: { token: quote.amountFormatted, native: cost.feeFormatted },
       ...shortfall.token || shortfall.native ? { shortfall } : {},
@@ -3433,25 +4398,30 @@ var PipRailClient = (_class2 = class {
    *  driver's describeAsset) + the policy verdict + a symbol-mismatch flag. */
   buildQuote(net, accept, url, description) {
     if (typeof accept.amount !== "string" || !/^\d+$/.test(accept.amount)) {
-      throw new (0, _chunkVPENSVOIcjs.InvalidEnvelopeError)(
+      throw new (0, _chunkMWBT7MCEcjs.InvalidEnvelopeError)(
         `challenge amount "${String(accept.amount)}" is not a base-unit integer string.`
       );
     }
     if (typeof accept.asset !== "string" || accept.asset.length === 0) {
-      throw new (0, _chunkVPENSVOIcjs.InvalidEnvelopeError)(
+      throw new (0, _chunkMWBT7MCEcjs.InvalidEnvelopeError)(
         `challenge on ${accept.network} states no (string) asset \u2014 refusing to price it.`
       );
     }
     const amountBase = BigInt(accept.amount);
     const described = net.describeAsset(accept.asset);
-    const decimals = _nullishCoalesce(_optionalChain([described, 'optionalAccess', _34 => _34.decimals]), () => ( _optionalChain([accept, 'access', _35 => _35.extra, 'optionalAccess', _36 => _36.decimals])));
+    const decimals = _nullishCoalesce(_optionalChain([described, 'optionalAccess', _60 => _60.decimals]), () => ( _optionalChain([accept, 'access', _61 => _61.extra, 'optionalAccess', _62 => _62.decimals])));
     if (typeof decimals !== "number" || !Number.isInteger(decimals) || decimals < 0) {
-      throw new (0, _chunkVPENSVOIcjs.InvalidEnvelopeError)(
+      throw new (0, _chunkMWBT7MCEcjs.InvalidEnvelopeError)(
         `challenge for ${accept.asset} on ${accept.network} states no valid decimals and the SDK doesn't recognise the token \u2014 refusing to price it.`
       );
     }
-    const symbol = _nullishCoalesce(_optionalChain([described, 'optionalAccess', _37 => _37.symbol]), () => ( _optionalChain([accept, 'access', _38 => _38.extra, 'optionalAccess', _39 => _39.symbol])));
-    const amountFormatted = _chunkVPENSVOIcjs.formatUnits.call(void 0, amountBase, decimals);
+    if (decimals > _chunkMWBT7MCEcjs.MAX_DECIMALS) {
+      throw new (0, _chunkMWBT7MCEcjs.InvalidEnvelopeError)(
+        `challenge for ${accept.asset} on ${accept.network} states ${decimals} decimals (> ${_chunkMWBT7MCEcjs.MAX_DECIMALS}) \u2014 refusing to price it (no real token is that deep).`
+      );
+    }
+    const symbol = _nullishCoalesce(_optionalChain([described, 'optionalAccess', _63 => _63.symbol]), () => ( _optionalChain([accept, 'access', _64 => _64.extra, 'optionalAccess', _65 => _65.symbol])));
+    const amountFormatted = _chunkMWBT7MCEcjs.formatUnits.call(void 0, amountBase, decimals);
     const intent = {
       host: hostOf2(url),
       chain: this.opts.chain,
@@ -3464,9 +4434,14 @@ var PipRailClient = (_class2 = class {
     };
     const policy = this.opts.policy;
     const hasWindow = !!policy && policy.windowTotal != null && policy.windowSeconds != null;
+    const hasWindowCount = !!policy && policy.maxPaymentsPerWindow != null && policy.windowSeconds != null;
+    const hasDenomCap = !!policy && policy.maxTotalPerDenom != null && Object.keys(policy.maxTotalPerDenom).length > 0;
+    const hasCountCap = !!policy && policy.maxPayments != null;
     const hasTimePolicy = !!policy && (policy.ttlSeconds != null || policy.expiresAt != null || hasWindow);
+    const needsCtx = hasTimePolicy || hasWindowCount || hasDenomCap || hasCountCap;
+    const denom = hasDenomCap ? denomOf(intent.symbol, intent.asset, policy) : void 0;
     const now = Date.now();
-    const ctx = hasTimePolicy ? {
+    const ctx = needsCtx ? {
       now,
       sessionStart: this.ledger.sessionStart,
       // Window slice ONLY when BOTH fields are set — never a `?? 0` width.
@@ -3474,7 +4449,12 @@ var PipRailClient = (_class2 = class {
         accept.network,
         accept.asset,
         now - policy.windowSeconds * 1e3
-      ) : 0n
+      ) : 0n,
+      // Running grand total on this intent's denomination, across the (shared) ledger.
+      spentInDenomScaled: denom ? this.ledger.totalForDenom(denom) : 0n,
+      // Settled-payment counts (lifetime + window) for the count caps.
+      paymentCount: hasCountCap ? this.ledger.count() : 0,
+      paymentCountInWindow: hasWindowCount ? this.ledger.countSince(now - policy.windowSeconds * 1e3) : 0
     } : void 0;
     const decision = evaluatePolicy(
       intent,
@@ -3482,7 +4462,7 @@ var PipRailClient = (_class2 = class {
       this.ledger.totalFor(accept.network, accept.asset),
       ctx
     );
-    const serverSymbol = _optionalChain([accept, 'access', _40 => _40.extra, 'optionalAccess', _41 => _41.symbol]);
+    const serverSymbol = _optionalChain([accept, 'access', _66 => _66.extra, 'optionalAccess', _67 => _67.symbol]);
     const symbolMismatch = intent.recognized && !!serverSymbol && !!symbol && serverSymbol.toUpperCase() !== symbol.toUpperCase();
     return {
       url,
@@ -3510,9 +4490,11 @@ var PipRailClient = (_class2 = class {
   async authorize(quote) {
     if (!quote.withinPolicy) {
       const reason = `Payment refused by policy: ${_nullishCoalesce(quote.policyReason, () => ( "not allowed"))}`;
-      const reasonCode = reasonCodeForPolicy(quote.policyCode);
-      this.safeEmit({ kind: "payment-failed", reason, code: reasonCode });
-      throw new (0, _chunkVPENSVOIcjs.PaymentDeclinedError)(reason, { reasonCode });
+      this.refuse(reason, {
+        reasonCode: reasonCodeForPolicy(quote.policyCode),
+        policyCode: quote.policyCode,
+        quote
+      });
     }
     const hook = this.opts.onBeforePay;
     if (!hook) return;
@@ -3520,43 +4502,161 @@ var PipRailClient = (_class2 = class {
     try {
       approved = await hook(quote);
     } catch (err) {
-      const reason = "onBeforePay threw \u2014 refusing to pay.";
-      this.safeEmit({ kind: "payment-failed", reason, code: "APPROVAL" });
-      throw new (0, _chunkVPENSVOIcjs.PaymentDeclinedError)(reason, { cause: err, reasonCode: "APPROVAL" });
+      this.refuse("onBeforePay threw \u2014 refusing to pay.", { reasonCode: "APPROVAL", quote, cause: err });
     }
     if (!approved) {
       const reason = `onBeforePay declined ${quote.amountFormatted} ${_nullishCoalesce(quote.symbol, () => ( ""))}`.trimEnd() + ` on ${quote.network}.`;
-      this.safeEmit({ kind: "payment-failed", reason, code: "APPROVAL" });
-      throw new (0, _chunkVPENSVOIcjs.PaymentDeclinedError)(reason, { reasonCode: "APPROVAL" });
+      this.refuse(reason, { reasonCode: "APPROVAL", quote });
     }
   }
-  /** Record a settled payment in the ledger (true decimals for the running total). */
-  recordSpend(quote, ref) {
-    this.ledger.record(
-      {
-        url: quote.url,
-        host: hostOf2(quote.url),
-        network: quote.network,
-        asset: quote.asset,
-        amountBase: quote.amount,
-        amountFormatted: quote.amountFormatted,
-        ...quote.symbol ? { symbol: quote.symbol } : {},
-        ref,
-        at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      quote.decimals
-    );
+  /**
+   * Refuse a payment BEFORE any send: emit BOTH the legacy `payment-failed` (so existing
+   * `onEvent` consumers are unaffected) AND the richer, dedicated `payment-declined`
+   * (typed reasonCode + fine PolicyDenyCode + the quote + a budget snapshot), then throw
+   * the typed {@link PaymentDeclinedError}. Returns `never` so callers' control flow is
+   * exhaustive.
+   */
+  refuse(reason, opts) {
+    this.safeEmit({ kind: "payment-failed", reason, ...opts.reasonCode ? { code: opts.reasonCode } : {} });
+    this.safeEmit({
+      kind: "payment-declined",
+      reason,
+      ...opts.reasonCode ? { reasonCode: opts.reasonCode } : {},
+      ...opts.policyCode ? { code: opts.policyCode } : {},
+      ...opts.quote ? { quote: opts.quote } : {},
+      budget: this.budget()
+    });
+    throw new (0, _chunkMWBT7MCEcjs.PaymentDeclinedError)(reason, {
+      ...opts.reasonCode ? { reasonCode: opts.reasonCode } : {},
+      ...opts.cause !== void 0 ? { cause: opts.cause } : {}
+    });
+  }
+  /** Record a settled payment in the ledger (TRUE decimals for the running total + the
+   *  denomination it counts toward in the grand total). Then fire the `onSpend` callback
+   *  with the record + the post-payment budget, and emit any `warnAtFraction` thresholds
+   *  this payment just crossed. All observability is isolated — a throwing hook never
+   *  affects the (already-settled) payment.
+   *
+   *  `settledAmountBase` is the SINGLE upto ledger-reconciliation seam: the quote (and thus
+   *  the policy/budget) gates on the MAX, and for the metered `upto` rail the budgeted amount
+   *  RECORDED is ALSO the authorized MAX — the only buyer-provable bound. The merchant's
+   *  claimed actual is UNTRUSTED (a malicious merchant can settle the MAX on-chain yet report
+   *  a tiny `SettleOutcome.amount`); recording it would let an under-report silently loosen a
+   *  cumulative cap (`maxTotal`/`maxTotalPerDenom`/`windowTotal`) past the buyer's real on-chain
+   *  spend (POL-1). So the cap-bearing `amountBase` is the MAX; the clamped actual is surfaced
+   *  separately on `settledBase`/`settledFormatted` for transparency (it equals the receipt's
+   *  amount). When absent (onchain-proof/exact) this is byte-identical to before. */
+  recordSpend(quote, ref, settledAmountBase) {
+    const denom = denomOf(quote.symbol, quote.asset, this.opts.policy);
+    const amountBase = quote.amount;
+    const amountFormatted = quote.amountFormatted;
+    let settledBase;
+    let settledFormatted;
+    if (settledAmountBase !== void 0 && /^\d+$/.test(settledAmountBase)) {
+      try {
+        const claimed = BigInt(settledAmountBase);
+        const max = BigInt(quote.amount);
+        const shown = claimed < max ? claimed : max;
+        settledBase = shown.toString();
+        settledFormatted = _chunkMWBT7MCEcjs.formatUnits.call(void 0, shown, quote.decimals);
+      } catch (e36) {
+      }
+    }
+    const record = {
+      url: quote.url,
+      host: hostOf2(quote.url),
+      network: quote.network,
+      asset: quote.asset,
+      amountBase,
+      amountFormatted,
+      ...settledBase !== void 0 ? { settledBase, settledFormatted } : {},
+      ...quote.symbol ? { symbol: quote.symbol } : {},
+      decimals: quote.decimals,
+      ...denom ? { denom } : {},
+      ref,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.ledger.record(record, quote.decimals, denom);
+    const budget = this.budget();
+    if (this.opts.onSpend) {
+      try {
+        this.opts.onSpend(record, budget);
+      } catch (e37) {
+      }
+    }
+    this.emitThresholds(budget);
+  }
+  /**
+   * Emit a `budget-threshold` event for each cap whose used-fraction just reached
+   * `policy.warnAtFraction` — the early warning before a hard decline. Fires ONCE per
+   * crossing per cap (deduped on the shared ledger via `markWarned`, so a cross-chain
+   * threshold fires once for the whole budget, not once per chain). No-op when no
+   * `warnAtFraction` is set. Reads the just-computed {@link SessionBudget}; isolated (safeEmit).
+   */
+  emitThresholds(budget) {
+    const frac = _optionalChain([this, 'access', _68 => _68.opts, 'access', _69 => _69.policy, 'optionalAccess', _70 => _70.warnAtFraction]);
+    if (frac === void 0) return;
+    const fire = (scope, label, spentFormatted, capFormatted, fraction) => {
+      if (fraction < frac) return;
+      if (!this.ledger.markWarned(`${scope}:${label}`)) return;
+      this.safeEmit({ kind: "budget-threshold", scope, label, spentFormatted, capFormatted, fraction });
+    };
+    for (const r of budget.byAsset) {
+      if (r.capBase === void 0) continue;
+      const cap = BigInt(r.capBase);
+      const spent = BigInt(r.spentBase);
+      const fraction = cap === 0n ? spent > 0n ? 1 : 0 : Number(spent * 1000000n / cap) / 1e6;
+      fire(
+        "asset",
+        `${_nullishCoalesce(r.symbol, () => ( r.asset))} on ${r.network}`,
+        _chunkMWBT7MCEcjs.formatUnits.call(void 0, spent, r.decimals),
+        _chunkMWBT7MCEcjs.formatUnits.call(void 0, cap, r.decimals),
+        fraction
+      );
+    }
+    for (const d of budget.byDenom) {
+      fire("denom", d.denom, d.spentFormatted, d.capFormatted, d.fraction);
+    }
+    const policy = this.opts.policy;
+    if (_optionalChain([policy, 'optionalAccess', _71 => _71.windowTotal]) !== void 0 && policy.windowSeconds !== void 0) {
+      const since = Date.now() - policy.windowSeconds * 1e3;
+      for (const r of budget.byAsset) {
+        const cap = _chunkMWBT7MCEcjs.floorUnits.call(void 0, policy.windowTotal, r.decimals);
+        const spent = this.ledger.totalSince(r.network, r.asset, since);
+        const fraction = cap === 0n ? spent > 0n ? 1 : 0 : Number(spent * 1000000n / cap) / 1e6;
+        fire(
+          "window",
+          `${_nullishCoalesce(r.symbol, () => ( r.asset))} on ${r.network}`,
+          _chunkMWBT7MCEcjs.formatUnits.call(void 0, spent, r.decimals),
+          _chunkMWBT7MCEcjs.formatUnits.call(void 0, cap, r.decimals),
+          fraction
+        );
+      }
+    }
+    const c = budget.counts;
+    if (c.lifetimeCap !== void 0 && c.lifetimeCap > 0) {
+      fire("count", "maxPayments", String(c.settled), String(c.lifetimeCap), c.settled / c.lifetimeCap);
+    }
+    if (c.windowCap !== void 0 && c.windowCap > 0 && c.windowSettled !== void 0) {
+      fire(
+        "window-count",
+        "maxPaymentsPerWindow",
+        String(c.windowSettled),
+        String(c.windowCap),
+        c.windowSettled / c.windowCap
+      );
+    }
   }
   async payAndConfirm(net, wallet, accept) {
     if (!this.supportsNetwork(net, accept.network)) {
-      throw new (0, _chunkVPENSVOIcjs.WrongChainError)(
+      throw new (0, _chunkMWBT7MCEcjs.WrongChainError)(
         `Challenge expects ${accept.network} but client is on ${net.network}.`
       );
     }
     const ref = await net.send(wallet, accept);
     this.safeEmit({ kind: "payment-broadcast", ref });
     try {
-      const { height } = await net.confirm(ref, _nullishCoalesce(_optionalChain([accept, 'access', _42 => _42.extra, 'optionalAccess', _43 => _43.minConfirmations]), () => ( 1)));
+      const { height } = await net.confirm(ref, _nullishCoalesce(_optionalChain([accept, 'access', _72 => _72.extra, 'optionalAccess', _73 => _73.minConfirmations]), () => ( 1)));
       this.safeEmit({
         kind: "payment-confirmed",
         ref,
@@ -3576,9 +4676,9 @@ var PipRailClient = (_class2 = class {
     const signature = {
       x402Version: 2,
       accepted: accept,
-      payload: { nonce: _optionalChain([accept, 'access', _44 => _44.extra, 'optionalAccess', _45 => _45.nonce]), txHash: ref }
+      payload: { nonce: _optionalChain([accept, 'access', _74 => _74.extra, 'optionalAccess', _75 => _75.nonce]), txHash: ref }
     };
-    const headers = new Headers(_optionalChain([originalInit, 'optionalAccess', _46 => _46.headers]));
+    const headers = new Headers(_optionalChain([originalInit, 'optionalAccess', _76 => _76.headers]));
     headers.set(HEADER_SIGNATURE, buildSignatureHeader(signature));
     let lastResponse = null;
     let lastReason = null;
@@ -3593,7 +4693,7 @@ var PipRailClient = (_class2 = class {
         () => timeoutController.abort(),
         this.retryTimeoutMs
       );
-      const signal = _optionalChain([originalInit, 'optionalAccess', _47 => _47.signal]) && typeof AbortSignal.any === "function" ? AbortSignal.any([timeoutController.signal, originalInit.signal]) : timeoutController.signal;
+      const signal = _optionalChain([originalInit, 'optionalAccess', _77 => _77.signal]) && typeof AbortSignal.any === "function" ? AbortSignal.any([timeoutController.signal, originalInit.signal]) : timeoutController.signal;
       try {
         lastResponse = await fetch(url, {
           ..._nullishCoalesce(originalInit, () => ( {})),
@@ -3602,7 +4702,7 @@ var PipRailClient = (_class2 = class {
         });
       } catch (err) {
         if (timeoutController.signal.aborted) {
-          throw new (0, _chunkVPENSVOIcjs.PaymentTimeoutError)(
+          throw new (0, _chunkMWBT7MCEcjs.PaymentTimeoutError)(
             `Server did not respond within ${this.retryTimeoutMs}ms after broadcasting payment ${ref}. Re-verify or re-submit ref=${ref} \u2014 do NOT re-pay.`,
             { cause: err, ref }
           );
@@ -3613,6 +4713,7 @@ var PipRailClient = (_class2 = class {
       }
       if (lastResponse.status !== 402) {
         const receipt = parseReceipt(lastResponse);
+        this.captureReceipt(lastResponse, url);
         this.safeEmit({ kind: "payment-settled", receipt });
         return lastResponse;
       }
@@ -3625,42 +4726,126 @@ var PipRailClient = (_class2 = class {
       reason: `server returned 402 after broadcasting payment ${ref}${unconfirmedNote} (${why})`,
       ...lastReason ? { code: lastReason.error, detail: lastReason.detail } : {}
     });
-    throw new (0, _chunkVPENSVOIcjs.MaxRetriesExceededError)(
+    throw new (0, _chunkMWBT7MCEcjs.MaxRetriesExceededError)(
       `Server still returned 402 after ${attempts} attempt(s) with on-chain proof ref=${ref}${unconfirmedNote}. Last server rejection: ${why}. Re-verify or re-submit ref=${ref} before retrying \u2014 never re-pay (it would double-spend).`,
       { ref }
     );
   }
   /**
-   * Pay a standard x402 `exact` rail — a SEPARATE, fundamentally more conservative
-   * path than {@link retryWithProof}. The buyer SIGNS an EIP-3009 authorization ONCE
-   * (the driver's `payExact`) and the server / merchant-chosen facilitator BROADCASTS
-   * it synchronously, so a blind re-POST of a still-in-flight authorization could
-   * double-BROADCAST it. Hence, unlike the onchain-proof loop:
-   *
-   *   • sign exactly once — reuse the SAME header on every retry, never re-sign;
-   *   • retry ONLY an explicit 402 (a definitive pre-broadcast rejection), bounded
-   *     well under `maxTimeoutSeconds` so the loop can't outlive the authorization;
-   *   • a post-POST transport error/timeout → {@link PaymentTimeoutError} carrying the
-   *     nonce (the facilitator MAY have settled — verify on-chain, NEVER re-pay);
-   *   • a 5xx → return as-is (server settle failure; the authorization stays valid +
-   *     its nonce unused) — no settled event, no spend;
-   *   • a 200 whose SettleResponse says `success:false` → a rejection, NEVER a spend;
-   *   • the spend is recorded EXACTLY ONCE, on an affirmative settlement only.
+   * Pay a standard x402 `exact` rail — a SEPARATE, fundamentally more conservative
+   * path than {@link retryWithProof}. The buyer SIGNS an EIP-3009 authorization ONCE
+   * (the driver's `payExact`) and the server / merchant-chosen facilitator BROADCASTS
+   * it synchronously, so a blind re-POST of a still-in-flight authorization could
+   * double-BROADCAST it. Hence, unlike the onchain-proof loop:
+   *
+   *   • sign exactly once — reuse the SAME header on every retry, never re-sign;
+   *   • retry ONLY an explicit 402 (a definitive pre-broadcast rejection), bounded
+   *     well under `maxTimeoutSeconds` so the loop can't outlive the authorization;
+   *   • a post-POST transport error/timeout → {@link PaymentTimeoutError} carrying the
+   *     nonce (the facilitator MAY have settled — verify on-chain, NEVER re-pay);
+   *   • a 5xx → return as-is (server settle failure; the authorization stays valid +
+   *     its nonce unused) — no settled event, no spend;
+   *   • a 200 whose SettleResponse says `success:false` → a rejection, NEVER a spend;
+   *   • the spend is recorded EXACTLY ONCE, on an affirmative settlement only.
+   */
+  async payExactRail(net, wallet, accept, url, init, quote) {
+    if (!net.payExact) {
+      throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
+        `the ${net.family} family can't pay a standard 'exact' rail (supported on EVM, Solana, Algorand + NEAR today).`
+      );
+    }
+    throwIfAborted(_optionalChain([init, 'optionalAccess', _78 => _78.signal]));
+    const { payload, accepted, payerFrom, nonce } = await net.payExact(wallet, accept);
+    const headers = new Headers(_optionalChain([init, 'optionalAccess', _79 => _79.headers]));
+    headers.set(HEADER_SIGNATURE, buildExactSignatureHeader({ accepted, payload }));
+    const rejectDefinitive = (why2) => {
+      this.safeEmit({ kind: "payment-failed", reason: `exact: facilitator rejected nonce=${nonce} (${why2})`, code: why2 });
+      throw new (0, _chunkMWBT7MCEcjs.MaxRetriesExceededError)(
+        `exact: the facilitator rejected the payment (${why2}). Fix the cause, then re-present the SAME signed authorization (nonce=${nonce}) \u2014 do NOT re-sign a fresh nonce. ref=${nonce}.`,
+        { ref: nonce }
+      );
+    };
+    const deadline = Date.now() + Math.max(1, Math.floor(accept.maxTimeoutSeconds / 2)) * 1e3;
+    const maxAttempts = Math.min(this.maxRetries, 3);
+    let lastReason = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      if (attempt > 0) {
+        if (Date.now() >= deadline) break;
+        await new Promise((r) => setTimeout(r, Math.min(2e3, 400 * 2 ** (attempt - 1))));
+      }
+      throwIfAborted(_optionalChain([init, 'optionalAccess', _80 => _80.signal]));
+      const budget = Math.min(this.retryTimeoutMs, deadline - Date.now());
+      if (budget <= 0) break;
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(() => timeoutController.abort(), budget);
+      const signal = _optionalChain([init, 'optionalAccess', _81 => _81.signal]) && typeof AbortSignal.any === "function" ? AbortSignal.any([timeoutController.signal, init.signal]) : timeoutController.signal;
+      let response;
+      try {
+        response = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), headers, signal });
+      } catch (err) {
+        throw new (0, _chunkMWBT7MCEcjs.PaymentTimeoutError)(
+          `exact: no response after submitting the authorization (nonce=${nonce}) to ${hostOf2(url)}. The facilitator may have already settled it \u2014 verify on-chain with authorizationState(${payerFrom}, ${nonce}) before re-presenting; do NOT re-pay.`,
+          { cause: err, ref: nonce }
+        );
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      const settle = parseSettleResponse(response);
+      if (response.status === 402) {
+        if (settle && settle.success === false) rejectDefinitive(_nullishCoalesce(settle.errorReason, () => ( "the facilitator reported success:false")));
+        lastReason = await _asyncNullishCoalesce(await readInvalidReason(response), async () => ( lastReason));
+        continue;
+      }
+      if (response.ok && !(settle && settle.success === false)) {
+        const receipt = parseReceipt(response);
+        this.captureReceipt(response, url);
+        this.safeEmit({ kind: "payment-settled", receipt, ...settle ? { settle } : {} });
+        const ref = _optionalChain([settle, 'optionalAccess', _82 => _82.transaction]) || _optionalChain([receipt, 'optionalAccess', _83 => _83.transaction]) || `eip3009-nonce:${nonce}`;
+        this.recordSpend(quote, ref);
+        return response;
+      }
+      if (response.status >= 500) {
+        this.safeEmit({ kind: "payment-failed", reason: `exact: server ${response.status} \u2014 authorization nonce=${nonce} not settled` });
+        return response;
+      }
+      if (settle && settle.success === false) rejectDefinitive(_nullishCoalesce(settle.errorReason, () => ( "the facilitator reported success:false")));
+      this.safeEmit({ kind: "payment-failed", reason: `exact: server ${response.status} \u2014 authorization nonce=${nonce} not settled` });
+      return response;
+    }
+    const why = lastReason ? `${lastReason.error}${lastReason.detail ? ` \u2014 ${lastReason.detail}` : ""}` : "server gave no reason";
+    this.safeEmit({
+      kind: "payment-failed",
+      reason: `exact: 402 after submitting authorization nonce=${nonce} (${why})`,
+      ...lastReason ? { code: lastReason.error, detail: lastReason.detail } : {}
+    });
+    throw new (0, _chunkMWBT7MCEcjs.MaxRetriesExceededError)(
+      `exact: server still returned 402 after submitting the signed authorization (nonce=${nonce}). Last rejection: ${why}. Re-present the SAME authorization \u2014 do NOT re-sign a fresh nonce; verify authorizationState(${payerFrom}, ${nonce}) first. ref=${nonce}.`,
+      { ref: nonce }
+    );
+  }
+  /**
+   * The standard `upto` (metered) buyer path — a near-clone of {@link payExactRail} with TWO
+   * deltas: (1) it signs a Permit2-upto authorization for the MAX via `payUpto` + frames it
+   * with `buildUptoSignatureHeader`; (2) it records the ACTUAL settled amount (read off the
+   * SettleResponse's required `amount` field, via `recordSpend(quote, ref, settle.amount)`) in
+   * the ledger — the budget gated on the MAX, the ledger records the ACTUAL. A server that omits
+   * `settle.amount` FAILS SAFE to the MAX (over-counts, never under-counts). The buyer SIGNS, the
+   * merchant self-settles — the buyer never broadcasts.
    */
-  async payExactRail(net, wallet, accept, url, init, quote) {
-    if (!net.payExact) {
-      throw new (0, _chunkVPENSVOIcjs.UnsupportedSchemeError)(
-        `the ${net.family} family can't pay a standard 'exact' rail (supported on EVM, Solana, Algorand + NEAR today).`
+  async payUptoRail(net, wallet, accept, url, init, quote) {
+    if (!net.payUpto) {
+      throw new (0, _chunkMWBT7MCEcjs.UnsupportedSchemeError)(
+        `the ${net.family} family can't pay a standard 'upto' rail (EVM-Permit2 only today).`
       );
     }
-    throwIfAborted(_optionalChain([init, 'optionalAccess', _48 => _48.signal]));
-    const { payload, accepted, payerFrom, nonce } = await net.payExact(wallet, accept);
-    const headers = new Headers(_optionalChain([init, 'optionalAccess', _49 => _49.headers]));
-    headers.set(HEADER_SIGNATURE, buildExactSignatureHeader({ accepted, payload }));
+    throwIfAborted(_optionalChain([init, 'optionalAccess', _84 => _84.signal]));
+    const { payload, accepted, payerFrom, nonce } = await net.payUpto(wallet, accept);
+    const headers = new Headers(_optionalChain([init, 'optionalAccess', _85 => _85.headers]));
+    headers.set(HEADER_SIGNATURE, buildUptoSignatureHeader({ accepted, payload }));
     const rejectDefinitive = (why2) => {
-      this.safeEmit({ kind: "payment-failed", reason: `exact: facilitator rejected nonce=${nonce} (${why2})`, code: why2 });
-      throw new (0, _chunkVPENSVOIcjs.MaxRetriesExceededError)(
-        `exact: the facilitator rejected the payment (${why2}). Fix the cause, then re-present the SAME signed authorization (nonce=${nonce}) \u2014 do NOT re-sign a fresh nonce. ref=${nonce}.`,
+      this.safeEmit({ kind: "payment-failed", reason: `upto: facilitator rejected nonce=${nonce} (${why2})`, code: why2 });
+      throw new (0, _chunkMWBT7MCEcjs.MaxRetriesExceededError)(
+        `upto: the server rejected the payment (${why2}). Fix the cause, then re-present the SAME signed authorization (nonce=${nonce}) \u2014 do NOT re-sign a fresh nonce. ref=${nonce}.`,
         { ref: nonce }
       );
     };
@@ -3672,18 +4857,18 @@ var PipRailClient = (_class2 = class {
         if (Date.now() >= deadline) break;
         await new Promise((r) => setTimeout(r, Math.min(2e3, 400 * 2 ** (attempt - 1))));
       }
-      throwIfAborted(_optionalChain([init, 'optionalAccess', _50 => _50.signal]));
+      throwIfAborted(_optionalChain([init, 'optionalAccess', _86 => _86.signal]));
       const budget = Math.min(this.retryTimeoutMs, deadline - Date.now());
       if (budget <= 0) break;
       const timeoutController = new AbortController();
       const timeoutId = setTimeout(() => timeoutController.abort(), budget);
-      const signal = _optionalChain([init, 'optionalAccess', _51 => _51.signal]) && typeof AbortSignal.any === "function" ? AbortSignal.any([timeoutController.signal, init.signal]) : timeoutController.signal;
+      const signal = _optionalChain([init, 'optionalAccess', _87 => _87.signal]) && typeof AbortSignal.any === "function" ? AbortSignal.any([timeoutController.signal, init.signal]) : timeoutController.signal;
       let response;
       try {
         response = await fetch(url, { ..._nullishCoalesce(init, () => ( {})), headers, signal });
       } catch (err) {
-        throw new (0, _chunkVPENSVOIcjs.PaymentTimeoutError)(
-          `exact: no response after submitting the authorization (nonce=${nonce}) to ${hostOf2(url)}. The facilitator may have already settled it \u2014 verify on-chain with authorizationState(${payerFrom}, ${nonce}) before re-presenting; do NOT re-pay.`,
+        throw new (0, _chunkMWBT7MCEcjs.PaymentTimeoutError)(
+          `upto: no response after submitting the authorization (nonce=${nonce}) to ${hostOf2(url)}. The merchant may have already settled it \u2014 verify on-chain before re-presenting; do NOT re-pay.`,
           { cause: err, ref: nonce }
         );
       } finally {
@@ -3691,46 +4876,48 @@ var PipRailClient = (_class2 = class {
       }
       const settle = parseSettleResponse(response);
       if (response.status === 402) {
-        if (settle && settle.success === false) rejectDefinitive(_nullishCoalesce(settle.errorReason, () => ( "the facilitator reported success:false")));
+        if (settle && settle.success === false) rejectDefinitive(_nullishCoalesce(settle.errorReason, () => ( "the server reported success:false")));
         lastReason = await _asyncNullishCoalesce(await readInvalidReason(response), async () => ( lastReason));
         continue;
       }
       if (response.ok && !(settle && settle.success === false)) {
         const receipt = parseReceipt(response);
+        this.captureReceipt(response, url);
         this.safeEmit({ kind: "payment-settled", receipt, ...settle ? { settle } : {} });
-        const ref = _optionalChain([settle, 'optionalAccess', _52 => _52.transaction]) || _optionalChain([receipt, 'optionalAccess', _53 => _53.transaction]) || `eip3009-nonce:${nonce}`;
-        this.recordSpend(quote, ref);
+        const ref = _optionalChain([settle, 'optionalAccess', _88 => _88.transaction]) || _optionalChain([receipt, 'optionalAccess', _89 => _89.transaction]) || `upto-nonce:${nonce}`;
+        const settledAmount = _nullishCoalesce(_optionalChain([settle, 'optionalAccess', _90 => _90.amount]), () => ( _optionalChain([receipt, 'optionalAccess', _91 => _91.amount])));
+        this.recordSpend(quote, ref, settledAmount);
         return response;
       }
       if (response.status >= 500) {
-        this.safeEmit({ kind: "payment-failed", reason: `exact: server ${response.status} \u2014 authorization nonce=${nonce} not settled` });
+        this.safeEmit({ kind: "payment-failed", reason: `upto: server ${response.status} \u2014 authorization nonce=${nonce} not settled` });
         return response;
       }
-      if (settle && settle.success === false) rejectDefinitive(_nullishCoalesce(settle.errorReason, () => ( "the facilitator reported success:false")));
-      this.safeEmit({ kind: "payment-failed", reason: `exact: server ${response.status} \u2014 authorization nonce=${nonce} not settled` });
+      if (settle && settle.success === false) rejectDefinitive(_nullishCoalesce(settle.errorReason, () => ( "the server reported success:false")));
+      this.safeEmit({ kind: "payment-failed", reason: `upto: server ${response.status} \u2014 authorization nonce=${nonce} not settled` });
       return response;
     }
     const why = lastReason ? `${lastReason.error}${lastReason.detail ? ` \u2014 ${lastReason.detail}` : ""}` : "server gave no reason";
     this.safeEmit({
       kind: "payment-failed",
-      reason: `exact: 402 after submitting authorization nonce=${nonce} (${why})`,
+      reason: `upto: 402 after submitting authorization nonce=${nonce} (${why})`,
       ...lastReason ? { code: lastReason.error, detail: lastReason.detail } : {}
     });
-    throw new (0, _chunkVPENSVOIcjs.MaxRetriesExceededError)(
-      `exact: server still returned 402 after submitting the signed authorization (nonce=${nonce}). Last rejection: ${why}. Re-present the SAME authorization \u2014 do NOT re-sign a fresh nonce; verify authorizationState(${payerFrom}, ${nonce}) first. ref=${nonce}.`,
+    throw new (0, _chunkMWBT7MCEcjs.MaxRetriesExceededError)(
+      `upto: server still returned 402 after submitting the signed authorization (nonce=${nonce}). Last rejection: ${why}. Re-present the SAME authorization \u2014 do NOT re-sign a fresh nonce. ref=${nonce}.`,
       { ref: nonce }
     );
   }
 }, _class2);
 function throwIfAborted(signal) {
-  if (_optionalChain([signal, 'optionalAccess', _54 => _54.aborted])) {
+  if (_optionalChain([signal, 'optionalAccess', _92 => _92.aborted])) {
     throw _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
   }
 }
 function safeBig(s) {
   try {
     return BigInt(s);
-  } catch (e28) {
+  } catch (e38) {
     return 0n;
   }
 }
@@ -3793,10 +4980,10 @@ function buildFundingHint(options, chainLabel) {
     return `Couldn't fully read your wallet on ${chainLabel} (RPC throttled) \u2014 retry; you may already be able to pay ${target.quote.amountFormatted} ${sym}.`;
   }
   const parts = [];
-  if (target.blockers.includes("INSUFFICIENT_TOKEN") && _optionalChain([target, 'access', _55 => _55.shortfall, 'optionalAccess', _56 => _56.token])) {
+  if (target.blockers.includes("INSUFFICIENT_TOKEN") && _optionalChain([target, 'access', _93 => _93.shortfall, 'optionalAccess', _94 => _94.token])) {
     parts.push(`top up ${target.shortfall.token} ${sym}`);
   }
-  if (target.blockers.includes("INSUFFICIENT_GAS") && _optionalChain([target, 'access', _57 => _57.shortfall, 'optionalAccess', _58 => _58.native])) {
+  if (target.blockers.includes("INSUFFICIENT_GAS") && _optionalChain([target, 'access', _95 => _95.shortfall, 'optionalAccess', _96 => _96.native])) {
     parts.push(`add ~${target.shortfall.native} ${target.cost.feeSymbol} for gas`);
   }
   return parts.length ? `Can't settle on ${chainLabel}: ${parts.join(" and ")} (to pay ${target.quote.amountFormatted} ${sym}).` : `Can't settle on ${chainLabel} for ${target.quote.amountFormatted} ${sym}.`;
@@ -3810,7 +4997,7 @@ async function planAcross(clients, url, init) {
   const status = best ? "ready" : options.some((o) => o.state === "unknown") ? "unknown" : "blocked";
   return {
     url,
-    network: _nullishCoalesce(_optionalChain([best, 'optionalAccess', _59 => _59.accept, 'access', _60 => _60.network]), () => ( live[0].network)),
+    network: _nullishCoalesce(_optionalChain([best, 'optionalAccess', _97 => _97.accept, 'access', _98 => _98.network]), () => ( live[0].network)),
     status,
     payable: best !== null,
     best,
@@ -3829,7 +5016,7 @@ async function fetchAcross(clients, url, init) {
   const best = rankAcross(live.map((p) => p.plan)).find((o) => o.state === "payable");
   if (!best) {
     const hint = mergeDeclineHint(live.map((p) => p.plan));
-    throw new (0, _chunkVPENSVOIcjs.PaymentDeclinedError)(hint || "No funded chain can settle this payment right now.");
+    throw new (0, _chunkMWBT7MCEcjs.PaymentDeclinedError)(hint || "No funded chain can settle this payment right now.");
   }
   const owner = live.find((p) => p.plan.options.includes(best)).client;
   return owner.fetch(url, { ..._nullishCoalesce(init, () => ( {})), autoRoute: true });
@@ -3843,8 +5030,11 @@ function reasonCodeForPolicy(code) {
     case "SESSION_EXPIRED":
       return "SESSION_EXPIRED";
     case "WINDOW_TOTAL":
+    case "WINDOW_COUNT":
       return "OUTSIDE_WINDOW";
     case "MAX_TOTAL":
+    case "MAX_TOTAL_DENOM":
+    case "MAX_PAYMENTS":
       return "BUDGET";
     case void 0:
       return void 0;
@@ -3855,7 +5045,7 @@ function reasonCodeForPolicy(code) {
 function hostOf2(url) {
   try {
     return new URL(url).hostname;
-  } catch (e29) {
+  } catch (e39) {
     return url;
   }
 }
@@ -3872,8 +5062,8 @@ function isReplayableBodyInit(value) {
 async function readInvalidReason(response) {
   try {
     const body = await response.clone().json();
-    const ext = _optionalChain([body, 'optionalAccess', _61 => _61.extensions]);
-    const piprail = _optionalChain([ext, 'optionalAccess', _62 => _62.piprail]);
+    const ext = _optionalChain([body, 'optionalAccess', _99 => _99.extensions]);
+    const piprail = _optionalChain([ext, 'optionalAccess', _100 => _100.piprail]);
     if (piprail && typeof piprail.code === "string") {
       return {
         error: piprail.code,
@@ -3892,16 +5082,52 @@ async function readInvalidReason(response) {
         detail: typeof body.invalidMessage === "string" ? body.invalidMessage : ""
       };
     }
-  } catch (e30) {
+  } catch (e40) {
   }
   const settle = parseSettleResponse(response);
-  if (_optionalChain([settle, 'optionalAccess', _63 => _63.errorReason])) return { error: settle.errorReason, detail: "" };
+  if (_optionalChain([settle, 'optionalAccess', _101 => _101.errorReason])) return { error: settle.errorReason, detail: "" };
   return null;
 }
+var EVM_PRESET_FOR_CHAINID = {
+  1: "ethereum",
+  8453: "base",
+  137: "polygon",
+  42161: "arbitrum",
+  10: "optimism",
+  43114: "avalanche",
+  56: "bnb"
+};
+function chainSelectorForNetwork(network, rpcUrl) {
+  const chainId = chainIdFromNetwork(network);
+  if (chainId !== null) {
+    const preset = EVM_PRESET_FOR_CHAINID[chainId];
+    if (preset) return preset;
+    return { id: chainId, rpcUrl: _nullishCoalesce(rpcUrl, () => ( "")) };
+  }
+  const namespace = _nullishCoalesce(network.split(":")[0], () => ( ""));
+  return namespace === "tvm" ? "ton" : namespace;
+}
+function receiptAgeSeconds(verifiedAt) {
+  const t = Date.parse(verifiedAt);
+  if (Number.isNaN(t)) return 0;
+  return Math.max(0, Math.round((Date.now() - t) / 1e3));
+}
+function receiptIssuedAtSeconds(verifiedAt) {
+  const t = Date.parse(verifiedAt);
+  if (Number.isNaN(t)) return 0;
+  return Math.floor(t / 1e3);
+}
+function sameAddress(a, b) {
+  return typeof a === "string" && typeof b === "string" && a.toLowerCase() === b.toLowerCase();
+}
 
 // src/payer.ts
 var MultiChainPayer = class _MultiChainPayer {
   
+  /** True when every client shares ONE ledger (the `fromWallets` path) — so spend +
+   *  budget are read from that single source, never concatenated (which would
+   *  double-count a shared ledger). */
+  
   /**
    * Wrap an explicit, ordered set of single-chain clients — use this when a client
    * needs full control (e.g. a custom EVM chain configured by a viem `Chain`). The
@@ -3909,12 +5135,18 @@ var MultiChainPayer = class _MultiChainPayer {
    * at MOST one client per chain — two clients on the SAME network would double-count in
    * `spent()`/`budget()` and waste a plan round-trip (`fromWallets` can't produce this).
    * For the common case, prefer {@link MultiChainPayer.fromWallets}.
+   *
+   * For a cross-chain grand total / count cap via this path, build the clients with a
+   * SHARED `ledger` (`new SpendLedger(store?)` passed to each client's `ledger` option)
+   * and set `opts.shared = true` so reads come from that one ledger. `fromWallets` does
+   * this for you.
    */
-  constructor(clients) {
+  constructor(clients, opts = {}) {
     if (clients.length === 0) {
       throw new TypeError("MultiChainPayer needs at least one PipRailClient.");
     }
     this._clients = [...clients];
+    this._shared = _nullishCoalesce(opts.shared, () => ( false));
   }
   /**
    * Build one client per funded chain from a `{ chain → wallet }` map — the
@@ -3929,30 +5161,36 @@ var MultiChainPayer = class _MultiChainPayer {
    *     solana:  { key: process.env.SOLANA_SECRET! },
    *     xrpl:    { key: process.env.XRPL_SEED! },
    *   },
-   *   policy: { maxAmount: '1.00', maxTotal: '20.00', tokens: ['USDC', 'USDT'] },
+   *   // ONE budget across all three chains: $20 total + at most 100 payments.
+   *   policy: { maxAmount: '1.00', maxTotalPerDenom: { USD: '20.00' }, maxPayments: 100 },
    * })
    * const res = await payer.get('https://api.example.com/paid')  // pays on the first funded chain that can settle
    * ```
+   *
+   * Every client shares ONE {@link SpendLedger} (optionally backed by `spendStore`), so
+   * the cross-token grand total + the count caps span all chains as a single budget.
    */
   static fromWallets(opts) {
     const entries = Object.entries(opts.wallets);
     if (entries.length === 0) {
       throw new TypeError("MultiChainPayer.fromWallets needs at least one wallet.");
     }
+    const ledger = new SpendLedger(opts.spendStore);
     const clients = entries.map(
       ([chain, wallet]) => new PipRailClient({
         chain,
         wallet,
+        ledger,
         ...opts.policy ? { policy: opts.policy } : {},
         ...opts.schemes ? { schemes: opts.schemes } : {},
-        ..._optionalChain([opts, 'access', _64 => _64.rpcUrls, 'optionalAccess', _65 => _65[chain]]) ? { rpcUrl: opts.rpcUrls[chain] } : {},
+        ..._optionalChain([opts, 'access', _102 => _102.rpcUrls, 'optionalAccess', _103 => _103[chain]]) ? { rpcUrl: opts.rpcUrls[chain] } : {},
         ...opts.onBeforePay ? { onBeforePay: opts.onBeforePay } : {},
         ...opts.onEvent ? { onEvent: opts.onEvent } : {},
         ...opts.maxPaymentRetries != null ? { maxPaymentRetries: opts.maxPaymentRetries } : {},
         ...opts.retryTimeoutMs != null ? { retryTimeoutMs: opts.retryTimeoutMs } : {}
       })
     );
-    return new _MultiChainPayer(clients);
+    return new _MultiChainPayer(clients, { shared: true });
   }
   /** The underlying single-chain clients, in preference order. Reach for one of
    *  these for chain-specific reads (`estimateCost`, `discoverySigner`, per-chain
@@ -4003,7 +5241,7 @@ var MultiChainPayer = class _MultiChainPayer {
    * {@link PipRailClient.post}.
    */
   post(url, body, init) {
-    const headers = new Headers(_optionalChain([init, 'optionalAccess', _66 => _66.headers]));
+    const headers = new Headers(_optionalChain([init, 'optionalAccess', _104 => _104.headers]));
     let payload;
     if (body === void 0 || body === null) {
       payload = void 0;
@@ -4046,28 +5284,50 @@ var MultiChainPayer = class _MultiChainPayer {
   register(url, opts = {}) {
     return this._clients[0].register(url, opts);
   }
-  /** Aggregate spend across every chain — counts summed; per-(network,asset) rows
-   *  and records concatenated (no cross-chain collisions, never a cross-token sum). */
+  /**
+   * Aggregate spend across every chain. With a SHARED ledger (`fromWallets`), this reads
+   * that single ledger ONCE (its records already span every chain) — so the count and the
+   * cross-token `byDenom` grand total are correct and never double-counted. With
+   * independent clients (the explicit constructor), it concatenates: counts summed,
+   * per-(network,asset) `byAsset` + `byDenom` + records concatenated.
+   */
   spent() {
+    if (this._shared) return this._clients[0].spent();
     const summaries = this._clients.map((c) => c.spent());
     return {
       count: summaries.reduce((n, s) => n + s.count, 0),
       byAsset: summaries.flatMap((s) => s.byAsset),
+      byDenom: summaries.flatMap((s) => s.byDenom),
       records: summaries.flatMap((s) => s.records)
     };
   }
-  /** A merged budget view: every chain's per-(network,asset) remaining rows, plus the
-   *  MOST-RESTRICTIVE session time envelope across chains (the soonest deadline wins).
-   *  Mirrors {@link PipRailClient.budget}'s shape so the agent toolkit reads it
-   *  unchanged; per-chain session detail is on each `clients[i].budget()`. */
+  /**
+   * A merged budget view. With a SHARED ledger (`fromWallets`) it's the single source of
+   * truth — `byAsset`/`byDenom`/`counts` already span every chain, so the grand-total and
+   * count leashes read as ONE budget. With independent clients it merges: per-(network,
+   * asset) rows + per-denom rows concatenated, counts summed, and the MOST-RESTRICTIVE
+   * session time envelope (the soonest deadline wins). Per-chain detail is on each
+   * `clients[i].budget()`.
+   */
   budget() {
+    if (this._shared) return this._clients[0].budget();
     const budgets = this._clients.map((c) => c.budget());
     const session = budgets.map((b) => b.session).reduce((soonest, s) => {
       if (soonest.secondsRemaining == null) return s;
       if (s.secondsRemaining == null) return soonest;
       return s.secondsRemaining < soonest.secondsRemaining ? s : soonest;
     });
-    return { session, byAsset: budgets.flatMap((b) => b.byAsset) };
+    return {
+      session,
+      byAsset: budgets.flatMap((b) => b.byAsset),
+      byDenom: budgets.flatMap((b) => b.byDenom),
+      counts: { settled: budgets.reduce((n, b) => n + b.counts.settled, 0) }
+    };
+  }
+  /** The CONFIGURED spend policy (the shared policy `fromWallets` applies to every chain;
+   *  the first client's for the explicit constructor). `undefined` when none is set. */
+  policy() {
+    return this._clients[0].policy();
   }
 };
 function isBodyInit(value) {
@@ -4092,7 +5352,13 @@ var BRAND = {
 };
 var WHAT = 'This is an x402 "402 Payment Required" endpoint. Pay one of the offered rails to access it.';
 function howFor(scheme) {
-  return scheme === "exact" ? "Standard x402 exact rail \u2014 sign an EIP-3009 / Permit2 / SVM authorization; any stock x402 client (e.g. @x402/fetch) can pay this." : "Pay this amount on-chain to payTo, then resubmit with a payment-signature header carrying the proof ref + nonce. Easiest with @piprail/sdk (see sdk.install).";
+  if (scheme === "exact") {
+    return "Standard x402 exact rail \u2014 sign an EIP-3009 / Permit2 / SVM authorization; any stock x402 client (e.g. @x402/fetch) can pay this.";
+  }
+  if (scheme === "upto") {
+    return "Standard x402 upto (metered) rail \u2014 sign a Permit2 authorization for the MAX amount; the server settles the ACTUAL (\u2264 max) after serving. BUDGET AGAINST THE MAX \u2014 the server MAY fully charge it. EVM-Permit2 only; enable with schemes:['upto'].";
+  }
+  return "Pay this amount on-chain to payTo, then resubmit with a payment-signature header carrying the proof ref + nonce. Easiest with @piprail/sdk (see sdk.install).";
 }
 function railOf(a) {
   const extra = _nullishCoalesce(a.extra, () => ( {}));
@@ -4119,19 +5385,20 @@ function buildSelfDescription(input) {
     mcp: { run: BRAND.mcpRun, tool: "piprail_pay_request" },
     docs: { home: BRAND.home, agents: BRAND.docs, pay: BRAND.payDocs },
     discovery: { openapi: "/openapi.json", wellKnown: "/.well-known/x402" },
+    ...input.verifiableReceipts ? { verifiableReceipts: true } : {},
     ...input.instruction ? { instruction: input.instruction } : {}
   };
 }
 function buildEndpointInfo(input) {
   const d = input.descriptor;
-  const summary = _nullishCoalesce(_optionalChain([d, 'optionalAccess', _67 => _67.summary]), () => ( input.description));
-  const hasInput = _optionalChain([d, 'optionalAccess', _68 => _68.queryParams]) && Object.keys(d.queryParams).length > 0;
+  const summary = _nullishCoalesce(_optionalChain([d, 'optionalAccess', _105 => _105.summary]), () => ( input.description));
+  const hasInput = _optionalChain([d, 'optionalAccess', _106 => _106.queryParams]) && Object.keys(d.queryParams).length > 0;
   const endpoint = {
     ...summary ? { summary } : {},
-    ..._optionalChain([d, 'optionalAccess', _69 => _69.method]) ? { method: d.method.toUpperCase() } : {},
+    ..._optionalChain([d, 'optionalAccess', _107 => _107.method]) ? { method: d.method.toUpperCase() } : {},
     ...input.mimeType ? { mimeType: input.mimeType } : {},
     ...hasInput ? { input: d.queryParams } : {},
-    ..._optionalChain([d, 'optionalAccess', _70 => _70.output]) ? { output: d.output } : {}
+    ..._optionalChain([d, 'optionalAccess', _108 => _108.output]) ? { output: d.output } : {}
   };
   return Object.keys(endpoint).length > 0 ? endpoint : void 0;
 }
@@ -4149,7 +5416,7 @@ function summarizePlan(plan) {
   return `NOT payable: ${_nullishCoalesce(plan.fundingHint, () => ( `no settleable rail on ${plan.network}`))}`;
 }
 function explainDecline(err) {
-  if (!(err instanceof _chunkVPENSVOIcjs.PipRailError)) {
+  if (!(err instanceof _chunkMWBT7MCEcjs.PipRailError)) {
     return `Payment failed: ${err instanceof Error ? err.message : String(err)}`;
   }
   switch (err.code) {
@@ -4172,9 +5439,12 @@ function explainDecline(err) {
 }
 function formatSpendReport(summary) {
   if (summary.count === 0) return "No payments yet.";
-  return summary.byAsset.map(
+  const perAsset = summary.byAsset.map(
     (a) => `${a.totalFormatted} ${_nullishCoalesce(a.symbol, () => ( a.asset))} on ${a.network} (${a.count} payment${a.count === 1 ? "" : "s"})`
   ).join("; ");
+  if (summary.byDenom.length === 0) return perAsset;
+  const grand = summary.byDenom.map((d) => `${d.totalFormatted} ${d.denom} total`).join("; ");
+  return `${perAsset} \u2014 grand total: ${grand}`;
 }
 function describeChallenge(challenge) {
   const first = challenge.accepts[0];
@@ -4215,17 +5485,21 @@ and pay with the tools below.
 Always plan before you pay so you never commit to a payment you cannot finish.
 
 ## Gasless \u2014 the exact rail (zero gas for you)
-A 402 may offer up to two rails; you don't choose per payment \u2014 the client does, automatically:
+A 402 may offer up to three rails; you don't choose per payment \u2014 the client does, automatically:
 - onchain-proof (PipRail's default): you broadcast the payment yourself and pay the network gas
   (the native coin \u2014 ETH/SOL/\u2026). Works on every chain.
 - exact (the ratified x402 rail, opt-in): you only SIGN; the server \u2014 or a facilitator it chose
   (e.g. PayAI) \u2014 broadcasts it, so you pay ZERO gas (you need only the token, no native coin). It
   works on EVM, Solana + Algorand, and the on-chain method (EIP-3009 / Permit2 / SVM / Algorand
   fee-pooled group) is picked automatically.
+- upto (the metered/variable x402 rail, opt-in, EVM): the amount you see is a MAXIMUM \u2014 you sign
+  a ceiling, the server meters real usage and settles the ACTUAL (<= the max). BUDGET AGAINST THE MAX:
+  the plan/policy treat the ceiling as the spend (a server may charge up to it), so a payable plan
+  means the MAX fits your budget; the settled actual is recorded for reconciliation.
 When the exact scheme is enabled AND balance-aware routing is on, paying picks the cheapest
 settleable rail \u2014 i.e. the gasless exact one. Nothing changes in your loop: quote \u2192 plan \u2192 pay is
-identical. The exact scheme is OPT-IN by the operator (MCP: PIPRAIL_SCHEMES=onchain-proof,exact);
-you can't enable it yourself, but you can report when a 402 needs it (see UNSUPPORTED_SCHEME below).
+identical. The exact/upto schemes are OPT-IN by the operator (MCP: PIPRAIL_SCHEMES=onchain-proof,exact,upto);
+you can't enable them yourself, but you can report when a 402 needs one (see UNSUPPORTED_SCHEME below).
 
 ## Reading a refusal \u2014 never crash, never double-spend
 A failed pay returns a STRUCTURED object, never a thrown error you must catch:
@@ -4253,9 +5527,11 @@ Branch on \`code\` (always reliable). Key cases:
   once (enable the exact scheme); report it, don't retry the same call blindly.
 
 ## Knowing your leash \u2014 call piprail_budget
-piprail_budget tells you how much budget and time you have left, per
-(network, asset), plus your spend so far. Read-only; moves no funds. Use it in
-Mode A to self-check before paying.
+piprail_budget tells you how much budget and time you have left: per (network,
+asset) remaining, the cross-token GRAND TOTAL per denomination (e.g. how much
+USD you can still spend across every stablecoin and chain), the payment-count
+leash, the session time envelope, your spend so far, and the configured policy
+read back. Read-only; moves no funds. Use it in Mode A to self-check before paying.
 
 ## Two modes
 - Mode A (headless, default): you run FREE inside a pre-set budget + time
@@ -4266,10 +5542,15 @@ Mode A to self-check before paying.
   do NOT retry it as if it were a transient error.
 
 ## Hard facts
-- Spend caps are PER (network, asset). There is no single cross-token dollar cap \u2014
-  budgets aren't summed across tokens (no price oracle).
-- Spend totals and the time envelope live IN-MEMORY for THIS process; they reset on restart
-  (a convenience, not a durable ledger).
+- Per-payment + per-(network, asset) caps always apply. A cross-token GRAND TOTAL per
+  denomination (maxTotalPerDenom, e.g. "$20 across every USD stablecoin + chain") is
+  OPTIONAL \u2014 it sums tokens declared as one unit, each 1:1; it is NOT a price oracle and
+  never prices a volatile native coin. Payment-COUNT caps (maxPayments / per-window) also
+  span every chain + token.
+- The time envelope lives IN-MEMORY for THIS process (resets on restart). The money + count
+  totals also reset on restart UNLESS a durable spend store is configured \u2014 then they resume.
+- A refusal arrives as declined:true with a reasonCode; 'BUDGET' covers the lifetime, denom,
+  and count caps; 'OUTSIDE_WINDOW' covers both the rolling money and rolling count windows.
 `;
 function agentGuide() {
   return PIPRAIL_AGENT_GUIDE;
@@ -4282,19 +5563,19 @@ async function readBody(res) {
   if (!text) return null;
   try {
     return JSON.parse(text);
-  } catch (e31) {
+  } catch (e41) {
     return text;
   }
 }
 function toToolError(err) {
-  if (!(err instanceof _chunkVPENSVOIcjs.PipRailError)) throw err;
+  if (!(err instanceof _chunkMWBT7MCEcjs.PipRailError)) throw err;
   const out = {
     ok: false,
     code: err.code,
     reason: err.message,
     explain: explainDecline(err)
   };
-  if (err instanceof _chunkVPENSVOIcjs.PaymentDeclinedError) {
+  if (err instanceof _chunkMWBT7MCEcjs.PaymentDeclinedError) {
     out.declined = true;
     if (err.reasonCode) out.reasonCode = err.reasonCode;
   }
@@ -4501,21 +5782,23 @@ function paymentTools(client) {
             }
             res = await client.fetch(url, { method, headers, body });
           }
+          const verifiable = parseReceiptExtension(res);
           return {
             status: res.status,
             ok: res.ok,
             body: await readBody(res),
-            receipt: parseReceipt(res)
+            receipt: parseReceipt(res),
+            ...verifiable ? { verifiableReceipt: { ...verifiable, resource: { url } } } : {}
           };
         } catch (err) {
-          if (err instanceof _chunkVPENSVOIcjs.PipRailError) {
+          if (err instanceof _chunkMWBT7MCEcjs.PipRailError) {
             const out = {
               ok: false,
               code: err.code,
               reason: err.message,
               explain: explainDecline(err)
             };
-            if (err instanceof _chunkVPENSVOIcjs.PaymentDeclinedError) {
+            if (err instanceof _chunkMWBT7MCEcjs.PaymentDeclinedError) {
               out.declined = true;
               if (err.reasonCode) out.reasonCode = err.reasonCode;
             }
@@ -4584,11 +5867,11 @@ function paymentTools(client) {
     },
     {
       name: "piprail_budget",
-      description: "Read how much of your spend budget and time leash is left \u2014 per (network, asset) remaining, the session time envelope, and your spend so far. Use it in Mode A (headless) to self-check BEFORE paying, so you never discover the leash by hitting a decline. Read-only; moves no funds. NOTE: totals and the time envelope are in-memory for THIS process and reset on restart.",
+      description: "Read how much of your spend budget and time leash is left \u2014 per (network, asset) remaining, the cross-token GRAND TOTAL per denomination (e.g. how much USD you can still spend across every stablecoin and chain), the payment-count leash, the session time envelope, and your spend so far. Use it in Mode A (headless) to self-check BEFORE paying, so you never discover the leash by hitting a decline. Read-only; moves no funds. NOTE: the time envelope is in-memory for THIS process; the money/count totals persist only if a spend store is configured.",
       annotations: {
         title: "Check remaining budget",
         readOnlyHint: true,
-        // reads the in-memory ledger + policy; never pays
+        // reads the ledger + policy; never pays
         idempotentHint: true
         // a pure read
       },
@@ -4601,7 +5884,13 @@ function paymentTools(client) {
           return {
             spent,
             remaining: budget.byAsset,
+            grandTotal: budget.byDenom,
+            // cross-token spend cap per denomination (USD/EUR/…)
+            counts: budget.counts,
+            // payment-count leash (settled + lifetime/window caps)
             session: budget.session,
+            policy: _nullishCoalesce(client.policy(), () => ( null)),
+            // the configured leash, read back
             report: formatSpendReport(spent)
           };
         } catch (err) {
@@ -4619,6 +5908,38 @@ function paymentTools(client) {
       },
       parameters: { type: "object", properties: {}, additionalProperties: false },
       invoke: async () => ({ guide: PIPRAIL_AGENT_GUIDE })
+    },
+    {
+      name: "piprail_verify_receipt",
+      description: "Re-verify a PipRail VERIFIABLE RECEIPT against the chain \u2014 confirm a payment REALLY settled (the funds provably moved to payTo for AT LEAST the stated amount) WITHOUT trusting whoever handed you the receipt. Read-only and WALLET-FREE: pass the PipRailReceipt JSON (from a prior piprail_pay_request `verifiableReceipt`, or any third party). Returns { ok, onChain:{payTo,asset,amount,payer}, matchesClaims, ageSeconds, error? }: `ok` = the chain confirms the settlement; `onChain.payer` is RE-DERIVED from the tx and `matchesClaims:false` means the receipt forged the payer; `amount` is a verified lower bound. Pass `rpcUrl` for a chain outside the common presets.",
+      annotations: {
+        title: "Verify a payment receipt",
+        readOnlyHint: true,
+        // re-reads the chain; moves nothing, needs no wallet
+        idempotentHint: true,
+        openWorldHint: true
+        // reads an on-chain tx via RPC
+      },
+      parameters: {
+        type: "object",
+        properties: {
+          receipt: {
+            type: "object",
+            description: "The PipRailReceipt JSON ({ piprail, receipt, resource, decimals? }) to re-verify."
+          },
+          rpcUrl: {
+            type: "string",
+            description: "Optional RPC URL for the receipt's chain (required for chains outside the common presets)."
+          }
+        },
+        required: ["receipt"],
+        additionalProperties: false
+      },
+      invoke: async (args) => {
+        const receipt = args.receipt;
+        const opts = args.rpcUrl ? { rpcUrl: String(args.rpcUrl) } : void 0;
+        return await PipRailClient.verifyReceipt(receipt, opts);
+      }
     }
   ];
 }
@@ -4675,7 +5996,7 @@ function buildBazaarExtension(descriptor = {}) {
 function pathOf(url) {
   try {
     return new URL(url).pathname || "/";
-  } catch (e32) {
+  } catch (e42) {
     return url.startsWith("/") ? url : `/${url}`;
   }
 }
@@ -4784,28 +6105,28 @@ async function fetchFacilitatorFeePayer(url, network, timeoutMs = 8e3) {
     const res = await fetch(`${base2}/supported`, { signal: ctrl.signal });
     if (!res.ok) return void 0;
     const body = await res.json();
-    const kinds = Array.isArray(_optionalChain([body, 'optionalAccess', _71 => _71.kinds])) ? body.kinds : [];
+    const kinds = Array.isArray(_optionalChain([body, 'optionalAccess', _109 => _109.kinds])) ? body.kinds : [];
     const want = normalizeNetwork(network);
-    const kind = kinds.find((k) => _optionalChain([k, 'optionalAccess', _72 => _72.scheme]) === "exact" && normalizeNetwork(String(_nullishCoalesce(_optionalChain([k, 'optionalAccess', _73 => _73.network]), () => ( "")))) === want);
-    const fp = _optionalChain([kind, 'optionalAccess', _74 => _74.extra, 'optionalAccess', _75 => _75.feePayer]);
+    const kind = kinds.find((k) => _optionalChain([k, 'optionalAccess', _110 => _110.scheme]) === "exact" && normalizeNetwork(String(_nullishCoalesce(_optionalChain([k, 'optionalAccess', _111 => _111.network]), () => ( "")))) === want);
+    const fp = _optionalChain([kind, 'optionalAccess', _112 => _112.extra, 'optionalAccess', _113 => _113.feePayer]);
     return typeof fp === "string" ? fp : void 0;
-  } catch (e33) {
+  } catch (e43) {
     return void 0;
   } finally {
     clearTimeout(timer);
   }
 }
 function parseFacilitatorSupported(body) {
-  const kinds = _optionalChain([body, 'optionalAccess', _76 => _76.kinds]);
+  const kinds = _optionalChain([body, 'optionalAccess', _114 => _114.kinds]);
   if (!Array.isArray(kinds)) return [];
   const out = [];
   for (const k of kinds) {
     if (!k || typeof k !== "object") continue;
     const o = k;
     if (typeof o.scheme !== "string" || typeof o.network !== "string") continue;
-    const fp = _optionalChain([o, 'access', _77 => _77.extra, 'optionalAccess', _78 => _78.feePayer]);
+    const fp = _optionalChain([o, 'access', _115 => _115.extra, 'optionalAccess', _116 => _116.feePayer]);
     const ver = o.x402Version;
-    const method = _optionalChain([o, 'access', _79 => _79.extra, 'optionalAccess', _80 => _80.assetTransferMethod]);
+    const method = _optionalChain([o, 'access', _117 => _117.extra, 'optionalAccess', _118 => _118.assetTransferMethod]);
     out.push({
       scheme: o.scheme,
       network: o.network,
@@ -4824,7 +6145,7 @@ async function facilitatorCoverage(url, timeoutMs = 8e3) {
     const res = await fetch(`${base2}/supported`, { signal: ctrl.signal });
     if (!res.ok) return [];
     return parseFacilitatorSupported(await res.json());
-  } catch (e34) {
+  } catch (e44) {
     return [];
   } finally {
     clearTimeout(timer);
@@ -4853,7 +6174,7 @@ async function post(url, body, headers) {
   let json = null;
   try {
     json = await res.json();
-  } catch (e35) {
+  } catch (e45) {
   }
   return { status: res.status, json };
 }
@@ -4869,13 +6190,13 @@ async function settleViaFacilitator(input) {
   try {
     verify = await post(`${base2}/verify`, body, auth);
   } catch (err) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `exact settle (facilitator ${base2}): /verify request failed (${err instanceof Error ? err.message : String(err)}).`,
       { cause: err }
     );
   }
   if (verify.status !== 200) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `exact settle (facilitator ${base2}): /verify returned HTTP ${verify.status} (transport/auth error).`
     );
   }
@@ -4891,13 +6212,13 @@ async function settleViaFacilitator(input) {
   try {
     settle = await post(`${base2}/settle`, body, auth);
   } catch (err) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `exact settle (facilitator ${base2}): /settle request failed (${err instanceof Error ? err.message : String(err)}).`,
       { cause: err }
     );
   }
   if (settle.status !== 200) {
-    throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+    throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
       `exact settle (facilitator ${base2}): /settle returned HTTP ${settle.status} (transport/auth error).`
     );
   }
@@ -5268,17 +6589,40 @@ function normaliseExactOption(exact) {
   return exact;
 }
 var TRANSIENT_VERIFY_CODES = /* @__PURE__ */ new Set(["tx_not_found", "insufficient_confirmations"]);
+function nowUnixSeconds(verifiedAt) {
+  if (verifiedAt) {
+    const t = Date.parse(verifiedAt);
+    if (!Number.isNaN(t)) return Math.floor(t / 1e3);
+  }
+  return Math.floor(Date.now() / 1e3);
+}
 function createPaymentGate(options) {
   const minConfirmations = _nullishCoalesce(options.minConfirmations, () => ( 1));
   const maxTimeoutSeconds = _nullishCoalesce(options.maxTimeoutSeconds, () => ( 600));
   const genNonce = _nullishCoalesce(options.generateNonce, () => ( (() => globalThis.crypto.randomUUID())));
   const exactOption = normaliseExactOption(options.exact);
+  const receiptsOn = options.receipts !== void 0 && options.receipts !== false;
+  const receiptOpt = typeof options.receipts === "object" ? options.receipts : {};
+  const receiptIncludeTxHash = receiptOpt.includeTxHash !== false;
+  const receiptResourceUrl = _nullishCoalesce(receiptOpt.resource, () => ( ""));
+  const attestWallet = receiptOpt.attest && "wallet" in receiptOpt.attest ? receiptOpt.attest.wallet : void 0;
+  const attestJws = receiptOpt.attest && "jws" in receiptOpt.attest;
+  let attestWarned = false;
+  function warnAttestDegrade(reason) {
+    if (attestWarned) return;
+    attestWarned = true;
+    try {
+      console.warn(`[piprail] receipts.attest ${reason}; emitting an unsigned Tier-1 receipt instead.`);
+    } catch (e46) {
+    }
+  }
   let resolved;
   function ready() {
     if (resolved) return resolved;
     const p = (async () => {
       const accepts = normaliseAccepts(options);
       const exactSkips = [];
+      const uptoSkips = [];
       const specs = await Promise.all(
         accepts.map(async (a) => {
           const net = await resolveNetwork2({ chain: a.chain, rpcUrl: _nullishCoalesce(a.rpcUrl, () => ( options.rpcUrl)) });
@@ -5290,20 +6634,30 @@ function createPaymentGate(options) {
           }
           net.assertValidPayTo(payTo);
           const { asset, decimals, symbol } = net.resolveToken(a.token);
-          const amountBase = _chunkVPENSVOIcjs.parseUnits.call(void 0, a.amount, decimals);
+          const amountBase = _chunkMWBT7MCEcjs.parseUnits.call(void 0, a.amount, decimals);
           const spec = { net, asset, decimals, symbol, amountBase, amountFormatted: a.amount, payTo };
           if (exactOption) {
             const outcome = await resolveExactRail(net, asset);
             if (outcome.rail) spec.exact = outcome.rail;
             else if (outcome.skipReason) exactSkips.push(outcome.skipReason);
           }
+          if (options.upto) {
+            const upto = await resolveUptoRail(net, asset);
+            if (upto) spec.upto = upto;
+            else uptoSkips.push(`${net.network}/${asset}`);
+          }
           return spec;
         })
       );
+      if (options.upto && !specs.some((s) => s.upto)) {
+        throw new Error(
+          `requirePayment: \`upto\` (the metered rail) was requested but none of the offered rails support it (tried: ${uptoSkips.join(", ") || "none"}). The \`upto\` scheme is EVM-Permit2 ONLY \u2014 an ERC-20 on a chain with the x402UptoPermit2Proxy deployed (Ethereum/Base/Arbitrum/Optimism/Polygon/BNB), NOT a native coin, NOT a non-EVM family. (Native coins + non-Permit2 chains can never carry \`upto\`.)`
+        );
+      }
       if (exactOption && !specs.some((s) => s.exact)) {
         const why = exactSkips.length > 0 ? exactSkips.join(" ") : "The standard `exact` rail is EVM ERC-20 (EIP-3009 \u2014 USDC / EURC \u2014 or Permit2, e.g. Binance-Peg USDC on BNB) or a Solana SPL token (SVM) \u2014 NOT native coins, NOT families without a standard `exact` scheme.";
         if (exactOption.settle === "keyless") {
-          if (typeof process === "undefined" || !_optionalChain([process, 'optionalAccess', _81 => _81.env, 'optionalAccess', _82 => _82.PIPRAIL_NO_HINTS])) {
+          if (typeof process === "undefined" || !_optionalChain([process, 'optionalAccess', _119 => _119.env, 'optionalAccess', _120 => _120.PIPRAIL_NO_HINTS])) {
             console.warn(
               `[piprail] exact: true \u2014 no offered chain has a gasless \`exact\` rail available, so this gate serves ONCHAIN-PROOF ONLY (buyers PAY GAS \u2014 the fallback when no facilitator can sponsor). ${why} To be gasless: pin \`exact: { settle: { facilitator } }\` or self-settle \`exact: { settle: 'self', relayer }\`. (Suppress with PIPRAIL_NO_HINTS=1.)`
             );
@@ -5331,7 +6685,7 @@ function createPaymentGate(options) {
           skipReason: `${net.network}: \`exact: true\` found no known keyless facilitator for this network. Pass \`exact: { settle: { facilitator } }\`, \`exact: { settle: 'self', relayer }\`, or see the coverage map (KNOWN_FACILITATORS / docs.piprail.com).`
         };
       }
-      if (typeof process === "undefined" || _optionalChain([process, 'optionalAccess', _83 => _83.env, 'optionalAccess', _84 => _84.NODE_ENV]) !== "production" && !_optionalChain([process, 'optionalAccess', _85 => _85.env, 'optionalAccess', _86 => _86.PIPRAIL_NO_HINTS])) {
+      if (typeof process === "undefined" || _optionalChain([process, 'optionalAccess', _121 => _121.env, 'optionalAccess', _122 => _122.NODE_ENV]) !== "production" && !_optionalChain([process, 'optionalAccess', _123 => _123.env, 'optionalAccess', _124 => _124.PIPRAIL_NO_HINTS])) {
         console.warn(
           `[piprail] exact: keyless rail on ${net.network} auto-settles via ${picked.url} (zero-config; pin \`exact.settle.facilitator\` in production).`
         );
@@ -5379,7 +6733,27 @@ function createPaymentGate(options) {
     };
     return { rail: { method: info.method, ...info.extra ? { extra: info.extra } : {}, mode } };
   }
-  const hasCustomStore = Boolean(options.isUsed || options.markUsed);
+  async function resolveUptoRail(net, asset) {
+    const cfg = options.upto;
+    if (!net.resolveUptoRail) return null;
+    if (cfg.relayer === void 0) {
+      throw new Error(
+        "requirePayment: `upto` needs a `relayer` wallet (the gas-paying key that self-settles the metered actual AND is the bound witness.facilitator), e.g. upto: { relayer: { key }, settleAmount }."
+      );
+    }
+    const relayer = net.bindWallet(cfg.relayer);
+    const info = await net.resolveUptoRail({ asset, relayer });
+    if (!info) return null;
+    return { method: info.method, ...info.extra ? { extra: info.extra } : {}, relayer };
+  }
+  const hasIsUsed = typeof options.isUsed === "function";
+  const hasMarkUsed = typeof options.markUsed === "function";
+  if (hasIsUsed !== hasMarkUsed) {
+    throw new Error(
+      "requirePayment/createPaymentGate: `isUsed` and `markUsed` must be provided TOGETHER \u2014 a custom replay store needs both a read and a write. Supplying only " + (hasIsUsed ? "`isUsed`" : "`markUsed`") + " silently disables replay protection (double-spend). Provide both, or neither (the built-in in-memory store)."
+    );
+  }
+  const hasCustomStore = hasIsUsed && hasMarkUsed;
   const localUsed = /* @__PURE__ */ new Map();
   const replayWindowMs = maxTimeoutSeconds * 1e3;
   function pruneUsed(now) {
@@ -5442,10 +6816,33 @@ function createPaymentGate(options) {
       }
     };
   }
+  function buildUptoAccept(s) {
+    const rail = s.upto;
+    return {
+      scheme: "upto",
+      network: s.net.network,
+      amount: s.amountBase.toString(),
+      // the authorized MAX (base units)
+      asset: s.asset,
+      payTo: s.payTo,
+      maxTimeoutSeconds,
+      extra: {
+        assetTransferMethod: "permit2-upto",
+        // facilitatorAddress comes from rail.extra; the spread below carries it (+ name/version).
+        facilitatorAddress: _nullishCoalesce(_optionalChain([rail, 'access', _125 => _125.extra, 'optionalAccess', _126 => _126.facilitatorAddress]), () => ( "")),
+        minConfirmations,
+        decimals: s.decimals,
+        amountFormatted: s.amountFormatted,
+        ...s.symbol ? { symbol: s.symbol } : {},
+        ...rail.extra
+      }
+    };
+  }
   function buildAccepts(specs, nonce) {
     const out = [];
     for (const s of specs) {
       if (s.exact) out.push(buildExactAccept(s));
+      if (s.upto) out.push(buildUptoAccept(s));
       out.push(buildAccept(s, nonce));
     }
     return out;
@@ -5463,9 +6860,10 @@ function createPaymentGate(options) {
     const selfDescribe = options.selfDescribe === false ? void 0 : buildSelfDescription({
       accepts,
       instruction: describeChallenge({ x402Version: 2, resource: { url: resourceUrl }, accepts }),
-      ...endpointInfo ? { endpoint: endpointInfo } : {}
+      ...endpointInfo ? { endpoint: endpointInfo } : {},
+      ...receiptsOn ? { verifiableReceipts: true } : {}
     });
-    const rejectionExt = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _87 => _87.extensions]), () => ( {}));
+    const rejectionExt = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _127 => _127.extensions]), () => ( {}));
     const rejectionPiprail = _nullishCoalesce(rejectionExt.piprail, () => ( {}));
     const bodyPiprail = { ..._nullishCoalesce(selfDescribe, () => ( {})), ...rejectionPiprail };
     const bodyExtensions = {
@@ -5485,7 +6883,7 @@ function createPaymentGate(options) {
         ...options.mimeType ? { mimeType: options.mimeType } : {}
       },
       accepts,
-      ..._optionalChain([opts, 'optionalAccess', _88 => _88.error]) ? { error: opts.error } : {},
+      ..._optionalChain([opts, 'optionalAccess', _128 => _128.error]) ? { error: opts.error } : {},
       ...Object.keys(bodyExtensions).length > 0 ? { extensions: bodyExtensions } : {}
     };
     const headerChallenge = {
@@ -5516,8 +6914,8 @@ function createPaymentGate(options) {
   function enrichReceipt(spec, receipt) {
     let amountFormatted = receipt.amount;
     try {
-      amountFormatted = _chunkVPENSVOIcjs.formatUnits.call(void 0, BigInt(receipt.amount), spec.decimals);
-    } catch (e36) {
+      amountFormatted = _chunkMWBT7MCEcjs.formatUnits.call(void 0, BigInt(receipt.amount), spec.decimals);
+    } catch (e47) {
     }
     return {
       ...receipt,
@@ -5531,7 +6929,7 @@ function createPaymentGate(options) {
     if (!options.onPaidError) return;
     try {
       options.onPaidError(error, receipt);
-    } catch (e37) {
+    } catch (e48) {
     }
   }
   function fireOnPaid(receipt) {
@@ -5552,11 +6950,60 @@ function createPaymentGate(options) {
     if (options.awaitOnPaid) await fireOnPaid(paid);
     else void fireOnPaid(paid);
   }
+  async function buildPaidResult(spec, receipt, nonce) {
+    if (!receiptsOn) {
+      return { kind: "paid", receipt, receiptHeader: buildReceiptHeader(receipt) };
+    }
+    try {
+      const stamped = {
+        ...receipt,
+        ...nonce ? { nonce } : {},
+        // §5.3: a suppressed tx is the empty string on the wire, never a missing key.
+        ...receiptIncludeTxHash ? {} : { transaction: "" }
+      };
+      const attestation = await maybeSignAttestation(spec, stamped);
+      const extensions = buildReceiptExtension({
+        receipt: stamped,
+        resource: { url: receiptResourceUrl },
+        decimals: spec.decimals,
+        ...attestation ? { attestation } : {}
+      });
+      return { kind: "paid", receipt: stamped, receiptHeader: buildReceiptHeader(stamped, extensions) };
+    } catch (e49) {
+      return { kind: "paid", receipt, receiptHeader: buildReceiptHeader(receipt) };
+    }
+  }
+  async function maybeSignAttestation(spec, stamped) {
+    if (attestJws) {
+      warnAttestDegrade("JWS attestation is not yet implemented (R3)");
+      return void 0;
+    }
+    if (attestWallet === void 0) return void 0;
+    if (typeof spec.net.signReceipt !== "function") {
+      warnAttestDegrade(`is EVM-only; the ${spec.net.family} rail can't sign an EIP-712 attestation`);
+      return void 0;
+    }
+    try {
+      const wallet = spec.net.bindWallet(attestWallet);
+      return await spec.net.signReceipt(wallet, {
+        payTo: spec.payTo,
+        network: spec.net.network,
+        resourceUrl: receiptResourceUrl,
+        payer: stamped.payer,
+        issuedAt: nowUnixSeconds(stamped.verifiedAt),
+        // §5.3: the signed message carries the empty string for a suppressed tx, never omitted.
+        transaction: receiptIncludeTxHash ? stamped.transaction : ""
+      });
+    } catch (e50) {
+      warnAttestDegrade("signing failed");
+      return void 0;
+    }
+  }
   function reportOnFailedError(error, failure) {
     if (!options.onFailedError) return;
     try {
       options.onFailedError(error, failure);
-    } catch (e38) {
+    } catch (e51) {
     }
   }
   function fireOnFailed(failure) {
@@ -5578,6 +7025,14 @@ function createPaymentGate(options) {
     if (options.awaitOnFailed) await fireOnFailed(failure);
     else void fireOnFailed(failure);
   }
+  function railExtra(full) {
+    const out = {};
+    for (const k of ["assetTransferMethod", "facilitatorAddress", "name", "version"]) {
+      const v = full[k];
+      if (v !== void 0 && v !== "") out[k] = v;
+    }
+    return Object.keys(out).length > 0 ? { extra: out } : {};
+  }
   async function describe(resourceUrl = "") {
     const specs = await ready();
     const accepts = [];
@@ -5592,7 +7047,8 @@ function createPaymentGate(options) {
         maxTimeoutSeconds,
         ...s.symbol ? { symbol: s.symbol } : {}
       };
-      if (s.exact) accepts.push({ scheme: "exact", ...base2 });
+      if (s.exact) accepts.push({ scheme: "exact", ...base2, ...railExtra(buildExactAccept(s).extra) });
+      if (s.upto) accepts.push({ scheme: "upto", ...base2, ...railExtra(buildUptoAccept(s).extra) });
       accepts.push({ scheme: "onchain-proof", ...base2 });
     }
     return {
@@ -5628,7 +7084,7 @@ function createPaymentGate(options) {
     }
     await settleTx(ref, true);
     await deliverOnPaid(spec, result.receipt);
-    return { kind: "paid", receipt: result.receipt, receiptHeader: buildReceiptHeader(result.receipt) };
+    return await buildPaidResult(spec, result.receipt, sig.payload.nonce);
   }
   async function verifyExact(exact) {
     const specs = await ready();
@@ -5656,28 +7112,28 @@ function createPaymentGate(options) {
       nonce = [exact.payload.transaction, exact.payload.senderAuth].map((t) => {
         try {
           return Buffer.from(t, "base64").toString("base64");
-        } catch (e39) {
+        } catch (e52) {
           return t;
         }
       }).join("|");
     } else if ("transaction" in exact.payload) {
       try {
         nonce = Buffer.from(exact.payload.transaction, "base64").toString("base64");
-      } catch (e40) {
+      } catch (e53) {
         nonce = exact.payload.transaction;
       }
     } else if ("paymentGroup" in exact.payload) {
       nonce = exact.payload.paymentGroup.map((t) => {
         try {
           return Buffer.from(t, "base64").toString("base64");
-        } catch (e41) {
+        } catch (e54) {
           return t;
         }
       }).join("|");
     } else if ("signedDelegateAction" in exact.payload) {
       try {
         nonce = Buffer.from(exact.payload.signedDelegateAction, "base64").toString("base64");
-      } catch (e42) {
+      } catch (e55) {
         nonce = exact.payload.signedDelegateAction;
       }
     } else if ("permit2Authorization" in exact.payload) {
@@ -5700,7 +7156,7 @@ function createPaymentGate(options) {
         const ftMethod = accept.extra.assetTransferMethod;
         const needsFeePayer = ftMethod === "svm" || ftMethod === "algorand" || ftMethod === "aptos" || ftMethod === "near";
         if (needsFeePayer && !accept.extra.feePayer) {
-          throw new (0, _chunkVPENSVOIcjs.SettlementError)(
+          throw new (0, _chunkMWBT7MCEcjs.SettlementError)(
             `exact settle: the ${ftMethod} facilitator rail is missing extra.feePayer (the gas sponsor) \u2014 cannot settle.`
           );
         }
@@ -5738,34 +7194,129 @@ function createPaymentGate(options) {
     }
     await settleTx(nonce, true);
     await deliverOnPaid(spec, result.receipt);
-    return { kind: "paid", receipt: result.receipt, receiptHeader: buildReceiptHeader(result.receipt) };
+    return await buildPaidResult(spec, result.receipt);
+  }
+  function resolveSettleAmount(raw, maxAmount, decimals) {
+    if (typeof raw === "bigint") return raw < 0n ? null : raw;
+    const s = raw.trim();
+    if (s.length === 0) return null;
+    try {
+      if (s.endsWith("%")) {
+        const pct = s.slice(0, -1).trim();
+        if (!/^\d+(\.\d+)?$/.test(pct)) return null;
+        const pctScaled = _chunkMWBT7MCEcjs.floorUnits.call(void 0, pct, 4);
+        return maxAmount * pctScaled / (100n * 10n ** 4n);
+      }
+      if (s.startsWith("$")) {
+        const amt = s.slice(1).trim();
+        return _chunkMWBT7MCEcjs.floorUnits.call(void 0, amt, decimals);
+      }
+      if (/^\d+$/.test(s)) return BigInt(s);
+      return _chunkMWBT7MCEcjs.floorUnits.call(void 0, s, decimals);
+    } catch (e56) {
+      return null;
+    }
+  }
+  async function verifyUpto(upto) {
+    const specs = await ready();
+    const uptoSpecs = specs.filter((s) => s.upto);
+    if (uptoSpecs.length === 0) {
+      return rejection("transfer_not_found", "This resource offers no standard `upto` (metered) rail.");
+    }
+    const isCaip = upto.network.includes(":");
+    let candidates = isCaip ? uptoSpecs.filter((s) => s.net.network === upto.network) : uptoSpecs;
+    if (upto.asset) {
+      candidates = candidates.filter((s) => s.asset.toLowerCase() === upto.asset.toLowerCase());
+    }
+    let spec = candidates[0];
+    if (!isCaip && !upto.asset && uptoSpecs.length > 1) spec = void 0;
+    if (!spec && !isCaip && !upto.asset && uptoSpecs.length === 1) spec = uptoSpecs[0];
+    if (!spec || !spec.upto) {
+      return rejection(
+        "transfer_not_found",
+        `No \`upto\` rail offered for ${upto.network}${upto.asset ? `/${upto.asset}` : ""} (offered: ${uptoSpecs.map((s) => `${s.asset}@${s.net.network}`).join(", ")}).`
+      );
+    }
+    const nonce = upto.payload.permit2Authorization.nonce;
+    if (await claimTx(nonce)) {
+      return rejection("tx_already_used", `Authorization nonce ${nonce} was already redeemed.`);
+    }
+    const accept = buildUptoAccept(spec);
+    const relayer = spec.upto.relayer;
+    let result;
+    try {
+      const rawAmount = await options.upto.settleAmount({
+        maxAmount: spec.amountBase,
+        asset: spec.asset,
+        network: spec.net.network,
+        decimals: spec.decimals,
+        ...upto.raw ? { request: upto.raw } : {}
+      });
+      const settleAmount = resolveSettleAmount(rawAmount, spec.amountBase, spec.decimals);
+      if (settleAmount === null) {
+        await settleTx(nonce, false);
+        return rejection(
+          "upto_settle_exceeds_max",
+          `The settleAmount callback returned an unparseable amount (${String(rawAmount)}). Return a bigint, a raw/"NN%"/"$X" string, or 0.`
+        );
+      }
+      result = await spec.net.settleUptoSelf({ relayer, payload: upto.payload, accept, settleAmount });
+    } catch (err) {
+      await settleTx(nonce, false);
+      if (err instanceof _chunkMWBT7MCEcjs.SettlementError) throw err;
+      return rejection(
+        "tx_reverted",
+        `upto: metering/settle failed (${err instanceof Error ? err.message : String(err)}).`
+      );
+    }
+    if (!result.ok) {
+      await settleTx(nonce, false);
+      return rejection(result.error, result.detail);
+    }
+    await settleTx(nonce, true);
+    await deliverOnPaid(spec, result.receipt);
+    return await buildPaidResult(spec, result.receipt);
   }
   async function verify(paymentSignature) {
-    const result = await resolveVerdict(paymentSignature);
+    const raw = normaliseHeader(paymentSignature);
+    const result = await resolveVerdictObject(raw === void 0 ? void 0 : decodeBase64Json(raw));
     if (result.kind === "invalid") await deliverOnFailed(result);
     return result;
   }
-  async function resolveVerdict(paymentSignature) {
-    const raw = normaliseHeader(paymentSignature);
-    if (!raw) return asChallenge();
-    const sig = parseSignatureHeader(raw);
+  async function verifyObject(payload) {
+    const result = await resolveVerdictObject(payload);
+    if (result.kind === "invalid") await deliverOnFailed(result);
+    return result;
+  }
+  async function resolveVerdictObject(obj) {
+    if (obj === void 0 || obj === null) return asChallenge();
+    const sig = parseSignatureObject(obj);
     if (sig && sig.accepted && typeof sig.accepted.network === "string" && typeof sig.accepted.asset === "string") {
       return verifyOnchainProof(sig);
     }
-    const exact = parseExactPaymentHeader(raw);
+    const upto = parseUptoObject(obj);
+    if (upto) return verifyUpto(upto);
+    const exact = parseExactObject(obj);
     if (exact) return verifyExact(exact);
     return asChallenge();
   }
-  return { challenge, verify, describe, landingPage };
+  return { challenge, verify, verifyObject, describe, landingPage };
 }
 function requirePayment(options) {
+  if (options.upto) {
+    throw new (_class3 = class extends _chunkMWBT7MCEcjs.PipRailError {constructor(...args2) { super(...args2); _class3.prototype.__init7.call(this); }
+      __init7() {this.code = "UNSUPPORTED_SCHEME"}
+    }, _class3)(
+      "requirePayment: the 'upto' (metered) rail is unsupported through the Express middleware \u2014 it settles before the route handler serves, so metered usage is unknown at settle time. Call gate.verify() directly (createPaymentGate) and meter inside settleAmount; see docs/accepting-payments/upto-rail-seller.md."
+    );
+  }
   const gate = createPaymentGate(options);
   return async (req, res, next) => {
     let result;
     try {
       result = await gate.verify(_nullishCoalesce(req.headers[HEADER_SIGNATURE], () => ( req.headers[HEADER_SIGNATURE_V1])));
     } catch (err) {
-      if (err instanceof _chunkVPENSVOIcjs.SettlementError) {
+      if (err instanceof _chunkMWBT7MCEcjs.SettlementError) {
         res.status(502);
         res.json({
           x402Version: 2,
@@ -5813,7 +7364,7 @@ function isRetryableStatus(status) {
 }
 var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
 async function signBody(secret, body) {
-  const subtle = _optionalChain([globalThis, 'access', _89 => _89.crypto, 'optionalAccess', _90 => _90.subtle]);
+  const subtle = _optionalChain([globalThis, 'access', _129 => _129.crypto, 'optionalAccess', _130 => _130.subtle]);
   if (!subtle) return null;
   try {
     const enc = new TextEncoder();
@@ -5823,7 +7374,7 @@ async function signBody(secret, body) {
     const sig = await subtle.sign("HMAC", key, enc.encode(body));
     const hex = Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
     return `sha256=${hex}`;
-  } catch (e43) {
+  } catch (e57) {
     return null;
   }
 }
@@ -5883,8 +7434,8 @@ async function deliverReceipt(receipt, options) {
     const retryable = status === void 0 ? true : isRetryableStatus(status);
     const willRetry = !ok && retryable && attempt < maxAttempts;
     try {
-      _optionalChain([onAttempt, 'optionalCall', _91 => _91({ attempt, ok, ...status !== void 0 ? { status } : {}, ...error ? { error } : {}, willRetry })]);
-    } catch (e44) {
+      _optionalChain([onAttempt, 'optionalCall', _131 => _131({ attempt, ok, ...status !== void 0 ? { status } : {}, ...error ? { error } : {}, willRetry })]);
+    } catch (e58) {
     }
     if (ok) return { delivered: true, attempts: attempt, status };
     if (!willRetry) {
@@ -5905,6 +7456,277 @@ async function deliverReceipt(receipt, options) {
   };
 }
 
+// src/transports/a2a.ts
+var A2A_X402_EXTENSION_URI_V01 = "https://github.com/google-a2a/a2a-x402/v0.1";
+var A2A_X402_EXTENSION_URI_V02 = "https://github.com/google-agentic-commerce/a2a-x402/blob/main/spec/v0.2";
+var A2A_STATUS_KEY = "x402.payment.status";
+var A2A_REQUIRED_KEY = "x402.payment.required";
+var A2A_PAYLOAD_KEY = "x402.payment.payload";
+var A2A_RECEIPTS_KEY = "x402.payment.receipts";
+var A2A_ERROR_KEY = "x402.payment.error";
+var A2A_EXTENSIONS_HEADER = "X-A2A-Extensions";
+var MAX_TASK_RECEIPTS = 64;
+var VERIFY_CODE_TO_A2A_ERROR = {
+  payment_expired: "EXPIRED_PAYMENT",
+  tx_already_used: "DUPLICATE_NONCE",
+  amount_too_low: "INVALID_AMOUNT",
+  upto_settle_exceeds_max: "INVALID_AMOUNT",
+  signature_invalid: "INVALID_SIGNATURE",
+  transfer_not_found: "INVALID_AMOUNT",
+  wrong_recipient: "INVALID_AMOUNT",
+  tx_reverted: "SETTLEMENT_FAILED",
+  tx_not_found: "EXPIRED_PAYMENT",
+  insufficient_confirmations: "EXPIRED_PAYMENT",
+  no_meta: "INVALID_SIGNATURE",
+  // The settlement-side throw code the handler emits for a SettlementError (the merchant's
+  // relayer/facilitator never moved funds) — maps to the spec's SETTLEMENT_FAILED.
+  settlement_failed: "SETTLEMENT_FAILED"
+};
+function toA2AErrorCode(code) {
+  return _nullishCoalesce(VERIFY_CODE_TO_A2A_ERROR[code], () => ( code));
+}
+function toA2APaymentRequired(taskId, challenge, parts) {
+  const metadata = {
+    [A2A_STATUS_KEY]: "payment-required",
+    [A2A_REQUIRED_KEY]: challenge
+  };
+  return {
+    kind: "task",
+    id: taskId,
+    status: {
+      state: "input-required",
+      message: { kind: "message", role: "agent", taskId, ...parts ? { parts } : {}, metadata }
+    }
+  };
+}
+function toA2APaymentReceipts(receipts) {
+  return { [A2A_RECEIPTS_KEY]: receipts };
+}
+function toA2APaymentFailed(code, detail, receipts = [], network) {
+  const entry = {
+    success: false,
+    transaction: "",
+    ...network ? { network } : {},
+    errorReason: `${code}: ${detail}`
+  };
+  return {
+    [A2A_STATUS_KEY]: "payment-failed",
+    [A2A_ERROR_KEY]: toA2AErrorCode(code),
+    [A2A_RECEIPTS_KEY]: [...receipts, entry]
+  };
+}
+function fromA2APaymentRequired(task) {
+  const meta = _optionalChain([task, 'access', _132 => _132.status, 'optionalAccess', _133 => _133.message, 'optionalAccess', _134 => _134.metadata]);
+  const required = _optionalChain([meta, 'optionalAccess', _135 => _135[A2A_REQUIRED_KEY]]);
+  if (!required || typeof required !== "object") return null;
+  return required;
+}
+function fromA2APaymentPayload(message) {
+  const raw = _optionalChain([message, 'access', _136 => _136.metadata, 'optionalAccess', _137 => _137[A2A_PAYLOAD_KEY]]);
+  if (raw === void 0 || raw === null) return null;
+  return { raw, taskId: _nullishCoalesce(message.taskId, () => ( "")) };
+}
+function defaultTaskStore() {
+  const map = /* @__PURE__ */ new Map();
+  function prune(now) {
+    for (const [key, { expiry }] of map) {
+      if (expiry > now) break;
+      map.delete(key);
+    }
+  }
+  return {
+    get(taskId) {
+      const now = Date.now();
+      prune(now);
+      const hit = map.get(taskId);
+      return hit && hit.expiry > now ? hit.record : void 0;
+    },
+    set(taskId, value, ttlMs) {
+      const now = Date.now();
+      prune(now);
+      map.delete(taskId);
+      map.set(taskId, { record: value, expiry: now + ttlMs });
+    }
+  };
+}
+function createA2APaymentHandler(options) {
+  const gate = _nullishCoalesce(options.gate, () => ( createPaymentGate(options)));
+  const maxTimeoutSeconds = _nullishCoalesce(options.maxTimeoutSeconds, () => ( 600));
+  const ttlMs = _nullishCoalesce(options.taskTtlMs, () => ( maxTimeoutSeconds * 1e3));
+  const store = _nullishCoalesce(options.taskStore, () => ( defaultTaskStore()));
+  function appendReceipt(taskId, entry) {
+    const prior = _nullishCoalesce(_optionalChain([store, 'access', _138 => _138.get, 'call', _139 => _139(taskId), 'optionalAccess', _140 => _140.receipts]), () => ( []));
+    const isDup = "success" in entry && entry.success === true && prior.some((r) => "transaction" in r && r.transaction === entry.transaction);
+    const next = isDup ? prior : [...prior, entry];
+    const receipts = next.length > MAX_TASK_RECEIPTS ? next.slice(-MAX_TASK_RECEIPTS) : next;
+    store.set(taskId, { receipts }, ttlMs);
+    return receipts;
+  }
+  function completedTask(taskId, receipts, artifacts, status = "payment-completed") {
+    const metadata = { [A2A_STATUS_KEY]: status, ...toA2APaymentReceipts(receipts) };
+    return {
+      kind: "task",
+      id: taskId,
+      status: { state: "completed", message: { kind: "message", role: "agent", taskId, metadata } },
+      ...artifacts.length > 0 ? { artifacts } : {}
+    };
+  }
+  function reChallengeTask(taskId, result, attempted) {
+    if (result.kind !== "invalid") {
+      const metadata2 = {
+        [A2A_STATUS_KEY]: "payment-required",
+        [A2A_REQUIRED_KEY]: result.challenge
+      };
+      return {
+        kind: "task",
+        id: taskId,
+        status: { state: "input-required", message: { kind: "message", role: "agent", taskId, metadata: metadata2 } }
+      };
+    }
+    const network = _nullishCoalesce(attempted, () => ( singleNetworkOf(result.challenge)));
+    const receipts = appendReceiptFailed(taskId, result.error, result.detail, network);
+    const metadata = {
+      [A2A_STATUS_KEY]: "payment-rejected",
+      [A2A_ERROR_KEY]: toA2AErrorCode(result.error),
+      [A2A_REQUIRED_KEY]: result.challenge,
+      ...toA2APaymentReceipts(receipts)
+    };
+    return {
+      kind: "task",
+      id: taskId,
+      status: { state: "input-required", message: { kind: "message", role: "agent", taskId, metadata } }
+    };
+  }
+  function failedTask(taskId, code, detail, network) {
+    const receipts = appendReceiptFailed(taskId, code, detail, network);
+    const metadata = {
+      [A2A_STATUS_KEY]: "payment-failed",
+      [A2A_ERROR_KEY]: toA2AErrorCode(code),
+      ...toA2APaymentReceipts(receipts)
+    };
+    return {
+      kind: "task",
+      id: taskId,
+      status: { state: "failed", message: { kind: "message", role: "agent", taskId, metadata } }
+    };
+  }
+  function appendReceiptFailed(taskId, code, detail, network) {
+    return appendReceipt(taskId, {
+      success: false,
+      transaction: "",
+      ...network ? { network } : {},
+      errorReason: `${code}: ${detail}`
+    });
+  }
+  async function handleMessage(message, taskId) {
+    const id = _nullishCoalesce(_nullishCoalesce(taskId, () => ( message.taskId)), () => ( newTaskId()));
+    const inbound = fromA2APaymentPayload(message);
+    if (!inbound) {
+      const { challenge } = await gate.challenge(resourceUrlFromMessage(message));
+      store.set(id, { receipts: [] }, ttlMs);
+      return toA2APaymentRequired(id, challenge);
+    }
+    const attempted = networkFromPayload(inbound.raw);
+    let result;
+    try {
+      result = await gate.verifyObject(inbound.raw);
+    } catch (err) {
+      if (err instanceof _chunkMWBT7MCEcjs.SettlementError) {
+        return failedTask(id, "settlement_failed", err.message, attempted);
+      }
+      const detail = err instanceof Error ? err.message : String(err);
+      return failedTask(id, "tx_reverted", detail, attempted);
+    }
+    switch (result.kind) {
+      case "challenge":
+        return reChallengeTask(id, result, attempted);
+      case "invalid":
+        return reChallengeTask(id, result, attempted);
+      case "paid": {
+        const receipts = appendReceipt(id, result.receipt);
+        let artifacts = [];
+        if (options.fulfill) {
+          try {
+            artifacts = await _asyncNullishCoalesce(await options.fulfill({ taskId: id, receipt: result.receipt, message }), async () => ( []));
+          } catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            const annotation = {
+              name: "fulfillment-error",
+              metadata: { "x402.fulfillment.error": detail, "x402.fulfillment.settled": true },
+              parts: [{ kind: "text", text: `Payment settled, but serving the result failed: ${detail}` }]
+            };
+            return completedTask(id, receipts, [annotation]);
+          }
+        }
+        return completedTask(id, receipts, artifacts);
+      }
+    }
+  }
+  function agentCardExtension(opts) {
+    const uri = _optionalChain([opts, 'optionalAccess', _141 => _141.version]) === "v0.2" ? A2A_X402_EXTENSION_URI_V02 : A2A_X402_EXTENSION_URI_V01;
+    return {
+      uri,
+      description: "Supports payments using the x402 protocol for on-chain settlement.",
+      ..._optionalChain([opts, 'optionalAccess', _142 => _142.required]) ? { required: true } : {}
+    };
+  }
+  return { handleMessage, agentCardExtension, gate };
+}
+function singleNetworkOf(challenge) {
+  const nets = new Set((_nullishCoalesce(challenge.accepts, () => ( []))).map((a) => a.network).filter(Boolean));
+  return nets.size === 1 ? [...nets][0] : void 0;
+}
+function networkFromPayload(raw) {
+  const v = raw;
+  if (v && typeof _optionalChain([v, 'access', _143 => _143.accepted, 'optionalAccess', _144 => _144.network]) === "string") return v.accepted.network;
+  if (v && typeof v.network === "string") return v.network;
+  return void 0;
+}
+function newTaskId() {
+  return `task-${globalThis.crypto.randomUUID()}`;
+}
+function resourceUrlFromMessage(message) {
+  for (const part of _nullishCoalesce(message.parts, () => ( []))) {
+    const data = part.data;
+    if (data && typeof data.url === "string") return data.url;
+  }
+  return "";
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -6003,4 +7825,4 @@ async function deliverReceipt(receipt, options) {
 
 
 
-exports.BRAND = BRAND; exports.CHAINS = CHAINS; exports.ConfirmationTimeoutError = _chunkVPENSVOIcjs.ConfirmationTimeoutError; exports.DIRECTORY_INFO = DIRECTORY_INFO; exports.EIP3009_TYPES = EIP3009_TYPES; exports.EXACT_NETWORK_SLUGS = EXACT_NETWORK_SLUGS; exports.GENERATOR = GENERATOR; exports.HEADER_REQUIRED = HEADER_REQUIRED; exports.HEADER_RESPONSE = HEADER_RESPONSE; exports.HEADER_RESPONSE_V1 = HEADER_RESPONSE_V1; exports.HEADER_SIGNATURE = HEADER_SIGNATURE; exports.HEADER_SIGNATURE_V1 = HEADER_SIGNATURE_V1; exports.InsufficientFundsError = _chunkVPENSVOIcjs.InsufficientFundsError; exports.InvalidEnvelopeError = _chunkVPENSVOIcjs.InvalidEnvelopeError; exports.KNOWN_FACILITATORS = KNOWN_FACILITATORS; exports.MaxRetriesExceededError = _chunkVPENSVOIcjs.MaxRetriesExceededError; exports.MissingDriverError = _chunkVPENSVOIcjs.MissingDriverError; exports.MultiChainPayer = MultiChainPayer; exports.NoCompatibleAcceptError = _chunkVPENSVOIcjs.NoCompatibleAcceptError; exports.NonReplayableBodyError = _chunkVPENSVOIcjs.NonReplayableBodyError; exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS; exports.PERMIT2_PROXY_CHAIN_IDS = PERMIT2_PROXY_CHAIN_IDS; exports.PERMIT2_WITNESS_TYPES = PERMIT2_WITNESS_TYPES; exports.PIPRAIL_AGENT_GUIDE = PIPRAIL_AGENT_GUIDE; exports.POWERED_BY = POWERED_BY; exports.PaymentDeclinedError = _chunkVPENSVOIcjs.PaymentDeclinedError; exports.PaymentTimeoutError = _chunkVPENSVOIcjs.PaymentTimeoutError; exports.PipRailClient = PipRailClient; exports.PipRailError = _chunkVPENSVOIcjs.PipRailError; exports.REGISTER_ATTRIBUTION = REGISTER_ATTRIBUTION; exports.RecipientNotReadyError = _chunkVPENSVOIcjs.RecipientNotReadyError; exports.SettlementError = _chunkVPENSVOIcjs.SettlementError; exports.UnknownTokenError = _chunkVPENSVOIcjs.UnknownTokenError; exports.UnsupportedNetworkError = _chunkVPENSVOIcjs.UnsupportedNetworkError; exports.UnsupportedSchemeError = _chunkVPENSVOIcjs.UnsupportedSchemeError; exports.WalletRequiredError = _chunkVPENSVOIcjs.WalletRequiredError; exports.WrongChainError = _chunkVPENSVOIcjs.WrongChainError; exports.WrongFamilyError = _chunkVPENSVOIcjs.WrongFamilyError; exports.X402_EXACT_PERMIT2_PROXY = X402_EXACT_PERMIT2_PROXY; exports.agentGuide = agentGuide; exports.appendAttribution = appendAttribution; exports.appendKeywords = appendKeywords; exports.buildBazaarExtension = buildBazaarExtension; exports.buildChallengeHeader = buildChallengeHeader; exports.buildEndpointInfo = buildEndpointInfo; exports.buildExactAuthorization = buildExactAuthorization; exports.buildExactSignatureHeader = buildExactSignatureHeader; exports.buildOpenApi = buildOpenApi; exports.buildReceiptHeader = buildReceiptHeader; exports.buildSelfDescription = buildSelfDescription; exports.buildSignatureHeader = buildSignatureHeader; exports.buildWellKnownX402 = buildWellKnownX402; exports.buildX402DnsTxt = buildX402DnsTxt; exports.chainIdForExactNetwork = chainIdForExactNetwork; exports.claim402IndexDomain = claim402IndexDomain; exports.classifyChallenge = classifyChallenge; exports.createPaymentGate = createPaymentGate; exports.decorateOutcome = decorateOutcome; exports.deliverReceipt = deliverReceipt; exports.describeChallenge = describeChallenge; exports.discoveryHeaders = discoveryHeaders; exports.eip3009Abi = eip3009Abi; exports.encodeXPaymentHeader = encodeXPaymentHeader; exports.evaluatePolicy = evaluatePolicy; exports.explainDecline = explainDecline; exports.facilitatorCoverage = facilitatorCoverage; exports.fetchAcross = fetchAcross; exports.firstKeylessFacilitator = firstKeylessFacilitator; exports.formatSpendReport = formatSpendReport; exports.getDirectoryInfo = getDirectoryInfo; exports.isPermit2ProxyChain = isPermit2ProxyChain; exports.knownFacilitatorsFor = knownFacilitatorsFor; exports.normalizeNetwork = normalizeNetwork; exports.parseChallenge = parseChallenge; exports.parseExactPaymentHeader = parseExactPaymentHeader; exports.parseExactRequirements = parseExactRequirements; exports.parseFacilitatorSupported = parseFacilitatorSupported; exports.parseReceipt = parseReceipt; exports.parseSettleResponse = parseSettleResponse; exports.parseSignatureHeader = parseSignatureHeader; exports.paymentTools = paymentTools; exports.pickAccept = pickAccept; exports.planAcross = planAcross; exports.rankResources = rankResources; exports.readExactDomain = readExactDomain; exports.register402Index = register402Index; exports.registerDriver = registerDriver; exports.registerX402Scan = registerX402Scan; exports.renderLandingPage = renderLandingPage; exports.requirePayment = requirePayment; exports.resolveChain = resolveChain; exports.scoreResource = scoreResource; exports.searchOpenIndexes = searchOpenIndexes; exports.settleViaFacilitator = settleViaFacilitator; exports.summarizePlan = summarizePlan; exports.toInsufficientFundsError = _chunkVPENSVOIcjs.toInsufficientFundsError; exports.toInvalidBody = toInvalidBody; exports.verify402IndexDomain = verify402IndexDomain;
+exports.A2A_ERROR_KEY = A2A_ERROR_KEY; exports.A2A_EXTENSIONS_HEADER = A2A_EXTENSIONS_HEADER; exports.A2A_PAYLOAD_KEY = A2A_PAYLOAD_KEY; exports.A2A_RECEIPTS_KEY = A2A_RECEIPTS_KEY; exports.A2A_REQUIRED_KEY = A2A_REQUIRED_KEY; exports.A2A_STATUS_KEY = A2A_STATUS_KEY; exports.A2A_X402_EXTENSION_URI_V01 = A2A_X402_EXTENSION_URI_V01; exports.A2A_X402_EXTENSION_URI_V02 = A2A_X402_EXTENSION_URI_V02; exports.BRAND = BRAND; exports.BUILTIN_DENOMS = BUILTIN_DENOMS; exports.CHAINS = CHAINS; exports.ConfirmationTimeoutError = _chunkMWBT7MCEcjs.ConfirmationTimeoutError; exports.DENOM_PRECISION = DENOM_PRECISION; exports.DIRECTORY_INFO = DIRECTORY_INFO; exports.EIP3009_TYPES = EIP3009_TYPES; exports.EXACT_NETWORK_SLUGS = EXACT_NETWORK_SLUGS; exports.EXT_OFFER_RECEIPT = EXT_OFFER_RECEIPT; exports.GENERATOR = GENERATOR; exports.HEADER_REQUIRED = HEADER_REQUIRED; exports.HEADER_RESPONSE = HEADER_RESPONSE; exports.HEADER_RESPONSE_V1 = HEADER_RESPONSE_V1; exports.HEADER_SIGNATURE = HEADER_SIGNATURE; exports.HEADER_SIGNATURE_V1 = HEADER_SIGNATURE_V1; exports.InsufficientFundsError = _chunkMWBT7MCEcjs.InsufficientFundsError; exports.InvalidEnvelopeError = _chunkMWBT7MCEcjs.InvalidEnvelopeError; exports.KNOWN_FACILITATORS = KNOWN_FACILITATORS; exports.MaxRetriesExceededError = _chunkMWBT7MCEcjs.MaxRetriesExceededError; exports.MissingDriverError = _chunkMWBT7MCEcjs.MissingDriverError; exports.MultiChainPayer = MultiChainPayer; exports.NoCompatibleAcceptError = _chunkMWBT7MCEcjs.NoCompatibleAcceptError; exports.NonReplayableBodyError = _chunkMWBT7MCEcjs.NonReplayableBodyError; exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS; exports.PERMIT2_PROXY_CHAIN_IDS = PERMIT2_PROXY_CHAIN_IDS; exports.PERMIT2_UPTO_WITNESS_TYPES = PERMIT2_UPTO_WITNESS_TYPES; exports.PERMIT2_WITNESS_TYPES = PERMIT2_WITNESS_TYPES; exports.PIPRAIL_AGENT_GUIDE = PIPRAIL_AGENT_GUIDE; exports.POWERED_BY = POWERED_BY; exports.PaymentDeclinedError = _chunkMWBT7MCEcjs.PaymentDeclinedError; exports.PaymentTimeoutError = _chunkMWBT7MCEcjs.PaymentTimeoutError; exports.PipRailClient = PipRailClient; exports.PipRailError = _chunkMWBT7MCEcjs.PipRailError; exports.REGISTER_ATTRIBUTION = REGISTER_ATTRIBUTION; exports.RecipientNotReadyError = _chunkMWBT7MCEcjs.RecipientNotReadyError; exports.SettlementError = _chunkMWBT7MCEcjs.SettlementError; exports.SpendLedger = SpendLedger; exports.UPTO_PROXY_CHAIN_IDS = UPTO_PROXY_CHAIN_IDS; exports.UnknownTokenError = _chunkMWBT7MCEcjs.UnknownTokenError; exports.UnsupportedNetworkError = _chunkMWBT7MCEcjs.UnsupportedNetworkError; exports.UnsupportedSchemeError = _chunkMWBT7MCEcjs.UnsupportedSchemeError; exports.VERIFY_CODE_TO_A2A_ERROR = VERIFY_CODE_TO_A2A_ERROR; exports.WalletRequiredError = _chunkMWBT7MCEcjs.WalletRequiredError; exports.WrongChainError = _chunkMWBT7MCEcjs.WrongChainError; exports.WrongFamilyError = _chunkMWBT7MCEcjs.WrongFamilyError; exports.X402_EXACT_PERMIT2_PROXY = X402_EXACT_PERMIT2_PROXY; exports.X402_UPTO_PERMIT2_PROXY = X402_UPTO_PERMIT2_PROXY; exports.agentGuide = agentGuide; exports.appendAttribution = appendAttribution; exports.appendKeywords = appendKeywords; exports.buildBazaarExtension = buildBazaarExtension; exports.buildChallengeHeader = buildChallengeHeader; exports.buildEndpointInfo = buildEndpointInfo; exports.buildExactAuthorization = buildExactAuthorization; exports.buildExactSignatureHeader = buildExactSignatureHeader; exports.buildOpenApi = buildOpenApi; exports.buildReceiptExtension = buildReceiptExtension; exports.buildReceiptHeader = buildReceiptHeader; exports.buildSelfDescription = buildSelfDescription; exports.buildSignatureHeader = buildSignatureHeader; exports.buildUptoSignatureHeader = buildUptoSignatureHeader; exports.buildWellKnownX402 = buildWellKnownX402; exports.buildX402DnsTxt = buildX402DnsTxt; exports.chainIdForExactNetwork = chainIdForExactNetwork; exports.claim402IndexDomain = claim402IndexDomain; exports.classifyChallenge = classifyChallenge; exports.createA2APaymentHandler = createA2APaymentHandler; exports.createPaymentGate = createPaymentGate; exports.decodeBase64Json = decodeBase64Json; exports.decorateOutcome = decorateOutcome; exports.deliverReceipt = deliverReceipt; exports.denomOf = denomOf; exports.describeChallenge = describeChallenge; exports.discoveryHeaders = discoveryHeaders; exports.eip3009Abi = eip3009Abi; exports.encodeXPaymentHeader = encodeXPaymentHeader; exports.evaluatePolicy = evaluatePolicy; exports.explainDecline = explainDecline; exports.facilitatorCoverage = facilitatorCoverage; exports.fetchAcross = fetchAcross; exports.firstKeylessFacilitator = firstKeylessFacilitator; exports.formatSpendReport = formatSpendReport; exports.fromA2APaymentPayload = fromA2APaymentPayload; exports.fromA2APaymentRequired = fromA2APaymentRequired; exports.getDirectoryInfo = getDirectoryInfo; exports.isPermit2ProxyChain = isPermit2ProxyChain; exports.isUptoProxyChain = isUptoProxyChain; exports.knownFacilitatorsFor = knownFacilitatorsFor; exports.memorySpendStore = _chunkO4UQOZ4Zcjs.memorySpendStore; exports.normalizeNetwork = normalizeNetwork; exports.parseChallenge = parseChallenge; exports.parseExactObject = parseExactObject; exports.parseExactPaymentHeader = parseExactPaymentHeader; exports.parseExactRequirements = parseExactRequirements; exports.parseFacilitatorSupported = parseFacilitatorSupported; exports.parseReceipt = parseReceipt; exports.parseReceiptExtension = parseReceiptExtension; exports.parseSettleResponse = parseSettleResponse; exports.parseSignatureHeader = parseSignatureHeader; exports.parseSignatureObject = parseSignatureObject; exports.parseUptoObject = parseUptoObject; exports.parseUptoPaymentHeader = parseUptoPaymentHeader; exports.paymentTools = paymentTools; exports.pickAccept = pickAccept; exports.planAcross = planAcross; exports.rankResources = rankResources; exports.readExactDomain = readExactDomain; exports.register402Index = register402Index; exports.registerDriver = registerDriver; exports.registerX402Scan = registerX402Scan; exports.renderLandingPage = renderLandingPage; exports.requirePayment = requirePayment; exports.resolveChain = resolveChain; exports.scoreResource = scoreResource; exports.searchOpenIndexes = searchOpenIndexes; exports.settleViaFacilitator = settleViaFacilitator; exports.summarizePlan = summarizePlan; exports.toA2AErrorCode = toA2AErrorCode; exports.toA2APaymentFailed = toA2APaymentFailed; exports.toA2APaymentReceipts = toA2APaymentReceipts; exports.toA2APaymentRequired = toA2APaymentRequired; exports.toInsufficientFundsError = _chunkMWBT7MCEcjs.toInsufficientFundsError; exports.toInvalidBody = toInvalidBody; exports.verify402IndexDomain = verify402IndexDomain;