@lunora/x402 1.0.0-alpha.4 → 1.0.0-alpha.6

package/dist/charge/index.d.mts

@@ -1,5 +1,5 @@
-import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-5Nqi5iox.mjs";
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-5Nqi5iox.mjs";
+import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-B-NYmHgG.mjs";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-B-NYmHgG.mjs";
 import { HTTPFacilitatorClient } from '@x402/core/server';
 import { RouteConfig } from '@x402/core/http';
 import '@x402/evm';
@@ -7,106 +7,106 @@ import '@x402/svm';
 import '@x402/core/client';
 import '@x402/core/types';
 /**
-* Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
-*
-* `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
-* call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
-* `supported`), so the same header map is handed to each. With no config the
-* client points at the public {@link resolveFacilitatorUrl default} and sends no
-* auth headers.
-* @experimental
-*/
+ * Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
+ *
+ * `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
+ * call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
+ * `supported`), so the same header map is handed to each. With no config the
+ * client points at the public {@link resolveFacilitatorUrl default} and sends no
+ * auth headers.
+ * @experimental
+ */
 declare const createFacilitatorClient: (config?: FacilitatorConfig) => HTTPFacilitatorClient;
 /**
-* A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
-* @experimental
-*/
+ * A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
+ * @experimental
+ */
 type HttpActionHandler<Context> = (context: Context, request: Request) => Promise<Response> | Response;
 /**
-* Gate `handler` behind an x402 paywall described by `config`. Returns a handler
-* of the same shape, ready to pass to `httpAction`.
-* @experimental
-*/
+ * Gate `handler` behind an x402 paywall described by `config`. Returns a handler
+ * of the same shape, ready to pass to `httpAction`.
+ * @experimental
+ */
 declare const withX402: <Context>(config: X402ChargeConfig, handler: HttpActionHandler<Context>) => HttpActionHandler<Context>;
 /**
-* Runs the protected resource handler, producing the Response to gate.
-* @experimental
-*/
+ * Runs the protected resource handler, producing the Response to gate.
+ * @experimental
+ */
 type ChargeHandler = () => Promise<Response> | Response;
 /**
-* Per-request platform seams `handle` can use, beyond the request/handler pair.
-* @experimental
-*/
+ * Per-request platform seams `handle` can use, beyond the request/handler pair.
+ * @experimental
+ */
 interface ChargeHandlerDeps {
   /**
-  * Keep background work (the receipt sink) alive past the response — the
-  * request's `ctx.waitUntil`. Absent on paths with no platform execution
-  * context reaching the middleware (e.g. today's HTTP-action rail).
-  */
+   * Keep background work (the receipt sink) alive past the response — the
+   * request's `ctx.waitUntil`. Absent on paths with no platform execution
+   * context reaching the middleware (e.g. today's HTTP-action rail).
+   */
   readonly waitUntil?: (promise: Promise<unknown>) => void;
 }
 /**
-* A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
-* @experimental
-*/
+ * A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
+ * @experimental
+ */
 interface ChargeMiddleware {
   /** Gate `request`: challenge / verify / settle around `runHandler`. */
   handle: (request: Request, runHandler: ChargeHandler, deps?: ChargeHandlerDeps) => Promise<Response>;
 }
 /**
-* Route metadata a caller can layer onto the generated catch-all route. The
-* procedure gate sets `resource` to the `functionPath` so the x402 challenge
-* names the paid function (x402 core falls back to the request URL otherwise —
-* every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
-* procedures apart).
-* @experimental
-*/
+ * Route metadata a caller can layer onto the generated catch-all route. The
+ * procedure gate sets `resource` to the `functionPath` so the x402 challenge
+ * names the paid function (x402 core falls back to the request URL otherwise —
+ * every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
+ * procedures apart).
+ * @experimental
+ */
 type ChargeRouteOverrides = Pick<RouteConfig, "description" | "resource">;
 /**
-* Behaviour knobs for {@link createChargeMiddleware} beyond route metadata.
-* @experimental
-*/
+ * Behaviour knobs for {@link createChargeMiddleware} beyond route metadata.
+ * @experimental
+ */
 interface ChargeMiddlewareOptions {
   /**
-  * Settle the verified payment **before** dispatching `runHandler`, instead
-  * of after. Use this for a mutation/procedure gate: a settlement failure
-  * then means the handler never runs at all, so a paid mutation's writes can
-  * never be committed without payment (the free-execution gap X402-04
-  * closes). Once settlement succeeds the payment is final (on-chain) — a
-  * handler failure after that point is a normal application error, not a
-  * payment to unwind: there is nothing left to cancel, so it is not caught
-  * here and simply propagates.
-  *
-  * Default `false` (settle-after, the historical behaviour): the handler's
-  * response is passed to settlement as transport context (`responseHeaders`
-  * — read by some schemes for settlement overrides), and a handler throw
-  * still releases the verified-but-unsettled payment via
-  * `cancellationDispatcher.cancel`. Because settlement can still fail after
-  * the handler already ran on this path, `.x402()` handlers gated this way
-  * MUST be idempotent or compensatable — see the `@lunora/x402` charge docs.
-  */
+   * Settle the verified payment **before** dispatching `runHandler`, instead
+   * of after. Use this for a mutation/procedure gate: a settlement failure
+   * then means the handler never runs at all, so a paid mutation's writes can
+   * never be committed without payment (the free-execution gap X402-04
+   * closes). Once settlement succeeds the payment is final (on-chain) — a
+   * handler failure after that point is a normal application error, not a
+   * payment to unwind: there is nothing left to cancel, so it is not caught
+   * here and simply propagates.
+   *
+   * Default `false` (settle-after, the historical behaviour): the handler's
+   * response is passed to settlement as transport context (`responseHeaders`
+   * — read by some schemes for settlement overrides), and a handler throw
+   * still releases the verified-but-unsettled payment via
+   * `cancellationDispatcher.cancel`. Because settlement can still fail after
+   * the handler already ran on this path, `.x402()` handlers gated this way
+   * MUST be idempotent or compensatable — see the `@lunora/x402` charge docs.
+   */
   readonly settleBeforeHandler?: boolean;
 }
 /**
-* Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
-* facilitator support once (via `initialize()`), so call this once per config
-* and reuse the result across requests. `routeOverrides` layers extra route
-* metadata (e.g. `resource`) onto the generated catch-all route; `options`
-* controls settlement ordering (see {@link ChargeMiddlewareOptions}).
-* @experimental
-*/
+ * Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
+ * facilitator support once (via `initialize()`), so call this once per config
+ * and reuse the result across requests. `routeOverrides` layers extra route
+ * metadata (e.g. `resource`) onto the generated catch-all route; `options`
+ * controls settlement ordering (see {@link ChargeMiddlewareOptions}).
+ * @experimental
+ */
 declare const createChargeMiddleware: (config: X402ChargeConfig, routeOverrides?: ChargeRouteOverrides, options?: ChargeMiddlewareOptions) => Promise<ChargeMiddleware>;
 /**
-* Charge config for the procedure gate: the worker-level settlement vocabulary
-* (network, recipient, facilitator) minus `price` — price is per-procedure and
-* arrives with each {@link X402ProcedureSpec}.
-* @experimental
-*/
+ * Charge config for the procedure gate: the worker-level settlement vocabulary
+ * (network, recipient, facilitator) minus `price` — price is per-procedure and
+ * arrives with each {@link X402ProcedureSpec}.
+ * @experimental
+ */
 type X402ProcedureChargeConfig = Omit<X402ChargeConfig, "price">;
 /**
-* The per-RPC charge spec the runtime passes the gate for each paid dispatch.
-* @experimental
-*/
+ * The per-RPC charge spec the runtime passes the gate for each paid dispatch.
+ * @experimental
+ */
 interface X402ProcedureSpec {
   /** The `file:function` id of the paid procedure; becomes the x402 challenge `resource`. */
   readonly functionPath: string;
@@ -114,26 +114,26 @@ interface X402ProcedureSpec {
   readonly price: X402Price;
 }
 /**
-* Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
-* request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
-* attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
-* runs the actual shard forward — settlement happens **before** `dispatch` is
-* invoked (settle-first), so a settlement failure means the shard forward
-* (the mutation's commit) never runs at all — no committed-but-unpaid write is
-* possible. `deps.waitUntil`, when supplied (the request's `ctx.waitUntil`),
-* keeps the opt-in receipt sink alive past the response.
-* @experimental
-*/
+ * Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
+ * request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
+ * attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
+ * runs the actual shard forward — settlement happens **before** `dispatch` is
+ * invoked (settle-first), so a settlement failure means the shard forward
+ * (the mutation's commit) never runs at all — no committed-but-unpaid write is
+ * possible. `deps.waitUntil`, when supplied (the request's `ctx.waitUntil`),
+ * keeps the opt-in receipt sink alive past the response.
+ * @experimental
+ */
 type X402ProcedureChargeGate = (request: Request, spec: X402ProcedureSpec, dispatch: () => Promise<Response>, deps?: ChargeHandlerDeps) => Promise<Response>;
 /**
-* Build the injectable procedure charge gate for `config`. One initialised
-* {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
-* function's price + `resource`), since `createChargeMiddleware` fetches
-* facilitator support on first use. A failed init is not cached, so a transient
-* facilitator outage retries on the next request. Settlement runs before
-* `dispatch` (`settleBeforeHandler: true`) since `dispatch` commits the
-* procedure's real mutation — see `createChargeMiddleware`'s `ChargeMiddlewareOptions`.
-* @experimental
-*/
+ * Build the injectable procedure charge gate for `config`. One initialised
+ * {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
+ * function's price + `resource`), since `createChargeMiddleware` fetches
+ * facilitator support on first use. A failed init is not cached, so a transient
+ * facilitator outage retries on the next request. Settlement runs before
+ * `dispatch` (`settleBeforeHandler: true`) since `dispatch` commits the
+ * procedure's real mutation — see `createChargeMiddleware`'s `ChargeMiddlewareOptions`.
+ * @experimental
+ */
 declare const createProcedureChargeGate: (config: X402ProcedureChargeConfig) => X402ProcedureChargeGate;
 export { type ChargeHandler, type ChargeHandlerDeps, type ChargeMiddleware, type ChargeMiddlewareOptions, type ChargeRouteOverrides, type FacilitatorConfig, type HttpActionHandler, type X402ChargeConfig, type X402Price, type X402ProcedureChargeConfig, type X402ProcedureChargeGate, type X402ProcedureSpec, createChargeMiddleware, createFacilitatorClient, createProcedureChargeGate, withX402 };

package/dist/charge/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-5Nqi5iox.js";
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-5Nqi5iox.js";
+import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-B-NYmHgG.js";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-B-NYmHgG.js";
 import { HTTPFacilitatorClient } from '@x402/core/server';
 import { RouteConfig } from '@x402/core/http';
 import '@x402/evm';
@@ -7,106 +7,106 @@ import '@x402/svm';
 import '@x402/core/client';
 import '@x402/core/types';
 /**
-* Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
-*
-* `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
-* call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
-* `supported`), so the same header map is handed to each. With no config the
-* client points at the public {@link resolveFacilitatorUrl default} and sends no
-* auth headers.
-* @experimental
-*/
+ * Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
+ *
+ * `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
+ * call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
+ * `supported`), so the same header map is handed to each. With no config the
+ * client points at the public {@link resolveFacilitatorUrl default} and sends no
+ * auth headers.
+ * @experimental
+ */
 declare const createFacilitatorClient: (config?: FacilitatorConfig) => HTTPFacilitatorClient;
 /**
-* A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
-* @experimental
-*/
+ * A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
+ * @experimental
+ */
 type HttpActionHandler<Context> = (context: Context, request: Request) => Promise<Response> | Response;
 /**
-* Gate `handler` behind an x402 paywall described by `config`. Returns a handler
-* of the same shape, ready to pass to `httpAction`.
-* @experimental
-*/
+ * Gate `handler` behind an x402 paywall described by `config`. Returns a handler
+ * of the same shape, ready to pass to `httpAction`.
+ * @experimental
+ */
 declare const withX402: <Context>(config: X402ChargeConfig, handler: HttpActionHandler<Context>) => HttpActionHandler<Context>;
 /**
-* Runs the protected resource handler, producing the Response to gate.
-* @experimental
-*/
+ * Runs the protected resource handler, producing the Response to gate.
+ * @experimental
+ */
 type ChargeHandler = () => Promise<Response> | Response;
 /**
-* Per-request platform seams `handle` can use, beyond the request/handler pair.
-* @experimental
-*/
+ * Per-request platform seams `handle` can use, beyond the request/handler pair.
+ * @experimental
+ */
 interface ChargeHandlerDeps {
   /**
-  * Keep background work (the receipt sink) alive past the response — the
-  * request's `ctx.waitUntil`. Absent on paths with no platform execution
-  * context reaching the middleware (e.g. today's HTTP-action rail).
-  */
+   * Keep background work (the receipt sink) alive past the response — the
+   * request's `ctx.waitUntil`. Absent on paths with no platform execution
+   * context reaching the middleware (e.g. today's HTTP-action rail).
+   */
   readonly waitUntil?: (promise: Promise<unknown>) => void;
 }
 /**
-* A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
-* @experimental
-*/
+ * A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
+ * @experimental
+ */
 interface ChargeMiddleware {
   /** Gate `request`: challenge / verify / settle around `runHandler`. */
   handle: (request: Request, runHandler: ChargeHandler, deps?: ChargeHandlerDeps) => Promise<Response>;
 }
 /**
-* Route metadata a caller can layer onto the generated catch-all route. The
-* procedure gate sets `resource` to the `functionPath` so the x402 challenge
-* names the paid function (x402 core falls back to the request URL otherwise —
-* every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
-* procedures apart).
-* @experimental
-*/
+ * Route metadata a caller can layer onto the generated catch-all route. The
+ * procedure gate sets `resource` to the `functionPath` so the x402 challenge
+ * names the paid function (x402 core falls back to the request URL otherwise —
+ * every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
+ * procedures apart).
+ * @experimental
+ */
 type ChargeRouteOverrides = Pick<RouteConfig, "description" | "resource">;
 /**
-* Behaviour knobs for {@link createChargeMiddleware} beyond route metadata.
-* @experimental
-*/
+ * Behaviour knobs for {@link createChargeMiddleware} beyond route metadata.
+ * @experimental
+ */
 interface ChargeMiddlewareOptions {
   /**
-  * Settle the verified payment **before** dispatching `runHandler`, instead
-  * of after. Use this for a mutation/procedure gate: a settlement failure
-  * then means the handler never runs at all, so a paid mutation's writes can
-  * never be committed without payment (the free-execution gap X402-04
-  * closes). Once settlement succeeds the payment is final (on-chain) — a
-  * handler failure after that point is a normal application error, not a
-  * payment to unwind: there is nothing left to cancel, so it is not caught
-  * here and simply propagates.
-  *
-  * Default `false` (settle-after, the historical behaviour): the handler's
-  * response is passed to settlement as transport context (`responseHeaders`
-  * — read by some schemes for settlement overrides), and a handler throw
-  * still releases the verified-but-unsettled payment via
-  * `cancellationDispatcher.cancel`. Because settlement can still fail after
-  * the handler already ran on this path, `.x402()` handlers gated this way
-  * MUST be idempotent or compensatable — see the `@lunora/x402` charge docs.
-  */
+   * Settle the verified payment **before** dispatching `runHandler`, instead
+   * of after. Use this for a mutation/procedure gate: a settlement failure
+   * then means the handler never runs at all, so a paid mutation's writes can
+   * never be committed without payment (the free-execution gap X402-04
+   * closes). Once settlement succeeds the payment is final (on-chain) — a
+   * handler failure after that point is a normal application error, not a
+   * payment to unwind: there is nothing left to cancel, so it is not caught
+   * here and simply propagates.
+   *
+   * Default `false` (settle-after, the historical behaviour): the handler's
+   * response is passed to settlement as transport context (`responseHeaders`
+   * — read by some schemes for settlement overrides), and a handler throw
+   * still releases the verified-but-unsettled payment via
+   * `cancellationDispatcher.cancel`. Because settlement can still fail after
+   * the handler already ran on this path, `.x402()` handlers gated this way
+   * MUST be idempotent or compensatable — see the `@lunora/x402` charge docs.
+   */
   readonly settleBeforeHandler?: boolean;
 }
 /**
-* Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
-* facilitator support once (via `initialize()`), so call this once per config
-* and reuse the result across requests. `routeOverrides` layers extra route
-* metadata (e.g. `resource`) onto the generated catch-all route; `options`
-* controls settlement ordering (see {@link ChargeMiddlewareOptions}).
-* @experimental
-*/
+ * Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
+ * facilitator support once (via `initialize()`), so call this once per config
+ * and reuse the result across requests. `routeOverrides` layers extra route
+ * metadata (e.g. `resource`) onto the generated catch-all route; `options`
+ * controls settlement ordering (see {@link ChargeMiddlewareOptions}).
+ * @experimental
+ */
 declare const createChargeMiddleware: (config: X402ChargeConfig, routeOverrides?: ChargeRouteOverrides, options?: ChargeMiddlewareOptions) => Promise<ChargeMiddleware>;
 /**
-* Charge config for the procedure gate: the worker-level settlement vocabulary
-* (network, recipient, facilitator) minus `price` — price is per-procedure and
-* arrives with each {@link X402ProcedureSpec}.
-* @experimental
-*/
+ * Charge config for the procedure gate: the worker-level settlement vocabulary
+ * (network, recipient, facilitator) minus `price` — price is per-procedure and
+ * arrives with each {@link X402ProcedureSpec}.
+ * @experimental
+ */
 type X402ProcedureChargeConfig = Omit<X402ChargeConfig, "price">;
 /**
-* The per-RPC charge spec the runtime passes the gate for each paid dispatch.
-* @experimental
-*/
+ * The per-RPC charge spec the runtime passes the gate for each paid dispatch.
+ * @experimental
+ */
 interface X402ProcedureSpec {
   /** The `file:function` id of the paid procedure; becomes the x402 challenge `resource`. */
   readonly functionPath: string;
@@ -114,26 +114,26 @@ interface X402ProcedureSpec {
   readonly price: X402Price;
 }
 /**
-* Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
-* request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
-* attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
-* runs the actual shard forward — settlement happens **before** `dispatch` is
-* invoked (settle-first), so a settlement failure means the shard forward
-* (the mutation's commit) never runs at all — no committed-but-unpaid write is
-* possible. `deps.waitUntil`, when supplied (the request's `ctx.waitUntil`),
-* keeps the opt-in receipt sink alive past the response.
-* @experimental
-*/
+ * Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
+ * request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
+ * attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
+ * runs the actual shard forward — settlement happens **before** `dispatch` is
+ * invoked (settle-first), so a settlement failure means the shard forward
+ * (the mutation's commit) never runs at all — no committed-but-unpaid write is
+ * possible. `deps.waitUntil`, when supplied (the request's `ctx.waitUntil`),
+ * keeps the opt-in receipt sink alive past the response.
+ * @experimental
+ */
 type X402ProcedureChargeGate = (request: Request, spec: X402ProcedureSpec, dispatch: () => Promise<Response>, deps?: ChargeHandlerDeps) => Promise<Response>;
 /**
-* Build the injectable procedure charge gate for `config`. One initialised
-* {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
-* function's price + `resource`), since `createChargeMiddleware` fetches
-* facilitator support on first use. A failed init is not cached, so a transient
-* facilitator outage retries on the next request. Settlement runs before
-* `dispatch` (`settleBeforeHandler: true`) since `dispatch` commits the
-* procedure's real mutation — see `createChargeMiddleware`'s `ChargeMiddlewareOptions`.
-* @experimental
-*/
+ * Build the injectable procedure charge gate for `config`. One initialised
+ * {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
+ * function's price + `resource`), since `createChargeMiddleware` fetches
+ * facilitator support on first use. A failed init is not cached, so a transient
+ * facilitator outage retries on the next request. Settlement runs before
+ * `dispatch` (`settleBeforeHandler: true`) since `dispatch` commits the
+ * procedure's real mutation — see `createChargeMiddleware`'s `ChargeMiddlewareOptions`.
+ * @experimental
+ */
 declare const createProcedureChargeGate: (config: X402ProcedureChargeConfig) => X402ProcedureChargeGate;
 export { type ChargeHandler, type ChargeHandlerDeps, type ChargeMiddleware, type ChargeMiddlewareOptions, type ChargeRouteOverrides, type FacilitatorConfig, type HttpActionHandler, type X402ChargeConfig, type X402Price, type X402ProcedureChargeConfig, type X402ProcedureChargeGate, type X402ProcedureSpec, createChargeMiddleware, createFacilitatorClient, createProcedureChargeGate, withX402 };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-5Nqi5iox.mjs";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-B-NYmHgG.mjs";
 import '@x402/evm';
 import '@x402/svm';
 import '@x402/core/http';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-5Nqi5iox.js";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-B-NYmHgG.js";
 import '@x402/evm';
 import '@x402/svm';
 import '@x402/core/http';