mppx 0.11.0 → 0.13.1

package/dist/evm/server/Methods.js

@@ -1,9 +1,57 @@
 import * as Assets from '../Assets.js';
 import * as Chains from '../Chains.js';
 import { charge as charge_ } from './Charge.js';
-/** Creates EVM server methods from shared charge parameters. */
+/**
+ * Creates ordered EVM charge offers from shared parameters.
+ *
+ * Pass `currencies: [token]` for one asset or an ordered list for multiple assets.
+ * Viem token definitions resolve against `chainId`; known assets carry their own
+ * network. Unsupported chain entries are skipped and duplicate chain/address
+ * pairs are removed. An empty resolved list throws.
+ *
+ * Token definitions need explicit EIP-3009 domain metadata. Use
+ * `evm.assets.fromToken(token, { chainId, transfer })` for per-token domains.
+ * A token registry entry alone does not establish EIP-3009 support.
+ *
+ * @example
+ * ```ts
+ * import { evm } from 'mppx/server'
+ *
+ * evm({
+ *   currencies: [evm.assets.base.USDC],
+ *   recipient: '0x742d35Cc6634c0532925a3b844bC9e7595F8fE00',
+ *   settle: async ({ payload }) => settleAuthorization(payload),
+ * })
+ * ```
+ */
 export function evm(parameters) {
-    return [evm.charge(parameters)];
+    if (parameters.currency !== undefined) {
+        if (parameters.currencies !== undefined)
+            throw new Error('Specify either `currency` or `currencies`, not both.');
+        return [evm.charge(parameters)];
+    }
+    const { currencies, ...shared } = parameters;
+    const seen = new Set();
+    const methods = [];
+    for (const currency of currencies) {
+        const chainId = shared.chainId ?? (Assets.isAsset(currency) ? Assets.toChainId(currency.network) : undefined);
+        if (chainId === undefined)
+            throw new Error('EVM currencies require `chainId` or known asset metadata.');
+        const resolved = Assets.resolve(currency, Assets.toNetwork(chainId));
+        if (!resolved)
+            continue;
+        // One shared price cannot price non-USD or unknown-denomination token definitions.
+        if (Assets.isToken(currency) && currency.currency !== 'USD')
+            continue;
+        const key = `${chainId}:${resolved.address.toLowerCase()}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        methods.push(evm.charge({ ...shared, chainId, currency }));
+    }
+    if (methods.length === 0)
+        throw new Error('No accepted EVM currencies for the configured chain.');
+    return methods;
 }
 (function (evm) {
     /** Creates an EVM `charge` server method. */

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.11.0";
+export declare const version = "0.13.1";
 /** Canonical SDK identifier for this mppx release. */
-export declare const sdkIdentifier = "mppx/0.11.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.11.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' })),
  *   )
  * ```

package/dist/middlewares/elysia.js

@@ -1,5 +1,7 @@
 import { Elysia } from 'elysia';
+import { mapResponse as mapElysiaResponse } from 'elysia/adapter/web-standard/handler';
 import { generate } from '../discovery/OpenApi.js';
+import * as Scope from '../server/internal/scope.js';
 import * as Mppx_core from '../server/Mppx.js';
 import * as Mppx_internal from './internal/mppx.js';
 export * from '../server/Methods.js';
@@ -7,10 +9,10 @@ export var Mppx;
 (function (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 +23,7 @@ export var Mppx;
      *
      * const app = new Elysia()
      *   .guard(
-     *     { beforeHandle: mppx.charge({ amount: '1' }) },
+     *     mppx.charge({ amount: '1' }),
      *     (app) => app.get('/premium', () => ({ data: 'paid content' })),
      *   )
      * ```
@@ -32,7 +34,7 @@ export var Mppx;
     Mppx.create = create;
 })(Mppx || (Mppx = {}));
 /**
- * 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.
  *
@@ -46,27 +48,78 @@ export var Mppx;
  *
  * const app = new Elysia()
  *   .guard(
- *     { beforeHandle: payment(mppx.charge, { amount: '1' }) },
+ *     payment(mppx.charge, { amount: '1' }),
  *     (app) => app.get('/premium', () => ({ data: 'paid content' })),
  *   )
  * ```
  */
 export function payment(intent, options) {
-    return async ({ request, set }) => {
-        const result = await intent(options)(request);
+    const pending = new WeakMap();
+    const runBeforeHandle = async ({ request, route, set }, legacyRegistration) => {
+        const scopedRequest = options.scope === undefined && Scope.read(options.meta) === undefined
+            ? Scope.attach(request, `${request.method.toUpperCase()} ${route || new URL(request.url).pathname}`)
+            : request;
+        const result = await intent(options)(scopedRequest);
         if (result.status === 402)
             return result.challenge;
-        const managementResponse = getManagementResponse(result);
+        const managementResponse = await getManagementResponse(result);
         if (managementResponse)
             return managementResponse;
-        const receipt = result.withReceipt(new Response());
-        for (const [key, value] of receipt.headers)
-            set.headers[key] = value;
+        const supportsStreamingReceipts = Mppx_core.supportsStreamingReceipts(result);
+        if (legacyRegistration) {
+            if (supportsStreamingReceipts)
+                return new Response('Streaming payment hooks require paired beforeHandle and afterHandle registration.', { status: 500 });
+            const receiptResponse = await result.withReceipt(new Response(null, { status: 204 }));
+            if (!receiptResponse.ok)
+                return receiptResponse;
+            copyHeaders(receiptResponse, set.headers);
+            return undefined;
+        }
+        pending.set(request, { result, supportsStreamingReceipts });
+        return undefined;
+    };
+    const beforeHandle = (context) => runBeforeHandle(context, false);
+    const legacyBeforeHandle = (context) => runBeforeHandle(context, true);
+    const afterHandle = async ({ request, responseValue, set }) => {
+        const entry = pending.get(request);
+        if (!entry)
+            return;
+        const { result, supportsStreamingReceipts } = entry;
+        if (isAsyncIterableResponse(responseValue)) {
+            if (supportsStreamingReceipts) {
+                const response = await result.withReceipt(responseValue);
+                pending.delete(request);
+                return response;
+            }
+            const receiptResponse = await result.withReceipt(new Response(null, { status: 204 }));
+            pending.delete(request);
+            if (!receiptResponse.ok)
+                return receiptResponse;
+            copyHeaders(receiptResponse, set.headers);
+            return responseValue;
+        }
+        const response = await mapElysiaResponse(responseValue, set, request);
+        const wrapped = await result.withReceipt(response);
+        pending.delete(request);
+        return wrapped;
     };
+    return Object.assign(legacyBeforeHandle, { afterHandle, beforeHandle });
+}
+function isAsyncIterableResponse(response) {
+    if (typeof response === 'function')
+        return true;
+    return (typeof response === 'object' &&
+        response !== null &&
+        Symbol.asyncIterator in response &&
+        typeof response[Symbol.asyncIterator] === 'function');
+}
+function copyHeaders(response, headers) {
+    for (const [key, value] of response.headers)
+        headers[key] = value;
 }
-function getManagementResponse(result) {
+async function getManagementResponse(result) {
     try {
-        return result.withReceipt();
+        return await result.withReceipt();
     }
     catch (error) {
         if (Mppx_core.isMissingReceiptResponseError(error)) {

package/dist/middlewares/express.js

@@ -1,4 +1,5 @@
 import { generate } from '../discovery/OpenApi.js';
+import * as Scope from '../server/internal/scope.js';
 import * as Mppx_core from '../server/Mppx.js';
 import * as ExpressAdapter from './internal/express.js';
 import * as Mppx_internal from './internal/mppx.js';
@@ -49,16 +50,20 @@ export var Mppx;
  */
 export function payment(intent, options) {
     return async (req, res, next) => {
-        const request = ExpressAdapter.toRequest(req);
+        const rawRequest = ExpressAdapter.toRequest(req);
+        const routePath = typeof req.route?.path === 'string' ? req.route.path : req.path;
+        const request = options.scope === undefined && Scope.read(options.meta) === undefined
+            ? Scope.attach(rawRequest, `${req.method.toUpperCase()} ${req.baseUrl}${routePath}`)
+            : rawRequest;
         const result = await intent(options)(request);
         if (result.status === 402) {
             const challenge = result.challenge;
             await ExpressAdapter.sendResponse(res, challenge);
             return;
         }
-        const managementResponse = (() => {
+        const managementResponse = await (async () => {
             try {
-                return result.withReceipt();
+                return await result.withReceipt();
             }
             catch (error) {
                 if (Mppx_core.isMissingReceiptResponseError(error))
@@ -78,9 +83,11 @@ export function payment(intent, options) {
         }
         const originalJson = res.json.bind(res);
         res.json = (body) => {
-            const wrapped = result.withReceipt(Response.json(body));
-            ExpressAdapter.copyHeaders(res, wrapped.headers);
-            return originalJson(body);
+            void Promise.resolve(result.withReceipt(Response.json(body))).then((wrapped) => {
+                ExpressAdapter.copyHeaders(res, wrapped.headers);
+                originalJson(body);
+            }, next);
+            return res;
         };
         next();
     };

package/dist/middlewares/hono.js

@@ -55,16 +55,16 @@ export function payment(intent, options) {
         const result = await intent(options)(request);
         if (result.status === 402)
             return result.challenge;
-        const managementResponse = getManagementResponse(result);
+        const managementResponse = await getManagementResponse(result);
         if (managementResponse)
             return managementResponse;
         await next();
-        c.res = result.withReceipt(c.res);
+        c.res = await result.withReceipt(c.res);
     };
 }
-function getManagementResponse(result) {
+async function getManagementResponse(result) {
     try {
-        return result.withReceipt();
+        return await result.withReceipt();
     }
     catch (error) {
         if (Mppx_core.isMissingReceiptResponseError(error)) {

package/dist/middlewares/nextjs.js

@@ -1,4 +1,5 @@
 import { generate } from '../discovery/OpenApi.js';
+import * as Scope from '../server/internal/scope.js';
 import * as Mppx_core from '../server/Mppx.js';
 import * as Mppx_internal from './internal/mppx.js';
 export * from '../server/Methods.js';
@@ -48,19 +49,22 @@ export var Mppx;
  */
 export function payment(intent, options, handler) {
     return async (request) => {
-        const result = await intent(options)(request);
+        const scopedRequest = options.scope === undefined && Scope.read(options.meta) === undefined
+            ? Scope.attach(request, `${request.method.toUpperCase()} ${new URL(request.url).pathname}`)
+            : request;
+        const result = await intent(options)(scopedRequest);
         if (result.status === 402)
             return result.challenge;
-        const managementResponse = getManagementResponse(result);
+        const managementResponse = await getManagementResponse(result);
         if (managementResponse)
             return managementResponse;
         const response = await handler(request);
-        return result.withReceipt(response);
+        return await result.withReceipt(response);
     };
 }
-function getManagementResponse(result) {
+async function getManagementResponse(result) {
     try {
-        return result.withReceipt();
+        return await result.withReceipt();
     }
     catch (error) {
         if (Mppx_core.isMissingReceiptResponseError(error)) {

package/dist/proxy/internal/Headers.js

@@ -12,9 +12,12 @@ const hopByHopHeaders = new Set([
 const paymentHeaders = new Set([
     'accept-payment',
     'authorization',
+    'payment-authorization',
     'payment-receipt',
     'payment-required',
     'payment-response',
+    'payment-session',
+    'payment-session-snapshot',
     'payment-signature',
     'www-authenticate',
 ]);
@@ -57,10 +60,72 @@ export function scrubResponse(response) {
     headers.delete('content-encoding');
     headers.delete('content-length');
     headers.delete('set-cookie');
+    for (const name of paymentHeaders) {
+        if (name !== 'authorization' && name !== 'www-authenticate')
+            headers.delete(name);
+    }
+    headers.delete('payment-authorization');
+    const authorization = headers.get('authorization');
+    if (authorization && /^\s*Payment(?:\s|$)/i.test(authorization))
+        headers.delete('authorization');
+    const authenticate = headers.get('www-authenticate');
+    if (authenticate) {
+        const remaining = removePaymentChallenges(authenticate);
+        if (remaining)
+            headers.set('www-authenticate', remaining);
+        else
+            headers.delete('www-authenticate');
+    }
     return new Response(response.body, {
         status: response.status,
         statusText: response.statusText,
         headers,
     });
 }
+/** Removes Payment authentication challenges while preserving other schemes. */
+function removePaymentChallenges(value) {
+    const starts = [];
+    let inQuotes = false;
+    let escaped = false;
+    for (let index = 0; index < value.length; index++) {
+        const character = value[index];
+        if (inQuotes) {
+            if (escaped)
+                escaped = false;
+            else if (character === '\\')
+                escaped = true;
+            else if (character === '"')
+                inQuotes = false;
+            continue;
+        }
+        if (character === '"') {
+            inQuotes = true;
+            continue;
+        }
+        const previous = value.slice(0, index).trimEnd().at(-1);
+        if (index !== 0 && previous !== ',')
+            continue;
+        const match = value.slice(index).match(/^\s*([!#$%&'*+.^_`|~0-9A-Za-z-]+)(?=\s|,|$)/);
+        if (!match)
+            continue;
+        const start = index + match[0].length - match[0].trimStart().length;
+        const afterScheme = start + match[1].length;
+        let next = afterScheme;
+        while (/\s/.test(value[next] ?? ''))
+            next++;
+        if (value[next] === '=')
+            continue;
+        starts.push({ index: start, scheme: match[1].toLowerCase() });
+        index = afterScheme - 1;
+    }
+    return starts
+        .filter(({ scheme }) => scheme !== 'payment')
+        .map(({ index }) => {
+        const originalPosition = starts.findIndex((start) => start.index === index);
+        const end = starts[originalPosition + 1]?.index ?? value.length;
+        return value.slice(index, end).replace(/,\s*$/, '').trim();
+    })
+        .filter(Boolean)
+        .join(', ');
+}
 //# sourceMappingURL=Headers.js.map

package/dist/proxy/services/stripe.js

@@ -30,6 +30,7 @@ export function stripe(config) {
         rewriteRequest(request, ctx) {
             const apiKey = ctx.apiKey ?? config.apiKey;
             request.headers.delete('Stripe-Account');
+            request.headers.delete('Stripe-Context');
             request.headers.set('Authorization', `Basic ${btoa(`${apiKey}:`)}`);
             return request;
         },

package/dist/server/Mppx.d.ts

@@ -8,8 +8,14 @@ import * as Method from '../Method.js';
 import type * as Receipt from '../Receipt.js';
 import * as z from '../zod.js';
 import * as Html from './internal/html/config.js';
+import * as Request from './Request.js';
 import * as Transport from './Transport.js';
 export type Methods = readonly (Method.AnyServer | readonly Method.AnyServer[])[];
+type ReceiptWrapper = (response?: unknown) => unknown;
+/** Returns whether a successful payment result accepts streaming receipt responses. @internal */
+export declare function supportsStreamingReceipts(result: {
+    withReceipt: ReceiptWrapper;
+}): boolean;
 export type ServerEventMap<methods extends readonly Method.Method[] = readonly Method.Method[], transport extends Transport.AnyTransport = Transport.AnyTransport> = {
     'challenge.created': ChallengeContext<methods[number], transport>;
     'payment.failed': PaymentFailedContext<methods[number], transport>;
@@ -112,6 +118,7 @@ export type VerifyCredentialOptions = {
     capturedRequest?: Method.CapturedRequest | undefined;
     meta?: Record<string, string> | undefined;
     realm?: string | undefined;
+    /** Route input used for binding checks and disambiguating configured methods before schema transforms. */
     request?: Record<string, unknown> | undefined;
     /** Optional expected route/resource scope bound via challenge `opaque`. */
     scope?: string | undefined;
@@ -140,7 +147,8 @@ export type Mppx<methods extends Methods = Methods, transport extends Transport.
      * all methods through HTTP headers or an MCP payment-required challenge list.
      *
      * Each entry is a `[method, options]` tuple where `method` is one of the
-     * server methods passed to `Mppx.create()`, looked up by `name`+`intent`.
+     * server methods passed to `Mppx.create()`, looked up by object identity.
+     * String keys use the named handler; function references use their configured method.
      *
      * Available on HTTP, MCP JSON-RPC, and MCP SDK transports. MCP handlers
      * accept the transport's input and return its challenge and receipt types.
@@ -372,15 +380,19 @@ type ConfiguredHandler<transport extends Transport.AnyTransport = Transport.Http
         name: string;
         intent: string;
         html: Html.Options | undefined;
+        credentialHeaders?: readonly string[] | undefined;
         meta?: Record<string, string> | undefined;
         scope?: string | undefined;
         _canonicalRequest: Record<string, unknown>;
         _stableBinding?: Method.StableBindingFn<Method.Method> | undefined;
+        _transport: Transport.AnyTransport;
     };
 };
 type ComposedHandler<transport extends Transport.AnyTransport = Transport.Http> = ((input: Transport.InputOf<transport>) => Promise<MethodFn.Response<transport>>) & {
     _internal?: {
         offers: readonly ConfiguredHandler['_internal'][];
+        handlers?: readonly ConfiguredHandler<transport>[];
+        selectOffers?: SelectOffers<readonly Method.AnyServer[]> | undefined;
     };
 };
 /** An entry for `compose()`: a method reference, handler function ref, or string key paired with its options. */
@@ -409,6 +421,9 @@ export declare function compose(...args: readonly unknown[]): ComposedHandler;
  * On 402: writes the challenge response and ends the connection.
  * On 200: sets the Payment-Receipt header; caller should write response body.
  *
+ * @param handler - Payment handler to adapt.
+ * @param options - Node request conversion and body-size options.
+ *
  * @example
  * ```ts
  * import * as http from 'node:http'
@@ -427,7 +442,8 @@ export declare function compose(...args: readonly unknown[]): ComposedHandler;
  * })
  * ```
  */
-export declare function toNodeListener(handler: (input: globalThis.Request) => Promise<MethodFn.Response<Transport.Http>>): (req: IncomingMessage, res: ServerResponse) => Promise<MethodFn.Response<Transport.Http>>;
+export declare function toNodeListener(handler: (input: globalThis.Request) => Promise<MethodFn.Response<Transport.Http>>, options?: Request.NodeConversionOptions | undefined): (req: IncomingMessage, res: ServerResponse) => Promise<MethodFn.Response<Transport.Http>>;
+export declare function toNodeListener(handler: (input: globalThis.Request) => Promise<MethodFn.Response<Transport.Sse>>, options?: Request.NodeConversionOptions | undefined): (req: IncomingMessage, res: ServerResponse) => Promise<MethodFn.Response<Transport.Sse>>;
 /**
  * Flattens a methods config tuple, preserving positional types.
  * @internal