@agentcash/router 1.7.0 → 1.8.0

package/dist/index.cjs

@@ -67,6 +67,9 @@ function getConfiguredX402Accepts(config) {
 function getConfiguredX402Networks(config) {
   return [...new Set(getConfiguredX402Accepts(config).map((accept) => accept.network))];
 }
+function selectRouteAccepts(accepts, routeEntry) {
+  return routeEntry.billing === "upto" ? accepts.filter((accept) => accept.scheme === "upto") : accepts.filter((accept) => (accept.scheme ?? "exact") !== "upto");
+}
 async function resolveX402Accepts(request, routeEntry, accepts, fallbackPayTo, body) {
   return Promise.all(
     accepts.map(async (accept) => ({
@@ -264,12 +267,148 @@ var init_facilitators = __esm({
   }
 });
 
+// src/kv-store/facilitator-supported.ts
+function withCachedSupported(inner, options = {}) {
+  const { kv, cacheKey, ttlSeconds = FACILITATOR_SUPPORTED_TTL_SECONDS, fallback } = options;
+  const kvKey = kv && cacheKey ? `${FACILITATOR_SUPPORTED_KV_PREFIX}${cacheKey}` : void 0;
+  let inflight;
+  return {
+    verify: inner.verify.bind(inner),
+    settle: inner.settle.bind(inner),
+    getSupported: () => {
+      if (inflight) return inflight;
+      const attempt = fetchSupported(inner, kv, kvKey, ttlSeconds, fallback);
+      inflight = attempt;
+      attempt.catch(() => {
+        if (inflight === attempt) inflight = void 0;
+      });
+      return attempt;
+    }
+  };
+}
+async function fetchSupported(inner, kv, kvKey, ttlSeconds, fallback) {
+  if (kv && kvKey) {
+    const cached = await readKvCache(kv, kvKey);
+    if (cached) return cached;
+  }
+  const fresh = await tryFetchLive(inner, fallback);
+  if (fresh === null) return fallback();
+  if (kv && kvKey) await writeKvCache(kv, kvKey, fresh, ttlSeconds);
+  return fresh;
+}
+async function tryFetchLive(inner, fallback) {
+  try {
+    return await inner.getSupported();
+  } catch (err) {
+    if (!fallback) throw err;
+    console.warn(
+      `[x402] facilitator /supported failed, using hardcoded baseline: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+async function readKvCache(kv, key) {
+  try {
+    const cached = await kv.get(key);
+    return isSupportedResponse(cached) ? cached : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function writeKvCache(kv, key, value, ttlSeconds) {
+  try {
+    await kv.setNxEx(key, value, ttlSeconds);
+  } catch {
+  }
+}
+function isSupportedResponse(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.kinds);
+}
+var FACILITATOR_SUPPORTED_TTL_SECONDS, FACILITATOR_SUPPORTED_KV_PREFIX;
+var init_facilitator_supported = __esm({
+  "src/kv-store/facilitator-supported.ts"() {
+    "use strict";
+    FACILITATOR_SUPPORTED_TTL_SECONDS = 60 * 60;
+    FACILITATOR_SUPPORTED_KV_PREFIX = "x402:facilitator-supported:";
+  }
+});
+
+// src/protocols/x402/facilitator-clients.ts
+function createFacilitatorClients(facilitatorsByNetwork, HTTPFacilitatorClient, kvStore) {
+  return getResolvedX402FacilitatorGroups(facilitatorsByNetwork).map((group) => {
+    const inner = new HTTPFacilitatorClient(group.config);
+    const kinds = buildSupportedKinds(group);
+    const baseline = () => ({
+      kinds,
+      extensions: [],
+      signers: {}
+    });
+    if (group.family === "solana") {
+      return hardcodedSupportedClient(inner, baseline);
+    }
+    const cached = withCachedSupported(inner, {
+      kv: kvStore,
+      cacheKey: group.config.url,
+      fallback: baseline
+    });
+    return withScopedKinds(cached, kinds);
+  });
+}
+function hardcodedSupportedClient(inner, build) {
+  return {
+    verify: inner.verify.bind(inner),
+    settle: inner.settle.bind(inner),
+    getSupported: async () => build()
+  };
+}
+function withScopedKinds(client, kinds) {
+  return {
+    verify: client.verify.bind(client),
+    settle: client.settle.bind(client),
+    getSupported: async () => {
+      const live = await client.getSupported();
+      return { ...live, kinds: mergeKindExtras(kinds, live.kinds) };
+    }
+  };
+}
+function mergeKindExtras(scoped, live) {
+  return scoped.map((kind) => {
+    const match = live.find((l) => l.scheme === kind.scheme && l.network === kind.network);
+    return match?.extra ? { ...kind, extra: { ...kind.extra, ...match.extra } } : kind;
+  });
+}
+function buildSupportedKinds(group) {
+  return group.networks.flatMap((network) => {
+    if (group.family === "solana") {
+      return [
+        {
+          x402Version: 2,
+          scheme: "exact",
+          network,
+          extra: { features: { xSettlementAccountSupported: true } }
+        }
+      ];
+    }
+    return [
+      { x402Version: 2, scheme: "exact", network },
+      { x402Version: 2, scheme: "upto", network }
+    ];
+  });
+}
+var init_facilitator_clients = __esm({
+  "src/protocols/x402/facilitator-clients.ts"() {
+    "use strict";
+    init_facilitator_supported();
+    init_facilitators();
+  }
+});
+
 // src/init/x402-server.ts
 var x402_server_exports = {};
 __export(x402_server_exports, {
   createX402Server: () => createX402Server
 });
-async function createX402Server(config) {
+async function createX402Server(config, kvStore) {
   const { x402ResourceServer, HTTPFacilitatorClient } = await import("@x402/core/server");
   const { registerExactEvmScheme } = await import("@x402/evm/exact/server");
   const { bazaarResourceServerExtension } = await import("@x402/extensions/bazaar");
@@ -283,7 +422,11 @@ async function createX402Server(config) {
   );
   const evmNetworks = filterEvmNetworks(configuredNetworks);
   const svmNetworks = filterSolanaNetworks(configuredNetworks);
-  const facilitatorClients = createFacilitatorClients(facilitatorsByNetwork, HTTPFacilitatorClient);
+  const facilitatorClients = createFacilitatorClients(
+    facilitatorsByNetwork,
+    HTTPFacilitatorClient,
+    kvStore
+  );
   const server = new x402ResourceServer(
     facilitatorClients.length === 1 ? facilitatorClients[0] : facilitatorClients
   );
@@ -307,48 +450,13 @@ async function createX402Server(config) {
     facilitatorsByNetwork
   };
 }
-function createFacilitatorClients(facilitatorsByNetwork, HTTPFacilitatorClient) {
-  const groups = getResolvedX402FacilitatorGroups(facilitatorsByNetwork);
-  return groups.map((group) => {
-    const inner = new HTTPFacilitatorClient(group.config);
-    const kinds = buildSupportedKinds(group);
-    return hardcodedSupportedClient(inner, kinds);
-  });
-}
-function hardcodedSupportedClient(inner, kinds) {
-  return {
-    verify: inner.verify.bind(inner),
-    settle: inner.settle.bind(inner),
-    getSupported: async () => ({ kinds, extensions: [], signers: {} })
-  };
-}
-function buildSupportedKinds(group) {
-  return group.networks.flatMap((network) => {
-    const exactKind = {
-      x402Version: 2,
-      scheme: "exact",
-      network,
-      ...group.family === "solana" ? {
-        extra: {
-          features: {
-            xSettlementAccountSupported: true
-          }
-        }
-      } : {}
-    };
-    const uptoKind = { x402Version: 2, scheme: "upto", network };
-    if (group.family === "evm") {
-      return [exactKind, uptoKind];
-    }
-    return [exactKind, uptoKind];
-  });
-}
 var init_x402_server = __esm({
   "src/init/x402-server.ts"() {
     "use strict";
     init_evm();
     init_solana();
     init_facilitators();
+    init_facilitator_clients();
     init_accepts();
   }
 });
@@ -699,10 +807,7 @@ async function runHandler(ctx, handlerCtx) {
   }
   if (isAsyncIterable(returned) && !isThenable(returned)) {
     return errorResult(
-      new HttpError(
-        `route '${ctx.routeEntry.key}': streaming handlers require .paid({ dynamic: true })`,
-        500
-      )
+      new HttpError(`route '${ctx.routeEntry.key}': streaming handlers require .metered()`, 500)
     );
   }
   let rawResult;
@@ -1069,6 +1174,61 @@ async function runApiKeyOnlyFlow(ctx) {
   return runHandlerOnly(ctx, null, result.account);
 }
 
+// src/pricing/format.ts
+var USDC_DECIMALS = 6;
+var DECIMAL_RE = /^(\d+)(?:\.(\d+))?$/;
+function badDecimal(amount) {
+  return Object.assign(new Error(`'${amount}' is not a valid decimal-dollar string`), {
+    status: 400
+  });
+}
+function decimalToAtomic(amount, decimals = USDC_DECIMALS) {
+  const match = DECIMAL_RE.exec(amount.trim());
+  if (!match) throw badDecimal(amount);
+  const whole = match[1];
+  const fraction = match[2] ?? "";
+  if (fraction.length > decimals) {
+    throw Object.assign(new Error(`Amount '${amount}' exceeds ${decimals} decimal places`), {
+      status: 400
+    });
+  }
+  const normalized = `${whole}${fraction.padEnd(decimals, "0")}`.replace(/^0+(?=\d)/, "");
+  return BigInt(normalized || "0");
+}
+function atomicToDecimal(atomic, decimals = USDC_DECIMALS) {
+  const divisor = 10n ** BigInt(decimals);
+  const whole = atomic / divisor;
+  const fraction = atomic % divisor;
+  if (fraction === 0n) return whole.toString();
+  const fractionStr = fraction.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${whole}.${fractionStr}`;
+}
+function compareDecimals(a, b) {
+  const av = decimalToAtomic(a);
+  const bv = decimalToAtomic(b);
+  if (av < bv) return -1;
+  if (av > bv) return 1;
+  return 0;
+}
+function isPositiveDecimal(value) {
+  try {
+    return decimalToAtomic(value) > 0n;
+  } catch {
+    return false;
+  }
+}
+function multiplyDecimal(decimal, factor) {
+  if (!Number.isFinite(factor) || factor <= 0) return decimal;
+  const [whole, fraction = ""] = decimal.split(".");
+  const scaled = (BigInt(whole + fraction) * BigInt(factor)).toString();
+  const decimals = fraction.length;
+  if (decimals === 0) return scaled;
+  const padded = scaled.padStart(decimals + 1, "0");
+  const intPart = padded.slice(0, padded.length - decimals);
+  const fracPart = padded.slice(padded.length - decimals).replace(/0+$/, "");
+  return fracPart ? `${intPart}.${fracPart}` : intPart;
+}
+
 // src/pricing/dynamic.ts
 var DynamicPricing = class {
   constructor(opts) {
@@ -1080,6 +1240,7 @@ var DynamicPricing = class {
       const raw = await this.opts.fn(body);
       return this.cap(raw, body);
     } catch (err) {
+      if (err instanceof HttpError) throw err;
       this.alert("error", `Pricing function failed: ${msg(err)}`, {
         error: err instanceof Error ? err.stack : String(err),
         body
@@ -1104,9 +1265,13 @@ var DynamicPricing = class {
   }
   cap(raw, body) {
     if (!this.opts.maxPrice) return raw;
-    const n = parseFloat(raw);
-    const max = parseFloat(this.opts.maxPrice);
-    if (!Number.isFinite(n) || n > max) {
+    let overCap;
+    try {
+      overCap = compareDecimals(raw, this.opts.maxPrice) > 0;
+    } catch {
+      overCap = true;
+    }
+    if (overCap) {
       this.alert("warn", `Price ${raw} exceeds maxPrice ${this.opts.maxPrice}, capping`, {
         calculated: raw,
         maxPrice: this.opts.maxPrice,
@@ -1183,7 +1348,7 @@ var TieredPricing = class {
   maxTierPrice() {
     let max = "0";
     for (const tier of Object.values(this.opts.tiers)) {
-      if (parseFloat(tier.price) > parseFloat(max)) max = tier.price;
+      if (compareDecimals(tier.price, max) > 0) max = tier.price;
     }
     return max;
   }
@@ -1598,7 +1763,7 @@ var mppStrategy = {
   async verify(args) {
     const info = readMppCredential(args.request);
     if (!info) return { ok: false, kind: "invalid" };
-    if (args.routeEntry.dynamicPrice) {
+    if (args.routeEntry.billing === "metered") {
       if (!info.sessionAction) return { ok: false, kind: "invalid" };
       return verifySessionMode(args, info);
     }
@@ -1649,7 +1814,7 @@ var mppStrategy = {
   async buildChallenge(args) {
     if (!args.deps.mppx) return {};
     const sessionsConfigured = args.deps.mppSessionConfig && (args.deps.mppx.sessionRequest || args.deps.mppx.sessionStream);
-    if (args.routeEntry.dynamicPrice && sessionsConfigured) {
+    if (args.routeEntry.billing === "metered" && sessionsConfigured) {
       const tickCost = args.routeEntry.tickCost;
       const computedDeposit = tickCost !== void 0 ? multiplyDecimal(tickCost, args.deps.mppSessionConfig.depositMultiplier) : void 0;
       const suggestedDeposit = args.routeEntry.maxPrice ?? computedDeposit ?? args.price;
@@ -1661,17 +1826,6 @@ var mppStrategy = {
     return buildChargeChallenge(args);
   }
 };
-function multiplyDecimal(decimal, factor) {
-  if (!Number.isFinite(factor) || factor <= 0) return decimal;
-  const [whole, fraction = ""] = decimal.split(".");
-  const scaled = (BigInt(whole + fraction) * BigInt(factor)).toString();
-  const decimals = fraction.length;
-  if (decimals === 0) return scaled;
-  const padded = scaled.padStart(decimals + 1, "0");
-  const intPart = padded.slice(0, padded.length - decimals);
-  const fracPart = padded.slice(padded.length - decimals).replace(/0+$/, "");
-  return fracPart ? `${intPart}.${fracPart}` : intPart;
-}
 async function buildChargeChallenge(args) {
   if (!args.deps.mppx) return {};
   try {
@@ -1764,26 +1918,13 @@ function buildCustomRequirement(price, accept) {
   return {
     scheme: accept.scheme,
     network: accept.network,
-    amount: decimalToAtomicUnits(price, accept.decimals ?? 6),
+    amount: decimalToAtomic(price, accept.decimals ?? 6).toString(),
     asset: accept.asset,
     payTo: accept.payTo,
     maxTimeoutSeconds: accept.maxTimeoutSeconds ?? 300,
     extra: accept.extra ?? {}
   };
 }
-function decimalToAtomicUnits(amount, decimals) {
-  const match = /^(?<whole>\d+)(?:\.(?<fraction>\d+))?$/.exec(amount);
-  if (!match?.groups) {
-    throw new Error(`Invalid decimal amount '${amount}'`);
-  }
-  const whole = match.groups.whole;
-  const fraction = match.groups.fraction ?? "";
-  if (fraction.length > decimals) {
-    throw new Error(`Amount '${amount}' exceeds ${decimals} decimal places`);
-  }
-  const normalized = `${whole}${fraction.padEnd(decimals, "0")}`.replace(/^0+(?=\d)/, "");
-  return normalized === "" ? "0" : normalized;
-}
 
 // src/protocols/x402/challenge.ts
 async function buildX402Challenge(opts) {
@@ -1930,7 +2071,7 @@ function tagBareDecimalAsDollars(amount) {
 }
 
 // src/protocols/x402/verify.ts
-var import_types2 = require("@x402/core/types");
+var import_types3 = require("@x402/core/types");
 async function verifyX402Payment(opts) {
   const { server, request, price, accepts, report } = opts;
   const payload = await readPaymentPayload(request);
@@ -1949,7 +2090,7 @@ async function verifyX402Payment(opts) {
   try {
     verify = await server.verifyPayment(payload, matching);
   } catch (err) {
-    if (err instanceof import_types2.VerifyError && err.statusCode >= 400 && err.statusCode < 500) {
+    if (err instanceof import_types3.VerifyError && err.statusCode >= 400 && err.statusCode < 500) {
       return invalidPaymentVerification({
         reason: err.invalidReason ?? "verify_error",
         ...err.invalidMessage ? { message: err.invalidMessage } : {},
@@ -2050,7 +2191,7 @@ async function verifyX402(args) {
   const accepts = await resolveX402Accepts(
     request,
     routeEntry,
-    deps.x402Accepts,
+    selectRouteAccepts(deps.x402Accepts, routeEntry),
     deps.payeeAddress,
     body
   );
@@ -2098,7 +2239,7 @@ async function verifyX402(args) {
 async function settleX402(args) {
   const { response, payment, token, deps, routeEntry, billedAmount, report } = args;
   const { payload, requirements } = token;
-  const override = routeEntry.dynamicPrice ? { amount: billedAmount } : void 0;
+  const override = routeEntry.billing === "exact" ? void 0 : { amount: billedAmount };
   try {
     const settle = await settleX402Payment(deps.x402Server, payload, requirements, override);
     if (!settle.result?.success) {
@@ -2128,7 +2269,7 @@ async function buildX402ChallengeContribution(args) {
   const accepts = await resolveX402Accepts(
     request,
     routeEntry,
-    deps.x402Accepts,
+    selectRouteAccepts(deps.x402Accepts, routeEntry),
     deps.payeeAddress,
     body
   );
@@ -2146,13 +2287,14 @@ async function buildX402ChallengeContribution(args) {
 }
 function reportSettleFailure(report, err, network) {
   const facilitator = err ?? {};
-  report("error", "Settlement failed", {
+  const meta = {
     error: err instanceof Error ? err.message : String(err),
     network,
     errorReason: facilitator.errorReason,
     facilitatorStatus: facilitator.response?.status,
     facilitatorBody: facilitator.response?.data ?? facilitator.response?.body
-  });
+  };
+  report("error", "Settlement failed", meta);
 }
 
 // src/protocols/index.ts
@@ -2175,6 +2317,7 @@ function getAllowedStrategies(allowed) {
 var import_server4 = require("next/server");
 
 // src/pipeline/challenge-extensions.ts
+init_evm();
 async function buildChallengeExtensions(ctx) {
   const { routeEntry } = ctx;
   let extensions;
@@ -2219,6 +2362,21 @@ async function buildChallengeExtensions(ctx) {
     } catch {
     }
   }
+  const hasEvmUpto = ctx.routeEntry.billing === "upto" && ctx.deps.x402Accepts.some((accept) => accept.scheme === "upto" && isEvmNetwork(accept.network));
+  if (hasEvmUpto) {
+    try {
+      const { declareEip2612GasSponsoringExtension } = await import("@x402/extensions");
+      extensions = {
+        ...extensions ?? {},
+        ...declareEip2612GasSponsoringExtension()
+      };
+    } catch (err) {
+      ctx.report(
+        "warn",
+        `EIP-2612 gas-sponsoring declaration failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   return extensions;
 }
 
@@ -2371,31 +2529,7 @@ async function runDynamicChannelMgmtFlow(args) {
   });
 }
 
-// src/pipeline/flows/dynamic/dynamic-invoke.ts
-var import_server6 = require("next/server");
-
-// src/pricing/atomic.ts
-var USDC_DECIMALS = 6;
-function decimalToAtomic(amount) {
-  const m = /^(\d+)(?:\.(\d+))?$/.exec(amount.trim());
-  if (!m) {
-    throw Object.assign(new Error(`'${amount}' is not a valid decimal-dollar string`), {
-      status: 400
-    });
-  }
-  const whole = m[1];
-  const fraction = (m[2] ?? "").slice(0, USDC_DECIMALS).padEnd(USDC_DECIMALS, "0");
-  return BigInt(`${whole}${fraction}`.replace(/^0+(?=\d)/, "") || "0");
-}
-function atomicToDecimal(atomic) {
-  const whole = atomic / 10n ** BigInt(USDC_DECIMALS);
-  const fraction = atomic % 10n ** BigInt(USDC_DECIMALS);
-  if (fraction === 0n) return whole.toString();
-  const fractionStr = fraction.toString().padStart(USDC_DECIMALS, "0").replace(/0+$/, "");
-  return `${whole}.${fractionStr}`;
-}
-
-// src/pricing/charge-context.ts
+// src/pricing/metered-charge.ts
 function createChargeContext(args) {
   const { tickCost, maxPrice, route } = args;
   const tickAtomic = decimalToAtomic(tickCost);
@@ -2430,15 +2564,10 @@ function createChargeContext(args) {
   };
 }
 
-// src/pipeline/flows/dynamic/dynamic-invoke.ts
-async function invokeDynamic(ctx, wallet, account, body, payment) {
-  const streaming = ctx.routeEntry.streaming === true;
-  const chargeContext = streaming ? createChargeContext({
-    tickCost: ctx.routeEntry.tickCost,
-    maxPrice: ctx.routeEntry.maxPrice,
-    route: ctx.routeEntry.key
-  }) : null;
-  const baseHandlerCtx = {
+// src/pipeline/flows/dynamic/dynamic-invoke/shared.ts
+var import_server6 = require("next/server");
+function buildBaseHandlerCtx(ctx, wallet, account, body, payment) {
+  return {
     body,
     query: parseQuery(ctx.request, ctx.routeEntry),
     request: ctx.request,
@@ -2450,12 +2579,41 @@ async function invokeDynamic(ctx, wallet, account, body, payment) {
     alert: ctx.report,
     setVerifiedWallet: (addr) => ctx.pluginCtx.setVerifiedWallet(addr)
   };
+}
+function toResponse(rawResult) {
+  return rawResult instanceof Response ? rawResult : import_server6.NextResponse.json(rawResult);
+}
+function errorResult2(error) {
+  const status = error instanceof HttpError ? error.status : typeof error?.status === "number" ? error.status : 500;
+  const message = error instanceof Error ? error.message : "Internal error";
+  return {
+    kind: "request",
+    response: import_server6.NextResponse.json({ success: false, error: message }, { status }),
+    rawResult: void 0,
+    handlerError: error
+  };
+}
+function isAsyncIterable2(value) {
+  return value != null && typeof value === "object" && Symbol.asyncIterator in value;
+}
+function isThenable2(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+
+// src/pipeline/flows/dynamic/dynamic-invoke/metered-invoke.ts
+async function invokeMetered(ctx, wallet, account, body, payment) {
+  const chargeContext = ctx.routeEntry.streaming ? createChargeContext({
+    tickCost: ctx.routeEntry.tickCost,
+    maxPrice: ctx.routeEntry.maxPrice,
+    route: ctx.routeEntry.key
+  }) : null;
+  const baseHandlerCtx = buildBaseHandlerCtx(ctx, wallet, account, body, payment);
   const handlerCtx = chargeContext !== null ? { ...baseHandlerCtx, charge: chargeContext.charge } : baseHandlerCtx;
   let returned;
   try {
     returned = ctx.handler(handlerCtx);
   } catch (error) {
-    return errorResult2(error, chargeContext);
+    return errorResult2(error);
   }
   if (isAsyncIterable2(returned) && !isThenable2(returned)) {
     if (!chargeContext) {
@@ -2463,41 +2621,80 @@ async function invokeDynamic(ctx, wallet, account, body, payment) {
         new HttpError(
           "route returned an async iterable from a non-streaming handler \u2014 use .stream(async function*(...)) instead of .handler() to opt into streaming",
           500
-        ),
-        null
+        )
       );
     }
-    return {
-      kind: "stream",
-      source: returned,
-      chargeContext
-    };
+    return { kind: "stream", source: returned, chargeContext };
   }
   let rawResult;
   try {
     rawResult = await returned;
   } catch (error) {
-    return errorResult2(error, chargeContext);
+    return errorResult2(error);
   }
-  const response = rawResult instanceof Response ? rawResult : import_server6.NextResponse.json(rawResult);
-  return { kind: "request", response, rawResult };
+  return { kind: "request", response: toResponse(rawResult), rawResult };
 }
-function errorResult2(error, chargeContext) {
-  const status = error instanceof HttpError ? error.status : typeof error?.status === "number" ? error.status : 500;
-  const message = error instanceof Error ? error.message : "Internal error";
-  void chargeContext;
+
+// src/pricing/upto-charge.ts
+function createUptoChargeContext(args) {
+  const { maxPrice, route } = args;
+  const capAtomic = decimalToAtomic(maxPrice);
+  if (capAtomic <= 0n) {
+    throw new Error(`route '${route}': maxPrice '${maxPrice}' must be a positive decimal string`);
+  }
+  let calls = 0;
+  let atomic = 0n;
+  const charge = async (amount) => {
+    const nextAtomic = atomic + decimalToAtomic(amount);
+    if (nextAtomic > capAtomic) {
+      throw Object.assign(
+        new Error(
+          `route '${route}': charge() running total ($${atomicToDecimal(nextAtomic)}) exceeds maxPrice ($${atomicToDecimal(capAtomic)})`
+        ),
+        { status: 400, code: "CHARGE_OVER_CAP" }
+      );
+    }
+    calls += 1;
+    atomic = nextAtomic;
+  };
   return {
-    kind: "request",
-    response: import_server6.NextResponse.json({ success: false, error: message }, { status }),
-    rawResult: void 0,
-    handlerError: error
+    charge,
+    callCount: () => calls,
+    atomicTotal: () => atomic
   };
 }
-function isAsyncIterable2(value) {
-  return value != null && typeof value === "object" && Symbol.asyncIterator in value;
-}
-function isThenable2(value) {
-  return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+
+// src/pipeline/flows/dynamic/dynamic-invoke/upto-invoke.ts
+async function invokeUpto(ctx, wallet, account, body, payment) {
+  const uptoCtx = createUptoChargeContext({
+    maxPrice: ctx.routeEntry.maxPrice,
+    route: ctx.routeEntry.key
+  });
+  const handlerCtx = {
+    ...buildBaseHandlerCtx(ctx, wallet, account, body, payment),
+    charge: uptoCtx.charge
+  };
+  let returned;
+  try {
+    returned = ctx.handler(handlerCtx);
+  } catch (error) {
+    return errorResult2(error);
+  }
+  if (isAsyncIterable2(returned) && !isThenable2(returned)) {
+    return errorResult2(
+      new HttpError(
+        "streaming is not supported on .upTo() routes \u2014 return a value from .handler() instead",
+        500
+      )
+    );
+  }
+  let rawResult;
+  try {
+    rawResult = await returned;
+  } catch (error) {
+    return errorResult2(error);
+  }
+  return { kind: "request", response: toResponse(rawResult), rawResult, uptoContext: uptoCtx };
 }
 
 // src/pipeline/flows/dynamic/dynamic-preflight.ts
@@ -2527,7 +2724,7 @@ async function runDynamicRequestFlow(args) {
   }
   const beforeErr = await runBeforeSettle(ctx, settleScope);
   if (beforeErr) return beforeErr;
-  const billedAmount = routeEntry.tickCost;
+  const billedAmount = computeBilledAmount(routeEntry, result);
   return settleAndFinalizeRequest({
     ctx,
     strategy,
@@ -2545,6 +2742,19 @@ async function runDynamicRequestFlow(args) {
     }
   });
 }
+function computeBilledAmount(routeEntry, result) {
+  if (routeEntry.billing === "upto") {
+    const total = result.uptoContext?.atomicTotal() ?? 0n;
+    if (total <= 0n) {
+      throw new HttpError(
+        `route '${routeEntry.key}': handler did not call charge(amount) \u2014 upto routes must accumulate a non-zero billed amount`,
+        500
+      );
+    }
+    return atomicToDecimal(total);
+  }
+  return routeEntry.tickCost;
+}
 
 // src/pipeline/flows/dynamic/dynamic-stream.ts
 async function runDynamicStreamFlow(args) {
@@ -2617,13 +2827,7 @@ async function runDynamicPaidFlow(ctx) {
     amount: price,
     network: verifyOutcome.payment.network
   });
-  const result = await invokeDynamic(
-    ctx,
-    verifyOutcome.wallet,
-    account,
-    parsedBody,
-    verifyOutcome.payment
-  );
+  const result = await invokeDynamic(ctx, verifyOutcome, account, parsedBody);
   switch (result.kind) {
     case "stream":
       return runDynamicStreamFlow({
@@ -2645,6 +2849,18 @@ async function runDynamicPaidFlow(ctx) {
       });
   }
 }
+async function invokeDynamic(ctx, verifyOutcome, account, parsedBody) {
+  switch (ctx.routeEntry.billing) {
+    case "upto":
+      return invokeUpto(ctx, verifyOutcome.wallet, account, parsedBody, verifyOutcome.payment);
+    case "metered":
+      return invokeMetered(ctx, verifyOutcome.wallet, account, parsedBody, verifyOutcome.payment);
+    case "exact":
+      throw new Error(
+        `route '${ctx.routeEntry.key}': exact billing must not reach the dynamic paid flow`
+      );
+  }
+}
 
 // src/pipeline/flows/static/static-body-and-price.ts
 async function resolveStaticBodyAndPrice(args) {
@@ -2792,19 +3008,27 @@ async function runStaticPaidFlow(ctx) {
 
 // src/pipeline/flows/paid.ts
 async function runPaidFlow(ctx) {
-  const dynamicPrice = ctx.routeEntry.dynamicPrice ?? false;
-  switch (dynamicPrice) {
-    case true:
-      return runDynamicPaidFlow(ctx);
-    case false:
-      return runStaticPaidFlow(ctx);
-  }
+  const handlerCharged = ctx.routeEntry.billing !== "exact";
+  return handlerCharged ? runDynamicPaidFlow(ctx) : runStaticPaidFlow(ctx);
 }
 
 // src/pipeline/flows/siwx-only.ts
 var import_server7 = require("next/server");
 
 // src/kv-store/client.ts
+var BIGINT_SUFFIX = "#__bigint";
+function stringifyValue(value) {
+  return JSON.stringify(
+    value,
+    (_key, v) => typeof v === "bigint" ? `${v.toString()}${BIGINT_SUFFIX}` : v
+  );
+}
+function parseValue(raw) {
+  return JSON.parse(
+    raw,
+    (_key, v) => typeof v === "string" && v.endsWith(BIGINT_SUFFIX) ? BigInt(v.slice(0, -BIGINT_SUFFIX.length)) : v
+  );
+}
 function restKvStore(url, token) {
   const base = url.replace(/\/+$/, "");
   const authHeader = { Authorization: `Bearer ${token}` };
@@ -2826,16 +3050,22 @@ function restKvStore(url, token) {
     const res = await fetch(`${base}/get/${encodeURIComponent(key)}`, { headers: authHeader });
     if (!res.ok) throw new Error(`[kv-store] GET ${key}: ${res.status}`);
     const { result } = await res.json();
-    return result ?? null;
+    if (result == null) return null;
+    if (typeof result !== "string") return result;
+    try {
+      return parseValue(result);
+    } catch {
+      return result;
+    }
   }
   async function set(key, value) {
-    await exec(["SET", key, JSON.stringify(value)]);
+    await exec(["SET", key, stringifyValue(value)]);
   }
   async function del(key) {
     await exec(["DEL", key]);
   }
   async function setNxEx(key, value, ttlSeconds) {
-    const result = await exec(["SET", key, JSON.stringify(value), "EX", ttlSeconds, "NX"]);
+    const result = await exec(["SET", key, stringifyValue(value), "EX", ttlSeconds, "NX"]);
     return result === "OK";
   }
   async function sadd(key, member) {
@@ -3164,142 +3394,148 @@ ${issues}`
 }
 
 // src/builder.ts
-var RouteBuilder = class {
-  /** @internal */
-  _key;
-  /** @internal */
-  _registry;
-  /** @internal */
-  _deps;
-  /** @internal */
-  _authMode = null;
-  /** @internal */
-  _pricing;
-  /** @internal */
-  _siwxEnabled = false;
-  /** @internal */
-  _protocols = ["x402"];
-  /** @internal */
-  _maxPrice;
-  /** @internal */
-  _minPrice;
-  /** @internal */
-  _dynamicPrice = false;
-  /** @internal */
-  _tickCost;
-  /** @internal */
-  _unitType;
-  /** @internal */
-  _payTo;
-  /** @internal */
-  _bodySchema;
-  /** @internal */
-  _querySchema;
-  /** @internal */
-  _outputSchema;
-  /** @internal */
-  _inputExample = void 0;
-  /** @internal */
-  _hasInputExample = false;
-  /** @internal */
-  _outputExample = void 0;
-  /** @internal */
-  _hasOutputExample = false;
-  /** @internal */
-  _description;
-  /** @internal */
-  _path;
-  /** @internal */
-  _method = "POST";
-  /** @internal */
-  _apiKeyResolver;
-  /** @internal */
-  _providerName;
-  /** @internal */
-  _providerConfig;
-  /** @internal */
-  _validateFn;
-  /** @internal */
-  _settlement;
-  /** @internal */
-  _mppInfo;
-  constructor(key, registry, deps) {
-    this._key = key;
-    this._registry = registry;
-    this._deps = deps;
+var RouteBuilder = class _RouteBuilder {
+  #s;
+  constructor(key, registry, deps, defaults) {
+    this.#s = {
+      key,
+      registry,
+      deps,
+      authMode: null,
+      pricing: void 0,
+      siwxEnabled: false,
+      protocols: defaults?.protocols ? [...defaults.protocols] : ["x402"],
+      maxPrice: void 0,
+      minPrice: void 0,
+      billing: "exact",
+      tickCost: void 0,
+      unitType: void 0,
+      payTo: void 0,
+      bodySchema: void 0,
+      querySchema: void 0,
+      outputSchema: void 0,
+      inputExample: void 0,
+      hasInputExample: false,
+      outputExample: void 0,
+      hasOutputExample: false,
+      description: void 0,
+      path: void 0,
+      method: "POST",
+      apiKeyResolver: void 0,
+      providerName: void 0,
+      providerConfig: void 0,
+      validateFn: void 0,
+      settlement: void 0,
+      mppInfo: void 0
+    };
   }
   fork() {
-    const next = Object.create(Object.getPrototypeOf(this));
-    Object.assign(next, this);
-    next._protocols = [...this._protocols];
+    const next = new _RouteBuilder(
+      this.#s.key,
+      this.#s.registry,
+      this.#s.deps
+    );
+    next.#s = { ...this.#s, protocols: [...this.#s.protocols] };
     return next;
   }
-  paid(pricingOrOptions, options) {
-    const { pricing, resolvedOptions } = resolvePaidArgs(this._key, pricingOrOptions, options);
-    if (this._authMode === "unprotected") {
+  paid(arg, options) {
+    return this.applyPaid(normalizePaidArg(this.#s.key, arg, options), "paid");
+  }
+  /**
+   * x402-only handler-computed billing. The handler receives `charge(amount)`
+   * and the request settles once for the accumulated total, capped at
+   * `maxPrice`. Requires an `'upto'` accept on at least one configured network.
+   * Pass a bare string as sugar for `{ maxPrice }`.
+   *
+   * @example
+   * ```ts
+   * router.route('llm')
+   *   .upTo('0.05')
+   *   .body(schema)
+   *   .handler(async ({ body, charge }) => { await charge('0.001'); ... });
+   * ```
+   */
+  upTo(arg) {
+    return this.applyPaid(normalizeUpToArg(this.#s.key, arg), "upTo");
+  }
+  /**
+   * MPP-only per-tick billing. `.handler()` bills exactly `tickCost`;
+   * `.stream()` calls `charge()` (no-arg) per yield, settling per tick up to
+   * `maxPrice`. Requires `RouterConfig.mpp.session`.
+   *
+   * @example
+   * ```ts
+   * router.route('llm/stream')
+   *   .metered({ tickCost: '0.0001', maxPrice: '0.05', unitType: 'token' })
+   *   .stream(async function* ({ charge }) { await charge(); yield 'hi'; });
+   * ```
+   */
+  metered(options) {
+    return this.applyPaid(normalizeMeteredArg(this.#s.key, options), "metered");
+  }
+  applyPaid(normalized, method) {
+    const { pricing, resolvedOptions, billing, tickCost, unitType, maxPrice } = normalized;
+    if (this.#s.authMode === "unprotected") {
       throw new Error(
-        `route '${this._key}': Cannot combine .unprotected() and .paid() on the same route.`
+        `route '${this.#s.key}': Cannot combine .unprotected() and .${method}() on the same route.`
       );
     }
-    if (this._pricing !== void 0) {
+    if (this.#s.pricing !== void 0) {
       throw new Error(
-        `route '${this._key}': Cannot call .paid() more than once on the same route.`
+        `route '${this.#s.key}': Cannot combine .paid(), .upTo(), and .metered() \u2014 pick one pricing mode.`
       );
     }
     const next = this.fork();
-    next._authMode = "paid";
-    next._pricing = pricing;
-    if (resolvedOptions?.protocols) {
-      next._protocols = [...resolvedOptions.protocols];
-    } else if (next._protocols.length === 0) {
-      next._protocols = ["x402"];
-    }
-    if (resolvedOptions?.maxPrice) next._maxPrice = resolvedOptions.maxPrice;
-    if (resolvedOptions?.minPrice) next._minPrice = resolvedOptions.minPrice;
-    if (resolvedOptions?.payTo) next._payTo = resolvedOptions.payTo;
-    if (resolvedOptions?.mpp) next._mppInfo = resolvedOptions.mpp;
-    if (resolvedOptions?.dynamic) next._dynamicPrice = true;
-    if (resolvedOptions?.tickCost) next._tickCost = resolvedOptions.tickCost;
-    if (resolvedOptions?.unitType) next._unitType = resolvedOptions.unitType;
-    if (typeof pricing === "object" && "tiers" in pricing) {
-      if (next._dynamicPrice) {
+    next.#s.authMode = "paid";
+    next.#s.pricing = pricing;
+    if (billing === "upto") {
+      if (resolvedOptions.protocols?.some((p) => p !== "x402")) {
+        throw new Error(
+          `route '${this.#s.key}': .upTo() is x402-only \u2014 remove the conflicting protocols override.`
+        );
+      }
+      next.#s.protocols = ["x402"];
+    } else if (billing === "metered") {
+      if (resolvedOptions.protocols?.some((p) => p !== "mpp")) {
         throw new Error(
-          `route '${this._key}': .paid({ dynamic: true }) is incompatible with tiered pricing`
+          `route '${this.#s.key}': .metered() is MPP-only \u2014 remove the conflicting protocols override.`
         );
       }
+      next.#s.protocols = ["mpp"];
+    } else if (resolvedOptions.protocols) {
+      next.#s.protocols = [...resolvedOptions.protocols];
+    } else if (next.#s.protocols.length === 0) {
+      next.#s.protocols = ["x402"];
+    }
+    if (resolvedOptions.maxPrice) next.#s.maxPrice = resolvedOptions.maxPrice;
+    if (maxPrice) next.#s.maxPrice = maxPrice;
+    if (resolvedOptions.minPrice) next.#s.minPrice = resolvedOptions.minPrice;
+    if (resolvedOptions.payTo) next.#s.payTo = resolvedOptions.payTo;
+    if (resolvedOptions.mpp) next.#s.mppInfo = resolvedOptions.mpp;
+    next.#s.billing = billing;
+    if (tickCost) next.#s.tickCost = tickCost;
+    if (unitType) next.#s.unitType = unitType;
+    if (typeof pricing === "object" && "tiers" in pricing) {
       for (const [tierKey, tierConfig] of Object.entries(pricing.tiers)) {
         if (!tierKey) {
-          throw new Error(`route '${this._key}': tier key cannot be empty`);
+          throw new Error(`route '${this.#s.key}': tier key cannot be empty`);
         }
-        const tierPrice = parseFloat(tierConfig.price);
-        if (isNaN(tierPrice) || tierPrice <= 0) {
+        if (!isPositiveDecimal(tierConfig.price)) {
           throw new Error(
-            `route '${this._key}': tier '${tierKey}' price '${tierConfig.price}' must be a positive decimal string`
+            `route '${this.#s.key}': tier '${tierKey}' price '${tierConfig.price}' must be a positive decimal string`
           );
         }
       }
     }
-    if (resolvedOptions?.maxPrice !== void 0) {
-      const parsed = parseFloat(resolvedOptions.maxPrice);
-      if (isNaN(parsed) || parsed <= 0) {
-        throw new Error(
-          `route '${this._key}': maxPrice '${resolvedOptions.maxPrice}' must be a positive decimal string`
-        );
-      }
-    }
-    if (resolvedOptions?.tickCost !== void 0) {
-      const parsed = parseFloat(resolvedOptions.tickCost);
-      if (isNaN(parsed) || parsed <= 0) {
-        throw new Error(
-          `route '${this._key}': tickCost '${resolvedOptions.tickCost}' must be a positive decimal string`
-        );
-      }
-    }
-    if (next._dynamicPrice && !next._maxPrice) {
-      throw new Error(`route '${this._key}': .paid({ dynamic: true }) requires maxPrice`);
+    if (next.#s.maxPrice !== void 0 && !isPositiveDecimal(next.#s.maxPrice)) {
+      throw new Error(
+        `route '${this.#s.key}': maxPrice '${next.#s.maxPrice}' must be a positive decimal string`
+      );
     }
-    if (next._dynamicPrice && !next._tickCost) {
-      throw new Error(`route '${this._key}': .paid({ dynamic: true }) requires tickCost`);
+    if (next.#s.tickCost !== void 0 && !isPositiveDecimal(next.#s.tickCost)) {
+      throw new Error(
+        `route '${this.#s.key}': tickCost '${next.#s.tickCost}' must be a positive decimal string`
+      );
     }
     return next;
   }
@@ -3314,25 +3550,25 @@ var RouteBuilder = class {
    * ```
    */
   siwx() {
-    if (this._authMode === "unprotected") {
+    if (this.#s.authMode === "unprotected") {
       throw new Error(
-        `route '${this._key}': Cannot combine .unprotected() and .siwx() on the same route.`
+        `route '${this.#s.key}': Cannot combine .unprotected() and .siwx() on the same route.`
       );
     }
-    if (this._apiKeyResolver) {
+    if (this.#s.apiKeyResolver) {
       throw new Error(
-        `route '${this._key}': Combining .siwx() and .apiKey() is not supported on the same route.`
+        `route '${this.#s.key}': Combining .siwx() and .apiKey() is not supported on the same route.`
       );
     }
     const next = this.fork();
-    next._siwxEnabled = true;
-    if (next._authMode === "paid" || next._pricing) {
-      next._authMode = "paid";
-      if (next._protocols.length === 0) next._protocols = ["x402"];
+    next.#s.siwxEnabled = true;
+    if (next.#s.authMode === "paid" || next.#s.pricing) {
+      next.#s.authMode = "paid";
+      if (next.#s.protocols.length === 0) next.#s.protocols = ["x402"];
       return next;
     }
-    next._authMode = "siwx";
-    next._protocols = [];
+    next.#s.authMode = "siwx";
+    next.#s.protocols = [];
     return next;
   }
   /**
@@ -3349,14 +3585,14 @@ var RouteBuilder = class {
    * ```
    */
   apiKey(resolver) {
-    if (this._siwxEnabled) {
+    if (this.#s.siwxEnabled) {
       throw new Error(
-        `route '${this._key}': Combining .apiKey() and .siwx() is not supported on the same route.`
+        `route '${this.#s.key}': Combining .apiKey() and .siwx() is not supported on the same route.`
       );
     }
     const next = this.fork();
-    next._authMode = "apiKey";
-    next._apiKeyResolver = resolver;
+    next.#s.authMode = "apiKey";
+    next.#s.apiKeyResolver = resolver;
     return next;
   }
   /**
@@ -3369,19 +3605,19 @@ var RouteBuilder = class {
    * ```
    */
   unprotected() {
-    if (this._authMode && this._authMode !== "unprotected") {
+    if (this.#s.authMode && this.#s.authMode !== "unprotected") {
       throw new Error(
-        `route '${this._key}': Cannot combine .unprotected() and .${this._authMode}() on the same route.`
+        `route '${this.#s.key}': Cannot combine .unprotected() and .${this.#s.authMode}() on the same route.`
       );
     }
-    if (this._pricing) {
+    if (this.#s.pricing) {
       throw new Error(
-        `route '${this._key}': Cannot combine .unprotected() and .paid() on the same route.`
+        `route '${this.#s.key}': Cannot combine .unprotected() and .paid() on the same route.`
       );
     }
     const next = this.fork();
-    next._authMode = "unprotected";
-    next._protocols = [];
+    next.#s.authMode = "unprotected";
+    next.#s.protocols = [];
     return next;
   }
   /**
@@ -3400,8 +3636,8 @@ var RouteBuilder = class {
    */
   provider(name, config) {
     const next = this.fork();
-    next._providerName = name;
-    next._providerConfig = config ?? {};
+    next.#s.providerName = name;
+    next.#s.providerConfig = config ?? {};
     return next;
   }
   /**
@@ -3416,7 +3652,7 @@ var RouteBuilder = class {
    */
   body(schema) {
     const next = this.fork();
-    next._bodySchema = schema;
+    next.#s.bodySchema = schema;
     return next;
   }
   /**
@@ -3432,8 +3668,8 @@ var RouteBuilder = class {
    */
   query(schema) {
     const next = this.fork();
-    next._querySchema = schema;
-    next._method = "GET";
+    next.#s.querySchema = schema;
+    next.#s.method = "GET";
     return next;
   }
   /**
@@ -3450,7 +3686,7 @@ var RouteBuilder = class {
    */
   output(schema) {
     const next = this.fork();
-    next._outputSchema = schema;
+    next.#s.outputSchema = schema;
     return next;
   }
   /**
@@ -3464,8 +3700,8 @@ var RouteBuilder = class {
    */
   inputExample(example) {
     const next = this.fork();
-    next._inputExample = example;
-    next._hasInputExample = true;
+    next.#s.inputExample = example;
+    next.#s.hasInputExample = true;
     return next;
   }
   /**
@@ -3479,8 +3715,8 @@ var RouteBuilder = class {
    */
   outputExample(example) {
     const next = this.fork();
-    next._outputExample = example;
-    next._hasOutputExample = true;
+    next.#s.outputExample = example;
+    next.#s.hasOutputExample = true;
     return next;
   }
   /**
@@ -3494,7 +3730,7 @@ var RouteBuilder = class {
    */
   description(text) {
     const next = this.fork();
-    next._description = text;
+    next.#s.description = text;
     return next;
   }
   /**
@@ -3508,7 +3744,7 @@ var RouteBuilder = class {
    */
   path(p) {
     const next = this.fork();
-    next._path = p;
+    next.#s.path = p;
     return next;
   }
   /**
@@ -3522,7 +3758,7 @@ var RouteBuilder = class {
    */
   method(m) {
     const next = this.fork();
-    next._method = m;
+    next.#s.method = m;
     return next;
   }
   /**
@@ -3541,7 +3777,7 @@ var RouteBuilder = class {
    */
   validate(fn) {
     const next = this.fork();
-    next._validateFn = fn;
+    next.#s.validateFn = fn;
     return next;
   }
   /**
@@ -3559,7 +3795,7 @@ var RouteBuilder = class {
    */
   settlement(lifecycle) {
     const next = this.fork();
-    next._settlement = lifecycle;
+    next.#s.settlement = lifecycle;
     return next;
   }
   /**
@@ -3582,13 +3818,13 @@ var RouteBuilder = class {
   /**
    * Register a streaming handler (`async function*`) and return the Next.js
    * route function. Each `charge()` call bills one tick (`tickCost` USDC) up
-   * to `maxPrice`; requires `.paid({ dynamic: true, ... })` and MPP session mode.
+   * to `maxPrice`; requires `.metered({ ... })` and MPP session mode.
    *
    * @example
    * ```ts
    * export const POST = router
    *   .route('llm/stream')
-   *   .paid({ dynamic: true, tickCost: '0.0001', unitType: 'token', maxPrice: '0.05' })
+   *   .metered({ tickCost: '0.0001', maxPrice: '0.05', unitType: 'token' })
    *   .body(schema)
    *   .stream(async function* ({ body, charge }) {
    *     for await (const token of streamLLM(body.prompt)) {
@@ -3602,91 +3838,144 @@ var RouteBuilder = class {
     return this.register(fn, true);
   }
   register(handlerFn, streaming) {
-    if (!this._authMode) {
+    if (!this.#s.authMode) {
       throw new Error(
-        `route '${this._key}': Select an auth mode: .paid(pricing), .siwx(), .apiKey(resolver), or .unprotected()`
+        `route '${this.#s.key}': Select an auth mode: .paid(pricing), .upTo(maxPrice), .metered(options), .siwx(), .apiKey(resolver), or .unprotected()`
       );
     }
-    if (this._validateFn && !this._bodySchema) {
+    if (this.#s.validateFn && !this.#s.bodySchema) {
       throw new Error(
-        `route '${this._key}': .validate() requires .body() \u2014 validation runs on parsed body`
+        `route '${this.#s.key}': .validate() requires .body() \u2014 validation runs on parsed body`
       );
     }
-    if (this._settlement && !this._pricing) {
-      throw new Error(`route '${this._key}': .settlement() requires a paid route`);
+    if (this.#s.settlement && !this.#s.pricing) {
+      throw new Error(`route '${this.#s.key}': .settlement() requires a paid route`);
     }
-    if (this._dynamicPrice && this._protocols.includes("x402")) {
-      const hasUpto = this._deps.x402Accepts.some((accept) => accept.scheme === "upto");
+    if (this.#s.billing === "upto") {
+      const hasUpto = this.#s.deps.x402Accepts.some((accept) => accept.scheme === "upto");
       if (!hasUpto) {
         throw new Error(
-          `route '${this._key}': .paid({ dynamic: true }) on an x402 route requires an 'upto' accept on at least one configured network. Add { scheme: 'upto', network, asset } to RouterConfig.x402.accepts.`
+          `route '${this.#s.key}': .upTo() requires an 'upto' accept on at least one configured network. Add { scheme: 'upto', network, asset } to RouterConfig.x402.accepts.`
+        );
+      }
+    }
+    if (this.#s.pricing !== void 0 && this.#s.billing === "exact" && this.#s.protocols.includes("x402")) {
+      const hasExact = this.#s.deps.x402Accepts.some(
+        (accept) => (accept.scheme ?? "exact") !== "upto"
+      );
+      if (!hasExact) {
+        throw new Error(
+          `route '${this.#s.key}': .paid() needs a non-'upto' x402 accept \u2014 an 'upto'-only accept list cannot serve a fixed-price route. Add { scheme: 'exact', network } to RouterConfig.x402.accepts, or use .upTo() for handler-computed billing.`
         );
       }
     }
-    if (this._dynamicPrice && this._protocols.includes("mpp")) {
-      if (!this._deps.mppSessionConfig) {
+    if (this.#s.billing === "metered") {
+      if (!this.#s.deps.mppSessionConfig) {
         throw new Error(
-          `route '${this._key}': .paid({ dynamic: true }) on an MPP route requires session mode. Set RouterConfig.mpp.session = {} and provide mpp.operatorKey.`
+          `route '${this.#s.key}': .metered() requires MPP session mode. Set RouterConfig.mpp.session = {} and provide mpp.operatorKey.`
         );
       }
     }
-    if (streaming && !this._dynamicPrice) {
+    if (streaming && this.#s.billing !== "metered") {
       throw new Error(
-        `route '${this._key}': .stream() requires .paid({ dynamic: true }) \u2014 static/free routes can't meter per-chunk billing.`
+        `route '${this.#s.key}': .stream() requires .metered() \u2014 static/free/upto routes can't meter per-chunk billing.`
       );
     }
     validateExamples(
-      this._key,
-      this._bodySchema,
-      this._querySchema,
-      this._outputSchema,
-      this._inputExample,
-      this._hasInputExample,
-      this._outputExample,
-      this._hasOutputExample
+      this.#s.key,
+      this.#s.bodySchema,
+      this.#s.querySchema,
+      this.#s.outputSchema,
+      this.#s.inputExample,
+      this.#s.hasInputExample,
+      this.#s.outputExample,
+      this.#s.hasOutputExample
     );
     const entry = {
-      key: this._key,
-      authMode: this._authMode,
-      siwxEnabled: this._siwxEnabled,
-      pricing: this._pricing,
-      dynamicPrice: this._dynamicPrice ? true : void 0,
+      key: this.#s.key,
+      authMode: this.#s.authMode,
+      siwxEnabled: this.#s.siwxEnabled,
+      pricing: this.#s.pricing,
+      billing: this.#s.billing,
       streaming: streaming ? true : void 0,
-      protocols: this._protocols,
-      bodySchema: this._bodySchema,
-      querySchema: this._querySchema,
-      outputSchema: this._outputSchema,
-      inputExample: this._hasInputExample ? this._inputExample : void 0,
-      outputExample: this._hasOutputExample ? this._outputExample : void 0,
-      description: this._description,
-      path: this._path,
-      method: this._method,
-      maxPrice: this._maxPrice,
-      minPrice: this._minPrice,
-      payTo: this._payTo,
-      apiKeyResolver: this._apiKeyResolver,
-      providerName: this._providerName,
-      providerConfig: this._providerConfig,
-      validateFn: this._validateFn,
-      settlement: this._settlement,
-      mppInfo: this._mppInfo,
-      tickCost: this._tickCost,
-      unitType: this._unitType
+      protocols: this.#s.protocols,
+      bodySchema: this.#s.bodySchema,
+      querySchema: this.#s.querySchema,
+      outputSchema: this.#s.outputSchema,
+      inputExample: this.#s.hasInputExample ? this.#s.inputExample : void 0,
+      outputExample: this.#s.hasOutputExample ? this.#s.outputExample : void 0,
+      description: this.#s.description,
+      path: this.#s.path,
+      method: this.#s.method,
+      maxPrice: this.#s.maxPrice,
+      minPrice: this.#s.minPrice,
+      payTo: this.#s.payTo,
+      apiKeyResolver: this.#s.apiKeyResolver,
+      providerName: this.#s.providerName,
+      providerConfig: this.#s.providerConfig,
+      validateFn: this.#s.validateFn,
+      settlement: this.#s.settlement,
+      mppInfo: this.#s.mppInfo,
+      tickCost: this.#s.tickCost,
+      unitType: this.#s.unitType
     };
-    this._registry.register(entry);
-    return createRequestHandler(entry, handlerFn, this._deps);
+    this.#s.registry.register(entry);
+    return createRequestHandler(entry, handlerFn, this.#s.deps);
   }
 };
-function resolvePaidArgs(routeKey, pricingOrOptions, options) {
-  const isHandlerDynamicShape = typeof pricingOrOptions === "object" && pricingOrOptions !== null && typeof pricingOrOptions !== "function" && !("tiers" in pricingOrOptions) && "dynamic" in pricingOrOptions && pricingOrOptions.dynamic;
-  if (isHandlerDynamicShape) {
-    const opts = pricingOrOptions;
-    if (!opts.maxPrice) {
-      throw new Error(`route '${routeKey}': .paid({ dynamic: true }) requires maxPrice`);
-    }
-    return { pricing: opts.maxPrice, resolvedOptions: opts };
+function normalizePaidArg(routeKey, arg, options) {
+  if (typeof arg === "string") {
+    return { pricing: arg, resolvedOptions: options ?? {}, billing: "exact" };
+  }
+  if (typeof arg === "function") {
+    return {
+      pricing: arg,
+      resolvedOptions: options ?? {},
+      billing: "exact"
+    };
+  }
+  if ("tiers" in arg && "field" in arg) {
+    return {
+      pricing: { field: arg.field, tiers: arg.tiers, default: arg.default },
+      resolvedOptions: arg,
+      billing: "exact"
+    };
+  }
+  if ("price" in arg && typeof arg.price === "string") {
+    return { pricing: arg.price, resolvedOptions: arg, billing: "exact" };
+  }
+  throw new Error(
+    `route '${routeKey}': .paid() requires one of: a price string, a (body) => string function, { price }, or { field, tiers }. For handler-computed billing use .upTo(); for per-tick billing use .metered().`
+  );
+}
+function normalizeUpToArg(routeKey, arg) {
+  const options = typeof arg === "string" ? { maxPrice: arg } : arg;
+  if (!options.maxPrice) {
+    throw new Error(`route '${routeKey}': .upTo() requires maxPrice`);
+  }
+  return {
+    pricing: options.maxPrice,
+    resolvedOptions: options,
+    billing: "upto",
+    unitType: options.unitType,
+    maxPrice: options.maxPrice
+  };
+}
+function normalizeMeteredArg(routeKey, options) {
+  if (!options.maxPrice) {
+    throw new Error(`route '${routeKey}': .metered() requires maxPrice`);
+  }
+  if (!options.tickCost) {
+    throw new Error(`route '${routeKey}': .metered() requires tickCost`);
   }
-  return { pricing: pricingOrOptions, resolvedOptions: options };
+  return {
+    pricing: options.maxPrice,
+    resolvedOptions: options,
+    billing: "metered",
+    tickCost: options.tickCost,
+    unitType: options.unitType,
+    maxPrice: options.maxPrice
+  };
 }
 
 // src/discovery/well-known.ts
@@ -3918,17 +4207,16 @@ function buildPricingInfo(entry) {
     };
   }
   if ("tiers" in entry.pricing) {
-    const tierPrices = Object.values(entry.pricing.tiers).map((tier) => parseFloat(tier.price));
-    const min = Math.min(...tierPrices);
-    const max = Math.max(...tierPrices);
-    if (Number.isFinite(min) && Number.isFinite(max)) {
-      if (min === max) {
+    const tierPrices = Object.values(entry.pricing.tiers).map((tier) => tier.price);
+    const extrema = tierExtrema(tierPrices);
+    if (extrema) {
+      if (extrema.min === extrema.max) {
         return {
-          price: { mode: "fixed", currency: "USD", amount: String(min) }
+          price: { mode: "fixed", currency: "USD", amount: extrema.min }
         };
       }
       return {
-        price: { mode: "dynamic", currency: "USD", min: String(min), max: String(max) }
+        price: { mode: "dynamic", currency: "USD", min: extrema.min, max: extrema.max }
       };
     }
     return {
@@ -3942,6 +4230,20 @@ function buildPricingInfo(entry) {
   }
   return void 0;
 }
+function tierExtrema(prices) {
+  if (prices.length === 0) return null;
+  let min = prices[0];
+  let max = prices[0];
+  try {
+    for (const price of prices.slice(1)) {
+      if (compareDecimals(price, min) < 0) min = price;
+      if (compareDecimals(price, max) > 0) max = price;
+    }
+  } catch {
+    return null;
+  }
+  return { min, max };
+}
 
 // src/discovery/llms-txt.ts
 var import_server10 = require("next/server");
@@ -4428,11 +4730,11 @@ function getRouterConfigIssues(config, options = {}) {
 }
 
 // src/init/x402.ts
-async function initX402(config, configError) {
+async function initX402(config, kvStore, configError) {
   if (configError) return { initError: configError };
   try {
     const { createX402Server: createX402Server2 } = await Promise.resolve().then(() => (init_x402_server(), x402_server_exports));
-    const result = await createX402Server2(config);
+    const result = await createX402Server2(config, kvStore);
     await result.initPromise;
     return {
       server: result.server,
@@ -4612,10 +4914,10 @@ function createRouter(config) {
     x402Accepts,
     mppx: null,
     tempoClient: null,
-    mppSessionConfig: config.mpp?.session ? { depositMultiplier: config.mpp.session.depositMultiplier ?? 10 } : null
+    mppSessionConfig: config.mpp?.session && config.mpp.operatorKey ? { depositMultiplier: config.mpp.session.depositMultiplier ?? 10 } : null
   };
   deps.initPromise = (async () => {
-    const x402Result = await initX402(config, x402ConfigError);
+    const x402Result = await initX402(config, kvStore, x402ConfigError);
     deps.x402Server = x402Result.server ?? null;
     deps.x402FacilitatorsByNetwork = x402Result.facilitatorsByNetwork;
     if (x402Result.initError) deps.x402InitError = x402Result.initError;
@@ -4644,11 +4946,10 @@ function createRouter(config) {
           `[router] strictRoutes=true forbids key/path divergence for route '${definition.path}'. Remove custom \`key\` or make it equal to \`path\`.`
         );
       }
-      let builder = new RouteBuilder(key, registry, deps);
+      let builder = new RouteBuilder(key, registry, deps, {
+        protocols: config.protocols
+      });
       builder = builder.path(normalizedPath);
-      if (config.protocols) {
-        builder._protocols = [...config.protocols];
-      }
       if (definition.method) {
         builder = builder.method(definition.method);
       }