@peaje/next 0.1.0 → 0.2.0

package/README.md

@@ -1,8 +1,9 @@
 # @peaje/next
 
-Peaje for Next.js. Two pieces:
+Peaje for Next.js. Three pieces:
 
-- `withPeaje(nextConfig, { slug })` adds the proxy rewrites that make your domain serve the Peaje catalog, the MCP server, the OpenAPI spec and the priced links (HTTP 402) that your gateway already publishes.
+- `peajeProxy({ slug })` (from `@peaje/next/proxy`) is the middleware that answers HTTP 402 on your own domain for every priced route in your Peaje dashboard, including API routes you publish later. It reads the route list from your gateway at runtime, cached for a minute, so a new route needs no redeploy.
+- `withPeaje(nextConfig, { slug })` adds the build-time rewrites for the fixed catalog paths (llms.txt, openapi.json, /developers, the MCP server, the `/r/` priced links).
 - `<PeajeHead slug="..." />` renders the JSON-LD `WebAPI` block and the discovery `<link>` tags in your `<head>`.
 
 Both are additive: your existing rewrites, config and head stay as they are.
@@ -32,7 +33,24 @@ export default withPeaje(nextConfig, { slug: 'cafe-andino' })
 
 Options: `slug` (required, the one from your Peaje dashboard) and `gateway` (defaults to `https://peaje-gateway.up.railway.app`, overridable with the `PEAJE_GATEWAY_URL` environment variable).
 
-If you have a `middleware.ts` or `proxy.ts` with a `matcher`, exclude `mcp`, `r/`, `discovery/`, `checkout_sessions`, `agentic_commerce/` and `docs` from it: middleware runs before rewrites.
+## 1b. Runtime proxy (priced API routes on your domain)
+
+```ts
+// proxy.ts (Next 16) or middleware.ts (Next 14/15), at the project root or in src/
+import { peajeProxy } from '@peaje/next/proxy'
+
+export default peajeProxy({ slug: 'cafe-andino' })
+
+export const config = {
+  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
+}
+```
+
+Set `PEAJE_ORIGIN_SECRET` in your hosting environment variables (copy it from the Kit page of your Peaje dashboard). After an agent pays, the gateway forwards the request to your site with that secret; it is how the proxy tells the gateway apart from someone pretending to be it. Without it, priced API routes are not forwarded (they would be free to anyone who spoofs a header) and the proxy logs a warning; discovery files and `/r/` links work anyway. You can also pass it as `peajeProxy({ slug, secret })`.
+
+The rewrites above are fixed at build time, so they cannot know about an API route you add to your dashboard tomorrow. `peajeProxy` fetches `/{slug}/kit/manifest.json` from the gateway, keeps it for 60 seconds, and rewrites any request that matches a priced route (`/api/forecast`, `/api/history/:city`, `/api/batch/*`) to the gateway, which answers 402 or, once paid, forwards to your origin. Catch-all patterns (`/*`, `/:id` at the root) are not forwarded from your domain: they would send the whole site to the gateway.
+
+With your own middleware: `export default peajeProxy({ slug }, myMiddleware)`. Peaje runs first; when the request is not one of its routes, yours runs.
 
 ## 2. Head
 

package/dist/{chunk-7KJLR3FN.js → chunk-XUCHMX2L.js}

@@ -91,6 +91,97 @@ var LINKS_HEAD = [
   { rel: "ard", type: "application/ai-catalog+json", href: "/.well-known/ard.json" }
 ];
 
+// ../shared/src/kit/proxy-runtime.ts
+var PEAJE_ORIGIN_HEADER = "x-peaje-origin";
+function iguales(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return d === 0;
+}
+function coincidePatron(patron, pathname) {
+  const p = patron.split("/").filter(Boolean);
+  const parts = pathname.split("/").filter(Boolean);
+  for (let i = 0; i < p.length; i++) {
+    const seg = p[i];
+    if (seg === "*") return true;
+    const v = parts[i];
+    if (v === void 0) return false;
+    if (seg.startsWith(":")) continue;
+    if (seg !== v) return false;
+  }
+  return p.length === parts.length;
+}
+function patronReenviable(patron) {
+  const segs = patron.split("/").filter(Boolean);
+  if (segs.length === 0) return false;
+  return !(segs.length === 1 && (segs[0] === "*" || segs[0].startsWith(":")));
+}
+function crearProxyRuntime(opciones) {
+  const base = opciones.base.replace(/\/+$/, "");
+  const ttl = opciones.ttlMs ?? 6e4;
+  const fetchImpl = opciones.fetchImpl ?? fetch;
+  let cache = {
+    at: 0,
+    rutas: opciones.respaldo?.rutas ?? [],
+    prefijos: opciones.respaldo?.prefijos ?? [],
+    patrones: opciones.respaldo?.patrones ?? []
+  };
+  let refrescando = null;
+  async function refrescar() {
+    try {
+      const res = await fetchImpl(`${base}/kit/manifest.json`, { signal: AbortSignal.timeout(5e3) });
+      if (!res.ok) throw new Error(String(res.status));
+      const m = await res.json();
+      cache = {
+        at: Date.now(),
+        rutas: Array.isArray(m.rutas) ? m.rutas : cache.rutas,
+        prefijos: Array.isArray(m.prefijos) ? m.prefijos : cache.prefijos,
+        patrones: Array.isArray(m.patrones) ? m.patrones : cache.patrones
+      };
+    } catch {
+      cache = { ...cache, at: Date.now() };
+    } finally {
+      refrescando = null;
+    }
+  }
+  async function listas() {
+    const vencido = Date.now() - cache.at >= ttl;
+    if (vencido) {
+      refrescando ??= refrescar();
+      if (cache.at === 0) await refrescando;
+    }
+    return cache;
+  }
+  return {
+    /** Rutas de API con precio que este sitio no puede cobrar por falta de secreto. */
+    async sinSecreto() {
+      if (opciones.secreto) return [];
+      return (await listas()).patrones.filter((p) => patronReenviable(p.path));
+    },
+    /** Fuerza la carga del manifiesto (útil al arrancar o en tests). */
+    cargar: () => refrescando ??= refrescar(),
+    /**
+     * Decide si la request va al gateway. `method` y `pathname` de la request,
+     * `search` con el `?` incluido, y los headers para cortar bucles.
+     */
+    async decidir(input) {
+      const secreto = opciones.secreto || null;
+      const prueba = input.headers.get(PEAJE_ORIGIN_HEADER);
+      if (secreto && prueba && iguales(prueba, secreto)) return null;
+      const { rutas, prefijos, patrones } = await listas();
+      const path = input.pathname;
+      const esFetchDePeaje = input.headers.get(PEAJE_FETCH_HEADER) !== null;
+      const fija = rutas.includes(path) && !(path === "/llms.txt" && esFetchDePeaje);
+      const prefijo = prefijos.some((p) => path.startsWith(p));
+      const method = input.method.toUpperCase();
+      const patron = secreto !== null && patrones.some((p) => p.method.toUpperCase() === method && patronReenviable(p.path) && coincidePatron(p.path, path));
+      if (!fija && !prefijo && !patron) return null;
+      return { destino: `${base}${path}${input.search ?? ""}` };
+    }
+  };
+}
+
 // ../shared/src/index.ts
 var TEMPO = {
   mainnet: {
@@ -187,6 +278,36 @@ var NETWORKS = {
   }
 };
 var NETWORK_IDS = Object.keys(NETWORKS);
+var CHAIN_LABELS = [
+  ...new Map(NETWORK_IDS.map((id) => [NETWORKS[id].testnet.chainId, NETWORKS[id].label.split(" \xB7 ")[0] ?? NETWORKS[id].label])).values()
+];
+var GATEWAY_RAILS = {
+  "gateway-arbitrum": {
+    id: "gateway-arbitrum",
+    label: "Arbitrum \xB7 Nanopayments",
+    chainId: 421614,
+    rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    token: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arbitrumSepolia",
+    explorerUrl: "https://sepolia.arbiscan.io"
+  },
+  "gateway-arc": {
+    id: "gateway-arc",
+    label: "Arc \xB7 Nanopayments",
+    chainId: 5042002,
+    rpcUrl: "https://rpc.testnet.arc.network",
+    token: "0x3600000000000000000000000000000000000000",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arcTestnet",
+    explorerUrl: "https://testnet.arcscan.app"
+  }
+};
+var GATEWAY_RAIL_IDS = Object.keys(GATEWAY_RAILS);
 
 // src/index.ts
 var GATEWAY_POR_DEFECTO = "https://peaje-gateway.up.railway.app";
@@ -222,9 +343,12 @@ function withPeaje(nextConfig, opciones) {
 var src_default = withPeaje;
 
 export {
+  RUTAS_PROXY,
+  RUTAS_DINAMICAS,
   jsonParaScript,
   jsonLdWebApi,
   LINKS_HEAD,
+  crearProxyRuntime,
   GATEWAY_POR_DEFECTO,
   baseDe,
   fusionarRewrites,

package/dist/head.cjs

@@ -186,6 +186,36 @@ var NETWORKS = {
   }
 };
 var NETWORK_IDS = Object.keys(NETWORKS);
+var CHAIN_LABELS = [
+  ...new Map(NETWORK_IDS.map((id) => [NETWORKS[id].testnet.chainId, NETWORKS[id].label.split(" \xB7 ")[0] ?? NETWORKS[id].label])).values()
+];
+var GATEWAY_RAILS = {
+  "gateway-arbitrum": {
+    id: "gateway-arbitrum",
+    label: "Arbitrum \xB7 Nanopayments",
+    chainId: 421614,
+    rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    token: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arbitrumSepolia",
+    explorerUrl: "https://sepolia.arbiscan.io"
+  },
+  "gateway-arc": {
+    id: "gateway-arc",
+    label: "Arc \xB7 Nanopayments",
+    chainId: 5042002,
+    rpcUrl: "https://rpc.testnet.arc.network",
+    token: "0x3600000000000000000000000000000000000000",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arcTestnet",
+    explorerUrl: "https://testnet.arcscan.app"
+  }
+};
+var GATEWAY_RAIL_IDS = Object.keys(GATEWAY_RAILS);
 
 // src/index.ts
 var GATEWAY_POR_DEFECTO = "https://peaje-gateway.up.railway.app";

package/dist/head.js

@@ -3,7 +3,7 @@ import {
   baseDe,
   jsonLdWebApi,
   jsonParaScript
-} from "./chunk-7KJLR3FN.js";
+} from "./chunk-XUCHMX2L.js";
 
 // src/head.tsx
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";

package/dist/index.cjs

@@ -163,6 +163,36 @@ var NETWORKS = {
   }
 };
 var NETWORK_IDS = Object.keys(NETWORKS);
+var CHAIN_LABELS = [
+  ...new Map(NETWORK_IDS.map((id) => [NETWORKS[id].testnet.chainId, NETWORKS[id].label.split(" \xB7 ")[0] ?? NETWORKS[id].label])).values()
+];
+var GATEWAY_RAILS = {
+  "gateway-arbitrum": {
+    id: "gateway-arbitrum",
+    label: "Arbitrum \xB7 Nanopayments",
+    chainId: 421614,
+    rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    token: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arbitrumSepolia",
+    explorerUrl: "https://sepolia.arbiscan.io"
+  },
+  "gateway-arc": {
+    id: "gateway-arc",
+    label: "Arc \xB7 Nanopayments",
+    chainId: 5042002,
+    rpcUrl: "https://rpc.testnet.arc.network",
+    token: "0x3600000000000000000000000000000000000000",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arcTestnet",
+    explorerUrl: "https://testnet.arcscan.app"
+  }
+};
+var GATEWAY_RAIL_IDS = Object.keys(GATEWAY_RAILS);
 
 // src/index.ts
 var GATEWAY_POR_DEFECTO = "https://peaje-gateway.up.railway.app";

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   fusionarRewrites,
   src_default,
   withPeaje
-} from "./chunk-7KJLR3FN.js";
+} from "./chunk-XUCHMX2L.js";
 export {
   GATEWAY_POR_DEFECTO,
   baseDe,

package/dist/proxy.cjs

@@ -0,0 +1,336 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/proxy.ts
+var proxy_exports = {};
+__export(proxy_exports, {
+  default: () => proxy_default,
+  peajeProxy: () => peajeProxy
+});
+module.exports = __toCommonJS(proxy_exports);
+
+// ../shared/src/kit/rutas.ts
+var RUTAS_PROXY = [
+  { path: "/llms.txt", nota: "gu\xEDa para agentes (fusionada con la tuya)" },
+  { path: "/pricing.md", nota: "precios por endpoint" },
+  { path: "/auth.md", nota: 'c\xF3mo pagar (el "auth" ac\xE1 es el pago)' },
+  { path: "/agents.md", nota: "qu\xE9 es y cu\xE1ndo usarte" },
+  { path: "/openapi.json", nota: "discovery con precios" },
+  { path: "/mcp", nota: "MCP server con tools pagas, en TU dominio" },
+  { path: "/.well-known/mcp", nota: "el MCP tambi\xE9n ac\xE1: es donde lo buscan los auditores" },
+  { path: "/.well-known/ard.json", nota: "cat\xE1logo ARD (path can\xF3nico)" },
+  { path: "/.well-known/ai-catalog.json", nota: "cat\xE1logo ARD (alias legacy)" },
+  { path: "/.well-known/api-catalog", nota: "linkset RFC 9727" },
+  { path: "/.well-known/agent-card.json", nota: "agent card A2A" },
+  { path: "/.well-known/mcp/server-card.json", nota: "server card MCP" },
+  { path: "/discovery/resources", nota: "lista x402 Bazaar: lo que cobra 402 de verdad" },
+  { path: "/.well-known/ucp", nota: "perfil UCP: qu\xE9 sabe hacer tu negocio" },
+  { path: "/checkout_sessions", nota: "checkout ACP (el de OpenAI)" },
+  { path: "/agentic_commerce/delegate_payment", nota: "delegate payment ACP" },
+  { path: "/developers", nota: "portal de desarrolladores, renderizado con tus precios" },
+  { path: "/.well-known/peaje-indexnow.txt", nota: "clave IndexNow: avisa a Bing y Copilot cuando cambian precios" },
+  // Los auditores prueban /docs y /developers; el gateway redirige uno al otro.
+  { path: "/docs", nota: "alias del portal: los auditores prueban ambos" }
+];
+var RUTAS_DINAMICAS = [
+  { path: "/r/:slug", prefijo: "/r/", nota: "links con precio: el 402 en tu dominio" },
+  { path: "/checkout_sessions/:id", prefijo: "/checkout_sessions/", nota: "leer una sesi\xF3n de checkout ACP" }
+];
+var PEAJE_FETCH_HEADER = "x-peaje-fetch";
+
+// ../shared/src/kit/proxy-runtime.ts
+var PEAJE_ORIGIN_HEADER = "x-peaje-origin";
+function iguales(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return d === 0;
+}
+function coincidePatron(patron, pathname) {
+  const p = patron.split("/").filter(Boolean);
+  const parts = pathname.split("/").filter(Boolean);
+  for (let i = 0; i < p.length; i++) {
+    const seg = p[i];
+    if (seg === "*") return true;
+    const v = parts[i];
+    if (v === void 0) return false;
+    if (seg.startsWith(":")) continue;
+    if (seg !== v) return false;
+  }
+  return p.length === parts.length;
+}
+function patronReenviable(patron) {
+  const segs = patron.split("/").filter(Boolean);
+  if (segs.length === 0) return false;
+  return !(segs.length === 1 && (segs[0] === "*" || segs[0].startsWith(":")));
+}
+function crearProxyRuntime(opciones) {
+  const base = opciones.base.replace(/\/+$/, "");
+  const ttl = opciones.ttlMs ?? 6e4;
+  const fetchImpl = opciones.fetchImpl ?? fetch;
+  let cache = {
+    at: 0,
+    rutas: opciones.respaldo?.rutas ?? [],
+    prefijos: opciones.respaldo?.prefijos ?? [],
+    patrones: opciones.respaldo?.patrones ?? []
+  };
+  let refrescando = null;
+  async function refrescar() {
+    try {
+      const res = await fetchImpl(`${base}/kit/manifest.json`, { signal: AbortSignal.timeout(5e3) });
+      if (!res.ok) throw new Error(String(res.status));
+      const m = await res.json();
+      cache = {
+        at: Date.now(),
+        rutas: Array.isArray(m.rutas) ? m.rutas : cache.rutas,
+        prefijos: Array.isArray(m.prefijos) ? m.prefijos : cache.prefijos,
+        patrones: Array.isArray(m.patrones) ? m.patrones : cache.patrones
+      };
+    } catch {
+      cache = { ...cache, at: Date.now() };
+    } finally {
+      refrescando = null;
+    }
+  }
+  async function listas() {
+    const vencido = Date.now() - cache.at >= ttl;
+    if (vencido) {
+      refrescando ??= refrescar();
+      if (cache.at === 0) await refrescando;
+    }
+    return cache;
+  }
+  return {
+    /** Rutas de API con precio que este sitio no puede cobrar por falta de secreto. */
+    async sinSecreto() {
+      if (opciones.secreto) return [];
+      return (await listas()).patrones.filter((p) => patronReenviable(p.path));
+    },
+    /** Fuerza la carga del manifiesto (útil al arrancar o en tests). */
+    cargar: () => refrescando ??= refrescar(),
+    /**
+     * Decide si la request va al gateway. `method` y `pathname` de la request,
+     * `search` con el `?` incluido, y los headers para cortar bucles.
+     */
+    async decidir(input) {
+      const secreto = opciones.secreto || null;
+      const prueba = input.headers.get(PEAJE_ORIGIN_HEADER);
+      if (secreto && prueba && iguales(prueba, secreto)) return null;
+      const { rutas, prefijos, patrones } = await listas();
+      const path = input.pathname;
+      const esFetchDePeaje = input.headers.get(PEAJE_FETCH_HEADER) !== null;
+      const fija = rutas.includes(path) && !(path === "/llms.txt" && esFetchDePeaje);
+      const prefijo = prefijos.some((p) => path.startsWith(p));
+      const method = input.method.toUpperCase();
+      const patron = secreto !== null && patrones.some((p) => p.method.toUpperCase() === method && patronReenviable(p.path) && coincidePatron(p.path, path));
+      if (!fija && !prefijo && !patron) return null;
+      return { destino: `${base}${path}${input.search ?? ""}` };
+    }
+  };
+}
+
+// ../shared/src/index.ts
+var TEMPO = {
+  mainnet: {
+    chainId: 4217,
+    rpcUrl: "https://rpc.tempo.xyz",
+    explorerUrl: "https://explore.tempo.xyz"
+  },
+  testnet: {
+    chainId: 42431,
+    rpcUrl: "https://rpc.moderato.tempo.xyz",
+    explorerUrl: "https://explore.testnet.tempo.xyz"
+  }
+};
+var TOKENS = {
+  pathUsd: "0x20c0000000000000000000000000000000000000",
+  usdc: "0x20C000000000000000000000b9537d11c60E8b50"
+};
+var DEFAULT_CURRENCY = TOKENS.pathUsd;
+var NETWORKS = {
+  tempo: {
+    id: "tempo",
+    label: "Tempo",
+    token: TOKENS.pathUsd,
+    tokenSymbol: "pathUSD",
+    decimals: 6,
+    mainnet: TEMPO.mainnet,
+    testnet: TEMPO.testnet
+  },
+  arc: {
+    id: "arc",
+    label: "Arc",
+    // Interfaz ERC-20 del USDC nativo de Arc; el gas de la red se paga en ese mismo USDC.
+    token: "0x3600000000000000000000000000000000000000",
+    tokenSymbol: "USDC",
+    decimals: 6,
+    // Leído on-chain del contrato: name() = "USDC", version() = "2".
+    eip3009: { name: "USDC", version: "2" },
+    // Arc no publica direcciones de mainnet todavía (sept 2026).
+    mainnet: null,
+    testnet: {
+      chainId: 5042002,
+      rpcUrl: "https://rpc.testnet.arc.io",
+      explorerUrl: "https://testnet.arcscan.app"
+    }
+  },
+  arbitrum: {
+    id: "arbitrum",
+    label: "Arbitrum",
+    // USDC de Circle en Arbitrum Sepolia. En Arbitrum One vive en otra dirección,
+    // por eso mainnet queda en null hasta que el gateway opere allá.
+    token: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    tokenSymbol: "USDC",
+    decimals: 6,
+    // Leído on-chain: name() = "USD Coin", version() = "2" (distinto al USDC de Arc).
+    eip3009: { name: "USD Coin", version: "2" },
+    mainnet: null,
+    testnet: {
+      chainId: 421614,
+      rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+      explorerUrl: "https://sepolia.arbiscan.io"
+    }
+  },
+  "arbitrum-usdg": {
+    id: "arbitrum-usdg",
+    label: "Arbitrum \xB7 USDG",
+    // Mismo contrato y misma cadena que el riel USDC: cambia el stablecoin.
+    // Un riel es (cadena, token), y el saldo del negocio se lleva por token.
+    token: "0xFFC95faa3d63Cde504a05B567C600B78C0b41892",
+    tokenSymbol: "USDG",
+    decimals: 6,
+    eip3009: { name: "Global Dollar", version: "1" },
+    mainnet: null,
+    testnet: {
+      chainId: 421614,
+      rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+      explorerUrl: "https://sepolia.arbiscan.io"
+    }
+  },
+  robinhood: {
+    id: "robinhood",
+    label: "Robinhood",
+    // USDG de Paxos en Robinhood Chain Testnet (el "USDC" de esa testnet es un
+    // mock sin EIP-3009). Leído on-chain: dominio "Global Dollar", versión "1".
+    token: "0x7E955252E15c84f5768B83c41a71F9eba181802F",
+    tokenSymbol: "USDG",
+    decimals: 6,
+    eip3009: { name: "Global Dollar", version: "1" },
+    mainnet: null,
+    testnet: {
+      chainId: 46630,
+      rpcUrl: "https://rpc.testnet.chain.robinhood.com",
+      explorerUrl: "https://explorer.testnet.chain.robinhood.com"
+    }
+  }
+};
+var NETWORK_IDS = Object.keys(NETWORKS);
+var CHAIN_LABELS = [
+  ...new Map(NETWORK_IDS.map((id) => [NETWORKS[id].testnet.chainId, NETWORKS[id].label.split(" \xB7 ")[0] ?? NETWORKS[id].label])).values()
+];
+var GATEWAY_RAILS = {
+  "gateway-arbitrum": {
+    id: "gateway-arbitrum",
+    label: "Arbitrum \xB7 Nanopayments",
+    chainId: 421614,
+    rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    token: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arbitrumSepolia",
+    explorerUrl: "https://sepolia.arbiscan.io"
+  },
+  "gateway-arc": {
+    id: "gateway-arc",
+    label: "Arc \xB7 Nanopayments",
+    chainId: 5042002,
+    rpcUrl: "https://rpc.testnet.arc.network",
+    token: "0x3600000000000000000000000000000000000000",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arcTestnet",
+    explorerUrl: "https://testnet.arcscan.app"
+  }
+};
+var GATEWAY_RAIL_IDS = Object.keys(GATEWAY_RAILS);
+
+// src/proxy.ts
+var import_server = require("next/server");
+
+// src/index.ts
+var GATEWAY_POR_DEFECTO = "https://peaje-gateway.up.railway.app";
+function baseDe({ slug, gateway }) {
+  const raiz = (gateway ?? process.env.PEAJE_GATEWAY_URL ?? GATEWAY_POR_DEFECTO).replace(/\/+$/, "");
+  return `${raiz}/${slug}`;
+}
+
+// src/proxy.ts
+var runtimes = /* @__PURE__ */ new Map();
+function runtimeDe(base, secreto) {
+  const clave = `${base}|${secreto ? "con" : "sin"}`;
+  let r = runtimes.get(clave);
+  if (!r) {
+    r = crearProxyRuntime({
+      base,
+      secreto,
+      respaldo: { rutas: RUTAS_PROXY.map((x) => x.path), prefijos: RUTAS_DINAMICAS.map((x) => x.prefijo), patrones: [] }
+    });
+    runtimes.set(clave, r);
+  }
+  return r;
+}
+var avisado = false;
+function peajeProxy(opciones, siguiente) {
+  if (!opciones?.slug) throw new Error("peajeProxy: `slug` is required (the business slug from your Peaje dashboard).");
+  const base = baseDe(opciones);
+  const secreto = opciones.secret ?? process.env.PEAJE_ORIGIN_SECRET ?? null;
+  return async (req, ev) => {
+    const runtime = runtimeDe(base, secreto);
+    if (!secreto && !avisado) {
+      avisado = true;
+      void runtime.sinSecreto().then((faltan) => {
+        if (faltan.length > 0) {
+          console.warn(
+            `[peaje] ${faltan.length} priced API route(s) are not charged on this domain because PEAJE_ORIGIN_SECRET is not set: ${faltan.map((p) => `${p.method} ${p.path}`).join(", ")}. Copy it from the Kit page of your Peaje dashboard into your hosting environment variables.`
+          );
+        }
+      });
+    }
+    const decision = await runtime.decidir({
+      method: req.method,
+      pathname: req.nextUrl.pathname,
+      search: req.nextUrl.search,
+      headers: req.headers
+    });
+    if (decision) {
+      const headers = new Headers(req.headers);
+      headers.set("x-forwarded-host", req.nextUrl.host);
+      headers.set("x-forwarded-proto", req.nextUrl.protocol.replace(":", ""));
+      return import_server.NextResponse.rewrite(new URL(decision.destino), { request: { headers } });
+    }
+    return siguiente ? siguiente(req, ev) : import_server.NextResponse.next();
+  };
+}
+var proxy_default = peajeProxy;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  peajeProxy
+});

package/dist/proxy.d.cts

@@ -0,0 +1,11 @@
+import { NextRequest, NextFetchEvent } from 'next/server';
+import { OpcionesPeaje } from './index.cjs';
+
+type Middleware = (req: NextRequest, ev: NextFetchEvent) => Response | undefined | void | Promise<Response | undefined | void>;
+type OpcionesProxy = OpcionesPeaje & {
+    /** Por defecto `process.env.PEAJE_ORIGIN_SECRET`. */
+    secret?: string;
+};
+declare function peajeProxy(opciones: OpcionesProxy, siguiente?: Middleware): Middleware;
+
+export { type OpcionesProxy, peajeProxy as default, peajeProxy };

package/dist/proxy.d.ts

@@ -0,0 +1,11 @@
+import { NextRequest, NextFetchEvent } from 'next/server';
+import { OpcionesPeaje } from './index.js';
+
+type Middleware = (req: NextRequest, ev: NextFetchEvent) => Response | undefined | void | Promise<Response | undefined | void>;
+type OpcionesProxy = OpcionesPeaje & {
+    /** Por defecto `process.env.PEAJE_ORIGIN_SECRET`. */
+    secret?: string;
+};
+declare function peajeProxy(opciones: OpcionesProxy, siguiente?: Middleware): Middleware;
+
+export { type OpcionesProxy, peajeProxy as default, peajeProxy };

package/dist/proxy.js

@@ -0,0 +1,60 @@
+import {
+  RUTAS_DINAMICAS,
+  RUTAS_PROXY,
+  baseDe,
+  crearProxyRuntime
+} from "./chunk-XUCHMX2L.js";
+
+// src/proxy.ts
+import { NextResponse } from "next/server";
+var runtimes = /* @__PURE__ */ new Map();
+function runtimeDe(base, secreto) {
+  const clave = `${base}|${secreto ? "con" : "sin"}`;
+  let r = runtimes.get(clave);
+  if (!r) {
+    r = crearProxyRuntime({
+      base,
+      secreto,
+      respaldo: { rutas: RUTAS_PROXY.map((x) => x.path), prefijos: RUTAS_DINAMICAS.map((x) => x.prefijo), patrones: [] }
+    });
+    runtimes.set(clave, r);
+  }
+  return r;
+}
+var avisado = false;
+function peajeProxy(opciones, siguiente) {
+  if (!opciones?.slug) throw new Error("peajeProxy: `slug` is required (the business slug from your Peaje dashboard).");
+  const base = baseDe(opciones);
+  const secreto = opciones.secret ?? process.env.PEAJE_ORIGIN_SECRET ?? null;
+  return async (req, ev) => {
+    const runtime = runtimeDe(base, secreto);
+    if (!secreto && !avisado) {
+      avisado = true;
+      void runtime.sinSecreto().then((faltan) => {
+        if (faltan.length > 0) {
+          console.warn(
+            `[peaje] ${faltan.length} priced API route(s) are not charged on this domain because PEAJE_ORIGIN_SECRET is not set: ${faltan.map((p) => `${p.method} ${p.path}`).join(", ")}. Copy it from the Kit page of your Peaje dashboard into your hosting environment variables.`
+          );
+        }
+      });
+    }
+    const decision = await runtime.decidir({
+      method: req.method,
+      pathname: req.nextUrl.pathname,
+      search: req.nextUrl.search,
+      headers: req.headers
+    });
+    if (decision) {
+      const headers = new Headers(req.headers);
+      headers.set("x-forwarded-host", req.nextUrl.host);
+      headers.set("x-forwarded-proto", req.nextUrl.protocol.replace(":", ""));
+      return NextResponse.rewrite(new URL(decision.destino), { request: { headers } });
+    }
+    return siguiente ? siguiente(req, ev) : NextResponse.next();
+  };
+}
+var proxy_default = peajeProxy;
+export {
+  proxy_default as default,
+  peajeProxy
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@peaje/next",
-  "version": "0.1.0",
-  "description": "Peaje for Next.js: proxy rewrites and the head block that make your site speak MPP, MCP and OpenAPI on your own domain.",
+  "version": "0.2.0",
+  "description": "Peaje for Next.js: runtime proxy, rewrites and the head block that make your site answer 402 (MPP, x402), MCP and OpenAPI on your own domain.",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -31,13 +31,18 @@
         "types": "./dist/head.d.cts",
         "default": "./dist/head.cjs"
       }
+    },
+    "./proxy": {
+      "import": {
+        "types": "./dist/proxy.d.ts",
+        "default": "./dist/proxy.js"
+      },
+      "require": {
+        "types": "./dist/proxy.d.cts",
+        "default": "./dist/proxy.cjs"
+      }
     }
   },
-  "scripts": {
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "test": "tsx --test test/*.test.ts"
-  },
   "keywords": [
     "peaje",
     "next",
@@ -59,13 +64,21 @@
     }
   },
   "devDependencies": {
-    "@peaje/shared": "workspace:*",
     "@types/node": "^20",
     "@types/react": "^19",
     "next": "16.3.1",
     "react": "19.2.8",
     "tsup": "^8.5.1",
     "tsx": "^4.23.12",
-    "typescript": "^5.9.0"
+    "typescript": "^5.9.0",
+    "@peaje/shared": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts"
   }
-}
+}