mppx 0.12.0 → 0.13.1

package/dist/cli/plugins/tempo.js

@@ -12,7 +12,7 @@ import * as Constants from '../../Constants.js';
 import * as Credential from '../../Credential.js';
 import { tempo as tempoMethods } from '../../tempo/client/index.js';
 import { tip20ChannelEscrow } from '../../tempo/session/precompile/Protocol.js';
-import { signVoucher } from '../../tempo/session/precompile/Voucher.js';
+import { signCloseAuthorization, signVoucher } from '../../tempo/session/precompile/Voucher.js';
 import { createDefaultStore, createKeychain, resolveAccountName } from '../account.js';
 import { fetchTokenInfo, fmtBalance, isTempoAccount, isTestnet, link, pc, resolveChain, resolveRpcUrl, } from '../utils.js';
 import { createPlugin } from './plugin.js';
@@ -227,14 +227,21 @@ export function tempo() {
                     const descriptor = _session?.descriptor;
                     if (!descriptor)
                         throw new Error('session descriptor not available');
+                    const voucher = { channelId: channelId, cumulativeAmount };
+                    const signature = await signVoucher(client, account, voucher, escrowContract, chainId);
                     return Credential.serialize({
                         challenge,
                         payload: {
                             action,
                             channelId,
+                            ...(action === 'close'
+                                ? {
+                                    closeSignature: await signCloseAuthorization(client, account, voucher, escrowContract, chainId),
+                                }
+                                : {}),
                             descriptor,
                             cumulativeAmount: cumulativeAmount.toString(),
-                            signature: await signVoucher(client, account, { channelId: channelId, cumulativeAmount }, escrowContract, chainId),
+                            signature,
                         },
                         source: `did:pkh:eip155:${chainId}:${account.address}`,
                     });

package/dist/cli/utils.d.ts

@@ -96,7 +96,17 @@ export declare const usdc: Address;
 export declare const mainnetTokens: readonly [`0x${string}`, `0x${string}`];
 export declare const testnetTokens: readonly ['0x20c0000000000000000000000000000000000000', '0x20c0000000000000000000000000000000000001', '0x20c0000000000000000000000000000000000002', '0x20c0000000000000000000000000000000000003'];
 export declare function isTestnet(chain: Chain): boolean;
-export declare function fetchTokenInfo(client: ReturnType<typeof createClient>, token: Address, account: Address): Promise<{
+/**
+ * Fetches a Tempo token balance and display metadata.
+ *
+ * By default, unavailable decimals fall back to six for display compatibility.
+ * Set `requireDecimals` to throw instead when trusted on-chain decimals cannot
+ * be resolved.
+ */
+export declare function fetchTokenInfo(client: ReturnType<typeof createClient>, token: Address, account: Address, options?: {
+    /** Throws instead of using six decimals when token metadata is unavailable. */
+    requireDecimals?: boolean;
+}): Promise<{
     balance: bigint;
     decimals: number;
     symbol: string;

package/dist/cli/utils.js

@@ -259,14 +259,25 @@ function toBaseUnitAmount(value) {
 export function isTestnet(chain) {
     return chain.id !== tempoMainnet.id;
 }
-export async function fetchTokenInfo(client, token, account) {
+/**
+ * Fetches a Tempo token balance and display metadata.
+ *
+ * By default, unavailable decimals fall back to six for display compatibility.
+ * Set `requireDecimals` to throw instead when trusted on-chain decimals cannot
+ * be resolved.
+ */
+export async function fetchTokenInfo(client, token, account, options = {}) {
     const { Actions } = await import('viem/tempo');
     const [balance, metadata] = await Promise.all([
         Actions.token
             .getBalance(client, { account, token })
             .then(toBaseUnitAmount)
             .catch(() => 0n),
-        Actions.token.getMetadata(client, { token }).catch(() => ({ symbol: token })),
+        Actions.token.getMetadata(client, { token }).catch((error) => {
+            if (options.requireDecimals)
+                throw error;
+            return { symbol: token };
+        }),
     ]);
     const knownSymbols = {
         [pathUsd]: 'PathUSD',
@@ -274,6 +285,8 @@ export async function fetchTokenInfo(client, token, account) {
     };
     const symbol = knownSymbols[token] ?? metadata.symbol;
     const decimals = 'decimals' in metadata && typeof metadata.decimals === 'number' ? metadata.decimals : 6;
+    if (options.requireDecimals && !('decimals' in metadata && typeof metadata.decimals === 'number'))
+        throw new Error('Token decimals are unavailable.');
     return { balance, symbol, decimals, token };
 }
 export async function fetchBalanceLines(address, opts) {

package/dist/cli/validate/challenge.d.ts

@@ -11,6 +11,8 @@ export declare function validateChallenge(baseUrl: string, endpoint: EndpointSpe
     resolvedBody?: string | undefined;
     challenges?: Challenge.Challenge[] | undefined;
 }>;
+/** Validates that challenge realms cover the server hostname. */
+export declare function validateRealmMatchesHost(challenges: Challenge.Challenge[], serverHost: string, results: CheckResult[]): void;
 export declare function validateErrorHandling(baseUrl: string, endpoint: EndpointSpec, options?: {
     body?: string | undefined;
     query?: string[] | undefined;

package/dist/cli/validate/challenge.js

@@ -15,7 +15,14 @@ function detectTestnet(challenge) {
 }
 export async function validateChallenge(baseUrl, endpoint, verbose, options) {
     const results = [];
-    const url = buildUrl(baseUrl, endpoint, options?.query);
+    let url;
+    try {
+        url = buildUrl(baseUrl, endpoint, options?.query);
+    }
+    catch (error) {
+        results.push(fail('Request URL valid', error.message));
+        return { results };
+    }
     const fetchHeaders = parseHeaders(options?.extraHeaders);
     let fetchBody;
     // If the user explicitly provided a body, include it on the first request
@@ -167,11 +174,19 @@ function validateExpiration(challenges, results) {
     const soonest = Math.min(...challenges.map((ch) => new Date(ch.expires).getTime() - now.getTime()));
     results.push(check('Challenge expires in the future', `${Math.round(soonest / 60000)}m from now`));
 }
-function validateRealmMatchesHost(challenges, serverHost, results) {
+/** Validates that challenge realms cover the server hostname. */
+export function validateRealmMatchesHost(challenges, serverHost, results) {
+    const normalizeHostname = (value) => value.toLowerCase().replace(/\.$/, '');
+    const normalizedServerHost = normalizeHostname(serverHost);
     const realms = [...new Set(challenges.map((ch) => ch.realm ?? ''))];
-    const badRealms = realms.filter((r) => r && r !== serverHost && !serverHost.endsWith(`.${r}`));
+    const badRealms = realms.filter((realm) => {
+        const normalizedRealm = normalizeHostname(realm);
+        return (!normalizedRealm ||
+            (normalizedRealm !== normalizedServerHost &&
+                !normalizedServerHost.endsWith(`.${normalizedRealm}`)));
+    });
     if (badRealms.length > 0) {
-        results.push(warn('Realm matches server hostname', `realm="${badRealms[0]}" vs host="${serverHost}"`, 'Set the realm to your production hostname (or base domain) in the challenge.'));
+        results.push(fail('Realm matches server hostname', `realm="${badRealms[0]}" vs host="${serverHost}"`, 'Set the realm to your production hostname (or base domain) in the challenge.'));
     }
     else {
         results.push(check('Realm matches server hostname'));

package/dist/cli/validate/discovery.d.ts

@@ -9,5 +9,6 @@ export declare function fetchDiscoveryDoc(baseUrl: string): Promise<{
 export declare function validateLlmsDoc(baseUrl: string): Promise<CheckResult>;
 export declare function extractEndpointsFromDiscovery(doc: Record<string, unknown>): EndpointSpec[];
 export declare function extractRequestBodyFromDiscovery(doc: Record<string, unknown>, endpoint: EndpointSpec): string | undefined;
+/** Builds an endpoint URL and rejects paths that could escape the discovery document's origin. */
 export declare function buildUrl(baseUrl: string, endpoint: EndpointSpec, query?: string[]): string;
 //# sourceMappingURL=discovery.d.ts.map

package/dist/cli/validate/discovery.js

@@ -117,14 +117,23 @@ export function extractRequestBodyFromDiscovery(doc, endpoint) {
     }
     return undefined;
 }
+/** Builds an endpoint URL and rejects paths that could escape the discovery document's origin. */
 export function buildUrl(baseUrl, endpoint, query) {
+    if (!endpoint.path.startsWith('/') ||
+        endpoint.path.startsWith('//') ||
+        endpoint.path.includes('\\'))
+        throw new Error(`OpenAPI path must be an origin-relative path: ${endpoint.path}`);
     let path = endpoint.path;
     if (endpoint.parameters) {
         path = substitutePathParams(path, endpoint.parameters);
     }
     // Strip leading slash so URL resolves relative to baseUrl's path, not root.
     const relativePath = path.startsWith('/') ? path.slice(1) : path;
-    let url = new URL(relativePath, baseUrl.replace(/\/?$/, '/')).href;
+    const base = new URL(baseUrl.replace(/\/?$/, '/'));
+    const resolved = new URL(relativePath, base);
+    if (resolved.origin !== base.origin)
+        throw new Error(`OpenAPI path must be an origin-relative path: ${endpoint.path}`);
+    let url = resolved.href;
     if (query) {
         const u = new URL(url);
         for (const q of query) {

package/dist/cli/validate/payment.js

@@ -15,6 +15,7 @@ import { isTempoSessionChallenge } from '../../tempo/session/client/Transports.j
 import { resolveAccount, resolveAccountName } from '../account.js';
 import { assertSamePaymentRequest, flattenConfigMethods, loadConfig, preparePayment, resolvePlugin, } from '../internal.js';
 import { fetchTokenInfo, confirm, pc } from '../utils.js';
+import { validateRealmMatchesHost } from './challenge.js';
 import { buildUrl } from './discovery.js';
 import { check, fail, fetchWithTimeout, formatBytes, isValidIntegerAmount, parseHeaders, skip, warn, } from './helpers.js';
 async function provisionAndPayTestnet(challenge, verbose, silent) {
@@ -95,16 +96,19 @@ function resolveStripeKey(verbose) {
 }
 async function fetchEvmTokenInfo(chain, token, account) {
     const client = createClient({ chain, transport: http() });
-    const [balance, symbol] = await Promise.all([
-        readContract(client, {
-            address: token,
-            abi: erc20Abi,
-            functionName: 'balanceOf',
-            args: [account],
-        }),
+    const [balance, decimals, symbol] = await Promise.all([
+        account
+            ? readContract(client, {
+                address: token,
+                abi: erc20Abi,
+                functionName: 'balanceOf',
+                args: [account],
+            })
+            : 0n,
+        readContract(client, { address: token, abi: erc20Abi, functionName: 'decimals' }),
         readContract(client, { address: token, abi: erc20Abi, functionName: 'symbol' }).catch(() => undefined),
     ]);
-    return { balance, symbol: symbol ?? undefined };
+    return { balance, decimals, symbol: symbol ?? undefined };
 }
 function resolveEvmChain(chainId) {
     const all = Object.values(viemChains);
@@ -162,6 +166,14 @@ export async function validatePaymentFlow(baseUrl, endpoint, verbose, options) {
         results.push(fail('Payment: parse challenge', 'No Payment challenges in response'));
         return results;
     }
+    const realmResults = [];
+    validateRealmMatchesHost(challenges, new URL(url).hostname, realmResults);
+    const realmFailures = realmResults.filter((result) => result.severity === 'fail');
+    if (realmFailures.length > 0) {
+        results.push(...realmFailures);
+        options.onResults?.(realmFailures);
+        return results;
+    }
     const loaded = await loadConfig().catch(() => undefined);
     // Testnet Tempo: always use ephemeral wallet (zero-setup, free money)
     const tempoTestnetChallenge = challenges.find((ch) => {
@@ -274,7 +286,7 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
     const requiredAmount = isValidIntegerAmount(request.amount)
         ? BigInt(request.amount)
         : undefined;
-    const decimals = methodDetails?.decimals ?? request.decimals ?? 6;
+    let decimals = methodDetails?.decimals ?? request.decimals ?? 6;
     const currency = request.currency;
     const { plugin, method: directMethod } = resolvePlugin(challenge, loaded?.config);
     if (!plugin && !directMethod) {
@@ -306,22 +318,30 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
         if (chainId)
             paymentChain = resolveEvmChain(chainId);
     }
+    if (requiredAmount && currency && !paymentChain) {
+        results.push(skip(tag, 'unable to resolve payment chain and verify token decimals'));
+        return;
+    }
     let tokenSymbol;
-    if (walletAddress && requiredAmount && currency && paymentChain) {
+    if (requiredAmount && currency && paymentChain) {
         try {
             let balance;
             if (challenge.method === Constants.Methods.tempo) {
                 const client = createClient({ chain: paymentChain, transport: http() });
-                const info = await fetchTokenInfo(client, currency, walletAddress);
+                const info = await fetchTokenInfo(client, currency, (walletAddress ?? zeroAddress), {
+                    requireDecimals: true,
+                });
                 balance = info.balance;
+                decimals = info.decimals;
                 tokenSymbol = info.symbol;
             }
             else {
                 const info = await fetchEvmTokenInfo(paymentChain, currency, walletAddress);
                 balance = info.balance;
+                decimals = info.decimals;
                 tokenSymbol = info.symbol;
             }
-            if (balance < requiredAmount) {
+            if (walletAddress && balance < requiredAmount) {
                 const requiredDisplay = formatAmount(requiredAmount, decimals);
                 const balanceDisplay = formatAmount(balance, decimals);
                 const symbol = tokenSymbol ?? 'tokens';
@@ -332,6 +352,8 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
         catch (e) {
             if (verbose)
                 console.log(pc.dim(`    Balance check skipped: ${e.message}`));
+            results.push(skip(tag, 'unable to verify token balance and decimals from the payment chain'));
+            return;
         }
     }
     // Prompt

package/dist/client/Methods.d.ts

@@ -4,6 +4,4 @@ export { subscription } from '../tempo/client/Subscription.js';
 export { session, tempo } from '../tempo/client/index.js';
 export { session as sessionMethod } from '../tempo/session/client/Session.js';
 export { sessionManager } from '../tempo/session/client/SessionManager.js';
-export { session as sessionLegacy } from '../tempo/legacy/client/index.js';
-export { sessionManager as sessionLegacyManager } from '../tempo/legacy/client/index.js';
 //# sourceMappingURL=Methods.d.ts.map

package/dist/client/Methods.js

@@ -4,6 +4,4 @@ export { subscription } from '../tempo/client/Subscription.js';
 export { session, tempo } from '../tempo/client/index.js';
 export { session as sessionMethod } from '../tempo/session/client/Session.js';
 export { sessionManager } from '../tempo/session/client/SessionManager.js';
-export { session as sessionLegacy } from '../tempo/legacy/client/index.js';
-export { sessionManager as sessionLegacyManager } from '../tempo/legacy/client/index.js';
 //# sourceMappingURL=Methods.js.map

package/dist/client/Mppx.js

@@ -181,6 +181,7 @@ export function create(config) {
                     context,
                     fetch: attestedFetch,
                     input: preparedHttp.replayRequest,
+                    signal: preparedHttp.replayRequest.signal,
                 });
             return payment.createCredential(context);
         });

package/dist/client/index.d.ts

@@ -1,7 +1,7 @@
 export * as Constants from '../Constants.js';
 export * as Expires from '../Expires.js';
 export * as Fetch from './internal/Fetch.js';
-export { evm, session, sessionManager, sessionMethod, sessionLegacy, sessionLegacyManager, stripe, tempo, } from './Methods.js';
+export { evm, session, sessionManager, sessionMethod, stripe, tempo } from './Methods.js';
 export { createChannelStore, createJsonChannelStore, entryKey, type ChannelStore, type JsonChannelKv, } from '../tempo/session/client/ChannelStore.js';
 export type { ChargeContext } from '../tempo/client/Charge.js';
 export type { ResolveAccount, ResolveAccountCall, ResolveAccountInfo, ResolveAccountOperation, } from '../tempo/client/ResolveAccount.js';

package/dist/client/index.js

@@ -1,7 +1,7 @@
 export * as Constants from '../Constants.js';
 export * as Expires from '../Expires.js';
 export * as Fetch from './internal/Fetch.js';
-export { evm, session, sessionManager, sessionMethod, sessionLegacy, sessionLegacyManager, stripe, tempo, } from './Methods.js';
+export { evm, session, sessionManager, sessionMethod, stripe, tempo } from './Methods.js';
 export { createChannelStore, createJsonChannelStore, entryKey, } from '../tempo/session/client/ChannelStore.js';
 export * as Mppx from './Mppx.js';
 export * as Transport from './Transport.js';

package/dist/client/internal/Fetch.d.ts

@@ -171,6 +171,8 @@ export declare function createEventDispatcher<methods extends readonly Method.An
 /** @internal */
 export declare function unwrapFetch(fetch: typeof globalThis.fetch): typeof globalThis.fetch;
 /** @internal */
+export declare function resolveRequestSignal(input: RequestInfo | URL, init: RequestInit | undefined): AbortSignal | undefined;
+/** @internal */
 export declare function validateCredentialHeaderValue(credential: string): void;
 /** @internal */
 /** @internal */

package/dist/client/internal/Fetch.js

@@ -122,6 +122,7 @@ export function from(config) {
                             context: credentialContext,
                             fetch: baseFetch,
                             input: paymentInput,
+                            signal: resolveRequestSignal(input, init),
                         }),
                     };
                     const promise = attempt
@@ -576,8 +577,13 @@ function cloneRequestInput(input) {
         return input;
     }
 }
-function resolveRequestSignal(input, init) {
-    return init?.signal ?? (input instanceof Request ? input.signal : undefined);
+/** @internal */
+export function resolveRequestSignal(input, init) {
+    if (init?.signal === null)
+        return undefined;
+    if (init?.signal !== undefined)
+        return init.signal;
+    return input instanceof Request ? input.signal : undefined;
 }
 /** @internal */
 function isWrappedFetch(fetch) {

package/dist/client/internal/MethodChallenge.d.ts

@@ -7,6 +7,7 @@ export type HandlerParameters = {
     context?: unknown;
     fetch: typeof globalThis.fetch;
     input: RequestInfo | URL;
+    signal?: AbortSignal | undefined;
 };
 /** Internal client-method challenge hook. */
 export type Handler = (parameters: HandlerParameters) => MaybePromise<void>;

package/dist/evm/Types.js

@@ -87,7 +87,7 @@ export function authorizationDomain(parameters) {
 }
 /** Computes the Payment-auth EVM challenge hash used as the EIP-3009 nonce. */
 export function challengeHash(challenge) {
-    return Hash.keccak256(Bytes.fromString(`${challenge.id}${challenge.realm}`), {
+    return Hash.keccak256(Bytes.fromString(JSON.stringify([challenge.id, challenge.realm])), {
         as: 'Hex',
     });
 }

package/dist/evm/server/Charge.js

@@ -171,6 +171,7 @@ function createPaths(config) {
 function createMppPath() {
     const transport = ServerTransport.http();
     return {
+        credentialHeaders: transport.credentialHeaders ?? [],
         bindCredential: (options) => transport.bindCredential?.(options) ?? options.credential,
         captureRequest: transport.captureRequest,
         getCredential: transport.getCredential,
@@ -181,10 +182,14 @@ function createMppPath() {
 function httpTransport(paths) {
     return ServerTransport.from({
         name: 'evm-http',
+        credentialHeaders: [
+            ...new Set([...paths.mpp.credentialHeaders, ...paths.x402.credentialHeaders]),
+        ],
         captureRequest: paths.mpp.captureRequest,
         getCredential(input) {
             return paths.mpp.getCredential(input) ?? paths.x402.getCredential(input);
         },
+        matchCredential: paths.x402.matchCredential,
         bindCredential(options) {
             if (X402.isPendingCredential(options.credential))
                 return paths.x402.bindCredential(options);

package/dist/integrations/x402/Evm.js

@@ -4,7 +4,6 @@ import { evm } from '../../evm/server/Methods.js';
 import { eip3009 } from '../../evm/Types.js';
 import * as Expires from '../../Expires.js';
 import * as Mppx from '../../server/Mppx.js';
-import { tempo } from '../../tempo/server/Methods.js';
 import * as Types from '../../x402/Types.js';
 /** Creates a native MPP handler backed by a compatible x402 EVM requirement. */
 export function createHandler(parameters) {
@@ -37,8 +36,10 @@ export function createHandler(parameters) {
             return { reference: result.reference };
         },
     });
+    // Only advertise a native rail whose credential can be verified and settled
+    // by the selected x402 scheme. A Tempo transaction is not an EIP-3009 payload.
     const payment = Mppx.create({
-        methods: [tempo.charge({ recipient: normalizeAddress(requirement.payTo) }), evmMethod],
+        methods: [evmMethod],
         ...(parameters.config.realm ? { realm: parameters.config.realm } : {}),
         secretKey: parameters.config.secretKey,
     });
@@ -50,7 +51,7 @@ export function createHandler(parameters) {
         expires: Expires.seconds(requirement.maxTimeoutSeconds),
         scope: parameters.paymentRequired.resource.url,
     };
-    const handler = payment.compose([payment.tempo.charge, options], [payment.evm.charge, options]);
+    const handler = payment.compose([payment.evm.charge, options]);
     return async (request) => ({
         payment: await handler(request),
         skipHandlerResponse,

package/dist/internal/HeaderCodec.d.ts

@@ -7,8 +7,8 @@ import type * as z from '../zod.js';
  * can opt into the exact wire encoding their protocol expects.
  */
 export declare function createJson<const schema extends z.ZodMiniType>(schema: schema): {
-    encode(value: z.infer<schema>): string;
-    decode(value: string): z.infer<schema>;
+    encode(value: z.output<schema>): string;
+    decode(value: string): z.output<schema>;
 };
 /** Error thrown when a JSON header value is not valid base64-encoded JSON. */
 export declare class InvalidJsonHeaderError extends Error {

package/dist/internal/version.d.ts

@@ -1,5 +1,5 @@
 /** Current mppx package version. */
-export declare const version = "0.12.0";
+export declare const version = "0.13.1";
 /** Canonical SDK identifier for this mppx release. */
-export declare const sdkIdentifier = "mppx/0.12.0";
+export declare const sdkIdentifier = "mppx/0.13.1";
 //# sourceMappingURL=version.d.ts.map

package/dist/internal/version.js

@@ -1,6 +1,6 @@
 // Generated by scripts/sync-version.ts.
 /** Current mppx package version. */
-export const version = '0.12.0';
+export const version = '0.13.1';
 /** Canonical SDK identifier for this mppx release. */
 export const sdkIdentifier = `mppx/${version}`;
 //# sourceMappingURL=version.js.map

package/dist/mcp/client/McpClient.js

@@ -88,14 +88,11 @@ export function isPaymentRequiredError(error) {
 }
 /** @internal */
 async function createCredential(challenge, config) {
-    const { context, methods } = config;
-    const mi = methods.find((m) => m.name === challenge.method && m.intent === challenge.intent);
-    if (!mi)
-        throw new Error(`No method found for "${challenge.method}.${challenge.intent}". Available: ${methods.map((m) => `${m.name}.${m.intent}`).join(', ')}`);
+    const { context, method } = config;
     if (challenge.expires)
         Expires.assert(challenge.expires, challenge.id);
-    const parsedContext = mi.context && context !== undefined ? mi.context.parse(context) : undefined;
-    return mi.createCredential(parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge });
+    const parsedContext = method.context && context !== undefined ? method.context.parse(context) : undefined;
+    return method.createCredential(parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge });
 }
 function createPaymentAwareCallTool(callTool, config) {
     const methods = config.methods.flat();
@@ -121,7 +118,7 @@ function createPaymentAwareCallTool(callTool, config) {
         }
         const credential = await createCredential(selected.challenge, {
             context: call.context,
-            methods,
+            method: selected.method,
         });
         const parsed = Credential.deserialize(credential);
         try {

package/dist/middlewares/elysia.d.ts

@@ -1,16 +1,19 @@
-import { Elysia, type Context } from 'elysia';
+import { Elysia, type AfterHandler, type OptionalHandler } from 'elysia';
 import { type GenerateConfig, type RouteConfig } from '../discovery/OpenApi.js';
 import * as Mppx_core from '../server/Mppx.js';
 import * as Mppx_internal from './internal/mppx.js';
 export * from '../server/Methods.js';
-type ElysiaHook = (context: Context) => Promise<Response | undefined>;
+type ElysiaHook = OptionalHandler & {
+    afterHandle: AfterHandler;
+    beforeHandle: OptionalHandler;
+};
 export declare namespace Mppx {
     /**
      * Creates an Elysia-aware payment handler where each intent
-     * returns an Elysia `beforeHandle` hook.
+     * returns Elysia lifecycle hooks.
      *
-     * Use with `.guard()` to scope payment to specific routes,
-     * or `.onBeforeHandle()` to apply globally.
+     * Use with `.guard()` so both verification and response wrapping are scoped
+     * to the same routes.
      *
      * @example
      * ```ts
@@ -21,7 +24,7 @@ export declare namespace Mppx {
      *
      * const app = new Elysia()
      *   .guard(
-     *     { beforeHandle: mppx.charge({ amount: '1' }) },
+     *     mppx.charge({ amount: '1' }),
      *     (app) => app.get('/premium', () => ({ data: 'paid content' })),
      *   )
      * ```
@@ -29,7 +32,7 @@ export declare namespace Mppx {
     function create<const methods extends Mppx_core.Methods>(config: Mppx_core.create.Config<methods>): Mppx_internal.Wrap<Mppx_core.Mppx<methods>, ElysiaHook>;
 }
 /**
- * Elysia `beforeHandle` hook that gates a route behind a payment intent.
+ * Elysia lifecycle hooks that gate a route behind a payment intent.
  *
  * Returns a 402 challenge if no valid credential is provided.
  *
@@ -43,7 +46,7 @@ export declare namespace Mppx {
  *
  * const app = new Elysia()
  *   .guard(
- *     { beforeHandle: payment(mppx.charge, { amount: '1' }) },
+ *     payment(mppx.charge, { amount: '1' }),
  *     (app) => app.get('/premium', () => ({ data: 'paid content' })),
  *   )
  * ```