mppx 0.11.0 → 0.13.1

package/dist/server/Mppx.js

@@ -19,6 +19,11 @@ import * as SecretKey from './internal/SecretKey.js';
 import * as NodeListener from './NodeListener.js';
 import * as Request from './Request.js';
 import * as Transport from './Transport.js';
+const streamingReceiptWrappers = new WeakSet();
+/** Returns whether a successful payment result accepts streaming receipt responses. @internal */
+export function supportsStreamingReceipts(result) {
+    return streamingReceiptWrappers.has(result.withReceipt);
+}
 const reservedMppxKeyValues = [
     'challenge',
     'compose',
@@ -64,22 +69,18 @@ export function create(config) {
         ? createAttestationGuard(attestation)
         : undefined;
     const handlers = {};
+    const methodHandlers = new Map();
     const intentCount = {};
+    function composeConfigured(configured) {
+        if (transport.name === 'mcp' || transport.name === 'mcp-sdk')
+            return composeMcpHandlers(configured, transport);
+        return composeHandlers(configured, undefined, selectOffers);
+    }
+    function createGroupedHandler(group) {
+        return (options) => composeConfigured(group.map((method) => methodHandlers.get(method)(options)));
+    }
     for (const mi of methods) {
         intentCount[mi.intent] = (intentCount[mi.intent] ?? 0) + 1;
-        if (mi.onPaymentSuccess) {
-            serverEvents.on('payment.success', (async (ctx) => {
-                if (ctx.method.name === mi.name && ctx.method.intent === mi.intent) {
-                    await mi.onPaymentSuccess({
-                        challenge: ctx.challenge,
-                        input: ctx.input,
-                        receipt: ctx.receipt,
-                        request: ctx.request,
-                        ...(ctx.requestInput !== undefined && { requestInput: ctx.requestInput }),
-                    });
-                }
-            }));
-        }
     }
     assertNoReservedMppxKeys(methods);
     for (const mi of methods) {
@@ -105,6 +106,8 @@ export function create(config) {
         const aliasKey = mi.alias ? `${mi.name}/${mi.alias}` : undefined;
         if (mi.extensions)
             Object.assign(fn, mi.extensions);
+        Object.assign(fn, { _method: mi });
+        methodHandlers.set(mi, fn);
         if (!aliasKey || !handlers[wireKey])
             handlers[wireKey] = fn;
         if (aliasKey)
@@ -122,23 +125,25 @@ export function create(config) {
         }
         else {
             const intentMethods = methods.filter((m) => m.intent === mi.intent);
-            handlers[mi.intent] = (options) => {
-                const configured = intentMethods.map((m) => {
-                    const key = `${m.name}/${m.intent}`;
-                    const handlerFn = handlers[key];
-                    return handlerFn(options);
-                });
-                return composeHandlers(configured, undefined, selectOffers);
-            };
+            handlers[mi.intent] = createGroupedHandler(intentMethods);
         }
     }
+    // Preserve distinct configured offers sharing a wire method, including nested handlers.
+    for (const key of new Set(methods.filter((m) => !m.alias).map((m) => `${m.name}/${m.intent}`))) {
+        const matching = methods.filter((m) => !m.alias && `${m.name}/${m.intent}` === key);
+        if (matching.length < 2)
+            continue;
+        const composed = createGroupedHandler(matching);
+        Object.assign(composed, matching[0].extensions);
+        handlers[key] = composed;
+    }
     // Build nested handlers: mppx.tempo.charge(...)
     for (const mi of methods) {
         if (!handlers[mi.name])
             handlers[mi.name] = {};
         const key = mi.alias ? `${mi.name}/${mi.alias}` : `${mi.name}/${mi.intent}`;
         const fn = handlers[key];
-        fn._method = mi;
+        fn._method ??= mi;
         handlers[mi.name][mi.alias ?? mi.intent] = fn;
     }
     // Build challenge generators: mppx.challenge.tempo.charge(...)
@@ -146,6 +151,8 @@ export function create(config) {
     for (const mi of methods) {
         if (!challengeHandlers[mi.name])
             challengeHandlers[mi.name] = {};
+        if (challengeHandlers[mi.name][mi.alias ?? mi.intent])
+            continue;
         challengeHandlers[mi.name][mi.alias ?? mi.intent] = createChallengeFn({
             credentialHeader,
             defaults: mi.defaults,
@@ -160,7 +167,7 @@ export function create(config) {
         const emitFailures = parameters.emitFailures === true;
         const { method: credMethod, intent: credIntent } = credential.challenge;
         const methodCandidates = methods.filter((m) => m.name === credMethod && m.intent === credIntent);
-        const mi = methodCandidates[0];
+        let mi = methodCandidates[0];
         const eventMethod = mi ?? { intent: credIntent, name: credMethod };
         const emitStandalonePaymentFailed = async (failure) => {
             if (!emitFailures)
@@ -191,11 +198,6 @@ export function create(config) {
                 reason: `no registered method for ${credMethod}/${credIntent}`,
             }));
         }
-        if (parameters.requireValidate && !mi.validate)
-            await fail(new Errors.VerificationFailedError({
-                details: { intent: credIntent, method: credMethod },
-                reason: `${credMethod}/${credIntent} does not support non-mutating credential validation`,
-            }));
         if (!Challenge.verify(credential.challenge, { secretKey: secretKey })) {
             await fail(new Errors.InvalidChallengeError({
                 id: credential.challenge.id,
@@ -210,6 +212,24 @@ export function create(config) {
                 await fail(e);
             throw e;
         }
+        if (methodCandidates.length > 1) {
+            const matches = [
+                ...new Set(methodCandidates.filter((candidate) => matchesStandaloneMethod(candidate, credential.challenge.request, options?.request))),
+            ];
+            if (matches.length !== 1)
+                await fail(new Errors.InvalidChallengeError({
+                    id: credential.challenge.id,
+                    reason: matches.length === 0
+                        ? 'no configured method matches the challenge request'
+                        : 'multiple configured methods match the challenge request; use a configured route handler',
+                }));
+            mi = matches[0];
+        }
+        if (parameters.requireValidate && !mi.validate)
+            await fail(new Errors.VerificationFailedError({
+                details: { intent: credIntent, method: credMethod },
+                reason: `${credMethod}/${credIntent} does not support non-mutating credential validation`,
+            }));
         let parsedCredential;
         try {
             parsedCredential = withParsedCredentialPayload(credential, mi.schema.credential.payload.parse(credential.payload));
@@ -291,6 +311,7 @@ export function create(config) {
         return prepared.method.validate({
             credential: prepared.parsedCredential,
             envelope: prepared.envelope,
+            operation: 'validate',
             request: prepared.request,
         });
     }
@@ -312,7 +333,12 @@ export function create(config) {
         let receipt;
         try {
             if (mi.broadcast && mi.validate)
-                await mi.validate({ credential: parsedCredential, envelope, request });
+                await mi.validate({
+                    credential: parsedCredential,
+                    envelope,
+                    operation: 'broadcast',
+                    request,
+                });
             const broadcast = mi.broadcast ?? mi.verify;
             receipt = await broadcast({ credential: parsedCredential, envelope, request });
         }
@@ -336,7 +362,7 @@ export function create(config) {
             receipt,
             request: parsedRequest,
             ...(requestInput !== undefined && { requestInput }),
-        }));
+        }), mi);
         return receipt;
     }
     const verifyCredentialFn = broadcastCredentialFn;
@@ -347,18 +373,27 @@ export function create(config) {
         if (entries.length === 0)
             throw new Error('compose() requires at least one entry');
         const configured = entries.map(([methodOrKey, options]) => {
+            const method = typeof methodOrKey === 'string'
+                ? undefined
+                : typeof methodOrKey === 'function'
+                    ? methodOrKey._method
+                    : methodOrKey;
             const key = typeof methodOrKey === 'string'
                 ? methodOrKey
-                : typeof methodOrKey === 'function' && '_method' in methodOrKey
-                    ? `${methodOrKey._method.name}/${methodOrKey._method.alias ?? methodOrKey._method.intent}`
-                    : `${methodOrKey.name}/${methodOrKey.alias ?? methodOrKey.intent}`;
-            const handlerFn = handlers[key];
+                : `${method.name}/${method.alias ?? method.intent}`;
+            const handlerFn = typeof methodOrKey === 'function' && handlers[key] === methodOrKey
+                ? methodOrKey
+                : method
+                    ? methodHandlers.get(method)
+                    : handlers[key];
             if (!handlerFn)
                 throw new Error(`No handler for "${key}". Is this method in your methods array?`);
-            const method = handlerFn._method;
-            if (isMcp && method?.transport && method.transport.name !== transport.name)
+            const configuredMethod = handlerFn._method;
+            if (isMcp &&
+                configuredMethod?.transport &&
+                configuredMethod.transport.name !== transport.name)
                 throw new Error('MCP compose() requires methods using the configured MCP transport');
-            if (isMcp && method?.canOffer)
+            if (isMcp && configuredMethod?.canOffer)
                 throw new Error('MCP compose() does not support HTTP canOffer hooks');
             return handlerFn(options);
         });
@@ -405,8 +440,15 @@ function createMethodFn(parameters) {
             name: method.name,
             intent: method.intent,
             html: method.html,
+            credentialHeaders: [
+                ...new Set([
+                    credentialHeader ?? Constants.Headers.authorization,
+                    ...(transport.credentialHeaders ?? []),
+                ]),
+            ],
             _canonicalRequest: PaymentRequest.fromMethod(method, { ...defaults, ...rest }),
             _stableBinding: stableBinding,
+            _transport: transport,
         };
         Object.defineProperty(internal, '_method', { value: method });
         const handler = async (input) => {
@@ -584,7 +626,7 @@ function createMethodFn(parameters) {
             }
             const success = (receiptData, options = {}) => {
                 const { challengeId = challenge.id, credentialForReceipt = { challenge, payload: {} }, envelopeForReceipt, managementResponse, } = options;
-                return {
+                const result = {
                     status: 200,
                     withReceipt(response) {
                         if (managementResponse) {
@@ -609,6 +651,9 @@ function createMethodFn(parameters) {
                         });
                     },
                 };
+                if (transport.supportsStreamingReceipts)
+                    streamingReceiptWrappers.add(result.withReceipt);
+                return result;
             };
             // No credential provided—issue challenge
             if (!credential) {
@@ -620,15 +665,6 @@ function createMethodFn(parameters) {
                             request: challenge.request,
                         });
                         if (authorized) {
-                            await events.emit('payment.success', createPaymentSuccessContext({
-                                capturedRequest,
-                                challenge,
-                                input,
-                                method,
-                                receipt: authorized.receipt,
-                                request: parsedRequest,
-                                requestInput: request,
-                            }));
                             return success(authorized.receipt, {
                                 managementResponse: authorized.response,
                             });
@@ -799,7 +835,12 @@ function createMethodFn(parameters) {
             let receiptData;
             try {
                 if (broadcast && validate)
-                    await validate({ credential: parsedCredential, envelope, request });
+                    await validate({
+                        credential: parsedCredential,
+                        envelope,
+                        operation: 'broadcast',
+                        request,
+                    });
                 const broadcastCredential = broadcast ?? verify;
                 receiptData = await broadcastCredential({
                     credential: parsedCredential,
@@ -851,7 +892,7 @@ function createMethodFn(parameters) {
                 receipt: receiptData,
                 request: parsedRequest,
                 requestInput: request,
-            }));
+            }), method);
             return success(receiptData, {
                 challengeId: credential.challenge.id,
                 credentialForReceipt: parsedCredential,
@@ -916,6 +957,7 @@ function createAttestationGuard(verifiers) {
         return verification;
     };
 }
+/** Dispatches instance events and scopes success hooks to the supplied configured method. */
 function createServerEventDispatcher() {
     const handlers = {
         '*': new Set(),
@@ -936,7 +978,22 @@ function createServerEventDispatcher() {
         }
     };
     return {
-        async emit(name, context) {
+        async emit(name, context, method) {
+            if (name === 'payment.success' && method?.onPaymentSuccess) {
+                const success = context;
+                try {
+                    await method.onPaymentSuccess({
+                        challenge: success.challenge,
+                        input: success.input,
+                        receipt: success.receipt,
+                        request: success.request,
+                        ...(success.requestInput !== undefined && { requestInput: success.requestInput }),
+                    });
+                }
+                catch {
+                    // Per-method hooks are isolated just like instance event handlers.
+                }
+            }
             await emitServerEventHandlers(handlers[name], context);
             await emitServerEventHandlers(handlers['*'], toServerEventEnvelope(name, context));
         },
@@ -1328,6 +1385,30 @@ function getPinnedChallengeMismatch(expectedChallenge, actualChallenge) {
         return 'opaque';
     return getPinnedRequestBindingMismatch(expectedChallenge.request, actualChallenge.request);
 }
+/** Matches standalone credentials against the configured portion of a method's stable binding. */
+function matchesStandaloneMethod(method, request, routeRequest) {
+    try {
+        const configured = { ...method.defaults, ...routeRequest };
+        const parsed = method.schema.request.safeParse(configured);
+        // Standalone callers may omit route-only inputs such as amount. In that
+        // case, constrain selection by the defaults we have rather than parsing
+        // the echoed wire request as input and applying its transforms twice.
+        const expectedRequest = parsed.success ? parsed.data : configured;
+        const binding = (value) => {
+            if (method.stableBinding)
+                return getStableBinding(value, method.stableBinding);
+            const { coreBinding, methodBinding } = getPinnedRequestBinding(value);
+            return { ...coreBinding, ...methodBinding };
+        };
+        const expected = binding(expectedRequest);
+        const actual = binding(request);
+        return Object.entries(expected).every(([key, value]) => value === undefined ||
+            isDeepStrictEqual(normalizeComparable(value), normalizeComparable(actual[key])));
+    }
+    catch {
+        return false;
+    }
+}
 function getPinnedRequestBindingMismatch(expectedRequest, actualRequest) {
     const expected = getPinnedRequestBinding(expectedRequest);
     const actual = getPinnedRequestBinding(actualRequest);
@@ -1457,6 +1538,11 @@ export function compose(...args) {
     return composeHandlers(handlers, composeOptions);
 }
 function composeHandlers(handlers, composeOptions, selectOffers) {
+    // Flatten only shared policies; a static wrapper must retain a nested server's selector.
+    handlers = handlers.flatMap((handler) => {
+        const internal = handler._internal;
+        return internal?.selectOffers === selectOffers ? (internal?.handlers ?? [handler]) : [handler];
+    });
     if (handlers.length === 0)
         throw new Error('compose() requires at least one handler');
     const offerSelector = selectOffers;
@@ -1486,7 +1572,10 @@ function composeHandlers(handlers, composeOptions, selectOffers) {
         // Try to extract a Payment credential to decide whether to dispatch or challenge.
         // Only gate on the Payment scheme — other auth schemes (Bearer, Basic, etc.)
         // should fall through to the merged-402 path so all offers are presented.
-        const paymentHeader = Array.from(input.headers.values())
+        const credentialHeaders = new Set(handlers.flatMap((handler) => getConfiguredOffers(handler).flatMap((internal) => internal.credentialHeaders ?? [])));
+        const paymentHeader = Array.from(credentialHeaders)
+            .map((header) => input.headers.get(header))
+            .filter((value) => value !== null)
             .map((value) => Credential.extractPaymentScheme(value))
             .find((value) => value !== null);
         if (paymentHeader) {
@@ -1525,6 +1614,24 @@ function composeHandlers(handlers, composeOptions, selectOffers) {
             // Unrecognized or malformed credentials still use the currently eligible
             // offer set before the first handler issues its rejection challenge.
         }
+        const transportResults = new Map();
+        for (const handler of handlers) {
+            for (const internal of getConfiguredOffers(handler)) {
+                const matchCredential = internal._transport.matchCredential;
+                if (!matchCredential)
+                    continue;
+                try {
+                    if (await matchCredential({ input, request: internal._canonicalRequest })) {
+                        const result = await handler(input);
+                        transportResults.set(handler, result);
+                        if (result.status === 200)
+                            return result;
+                        break;
+                    }
+                }
+                catch { }
+            }
+        }
         const selectedHandlers = hasOfferPolicy
             ? await selectOfferHandlers({
                 entries: offerEntries,
@@ -1532,13 +1639,23 @@ function composeHandlers(handlers, composeOptions, selectOffers) {
                 selectOffers: offerSelector,
             })
             : handlers;
+        const transportCredentialHandler = selectedHandlers.find((handler) => getConfiguredOffers(handler).some((internal) => internal.credentialHeaders?.some((header) => {
+            const value = input.headers.get(header);
+            return (header.toLowerCase() !== Constants.Headers.authorization.toLowerCase() &&
+                value !== null &&
+                Credential.extractPaymentScheme(value) === null);
+        })));
+        if (transportCredentialHandler)
+            return transportCredentialHandler(input);
         // No credential — evaluate handlers sequentially so authorize()/renewal hooks
         // can safely claim the request without racing each other.
         const results = [];
         for (const handler of selectedHandlers) {
-            const result = await handler(input);
+            const result = transportResults.get(handler) ?? (await handler(input));
             if (result.status === 200)
                 return result;
+            if (result.challenge.status !== 402)
+                return result;
             results.push(result);
         }
         const challengeEntries = (() => {
@@ -1655,7 +1772,7 @@ function composeHandlers(handlers, composeOptions, selectOffers) {
     };
     const offers = handlers.flatMap(getConfiguredOffers);
     if (offers.length > 0)
-        composed._internal = { offers };
+        composed._internal = { offers, handlers: handlers, selectOffers };
     return composed;
 }
 /** Returns the flattened configured offers accepted by a handler. */
@@ -1669,7 +1786,7 @@ function getConfiguredOffers(handler) {
 }
 /** Dispatches one MCP credential or gathers unsigned offers in their configured order. */
 function composeMcpHandlers(handlers, transport) {
-    return async (input) => {
+    const composed = async (input) => {
         let credential;
         try {
             const parsed = transport.getCredential(input);
@@ -1680,13 +1797,9 @@ function composeMcpHandlers(handlers, transport) {
             return handlers[0](input);
         }
         if (credential) {
-            const candidates = handlers.filter((handler) => {
-                const internal = handler._internal;
-                return (internal.name === credential.challenge.method &&
-                    internal.intent === credential.challenge.intent);
-            });
-            const match = candidates.find((handler) => {
-                const internal = handler._internal;
+            const candidates = handlers.filter((handler) => getConfiguredOffers(handler).some((internal) => internal.name === credential.challenge.method &&
+                internal.intent === credential.challenge.intent));
+            const match = candidates.find((handler) => getConfiguredOffers(handler).some((internal) => {
                 try {
                     const mismatch = internal._stableBinding
                         ? getRequestBindingMismatch(getStableBinding(internal._canonicalRequest, internal._stableBinding), getStableBinding(credential.challenge.request, internal._stableBinding))
@@ -1696,7 +1809,7 @@ function composeMcpHandlers(handlers, transport) {
                 catch {
                     return false;
                 }
-            });
+            }));
             // Verification and settlement belong to exactly one handler, including failures.
             return (match ?? candidates[0] ?? handlers[0])(input);
         }
@@ -1738,6 +1851,10 @@ function composeMcpHandlers(handlers, transport) {
             },
         };
     };
+    composed._internal = {
+        offers: handlers.flatMap((handler) => getConfiguredOffers(handler)),
+    };
+    return composed;
 }
 function isComposedHandlerMetadata(internal) {
     return 'offers' in internal && !('_canonicalRequest' in internal);
@@ -1849,52 +1966,47 @@ function mergeX402PaymentRequiredHeaders(values) {
         }),
     ];
 }
-/**
- * Wraps a payment handler to create a Node.js HTTP listener.
- *
- * On 402: writes the challenge response and ends the connection.
- * On 200: sets the Payment-Receipt header; caller should write response body.
- *
- * @example
- * ```ts
- * import * as http from 'node:http'
- * import { Mppx } from 'mppx/server'
- *
- * const payment = Mppx.create({ ... })
- *
- * http.createServer(async (req, res) => {
- *   const result = await Mppx.toNodeListener(
- *     payment.charge({
- *       amount: '1', currency: '...', recipient: '0x...',
- *     }),
- *   )(req, res)
- *   if (result.status === 402) return
- *   res.end('OK')
- * })
- * ```
- */
-export function toNodeListener(handler) {
+export function toNodeListener(handler, options) {
     return async (req, res) => {
-        const result = await handler(Request.fromNodeListener(req, res));
+        let result;
+        try {
+            const request = Request.fromNodeListener(req, res, options);
+            await Request.waitForBody(request);
+            result = await handler(request);
+        }
+        catch (error) {
+            if (!(error instanceof Request.RequestBodyTooLargeError))
+                throw error;
+            const response = new globalThis.Response('Payload Too Large', {
+                status: 413,
+                headers: { 'Content-Type': 'text/plain' },
+            });
+            await NodeListener.sendResponse(res, response);
+            return { challenge: response, status: 402 };
+        }
         if (result.status === 402) {
             await NodeListener.sendResponse(res, result.challenge);
         }
         else {
-            const managementResponse = getManagementResponse(result);
+            const managementResponse = await getManagementResponse(result);
             if (managementResponse) {
                 await NodeListener.sendResponse(res, managementResponse);
                 return { challenge: managementResponse, status: 402 };
             }
-            const wrapped = result.withReceipt(new globalThis.Response());
+            const wrapped = await result.withReceipt(new globalThis.Response(null, { status: 204 }));
+            if (wrapped.status === 402) {
+                await NodeListener.sendResponse(res, wrapped);
+                return { challenge: wrapped, status: 402 };
+            }
             for (const [name, value] of wrapped.headers)
                 res.setHeader(name, value);
         }
         return result;
     };
 }
-function getManagementResponse(result) {
+async function getManagementResponse(result) {
     try {
-        return result.withReceipt();
+        return await result.withReceipt();
     }
     catch (error) {
         if (isMissingReceiptResponseError(error)) {

package/dist/server/NodeListener.js

@@ -4,6 +4,10 @@
  * Useful when bridging Fetch API handlers with Node.js HTTP servers.
  */
 export async function sendResponse(res, response) {
+    if (isResponseClosed(res)) {
+        await response.body?.cancel('response connection closed').catch(() => { });
+        return;
+    }
     const headers = {};
     for (const [key, value] of response.headers) {
         if (key in headers) {
@@ -23,21 +27,82 @@ export async function sendResponse(res, response) {
         res.writeHead(response.status, headers);
     if (response.body != null && res.req?.method !== 'HEAD') {
         const reader = response.body.getReader();
+        let connectionClosed = false;
+        const onClose = () => {
+            connectionClosed = true;
+            void reader.cancel('response connection closed').catch(() => { });
+        };
+        res.once('close', onClose);
+        if (isResponseClosed(res))
+            onClose();
         try {
+            if (res.destroyed || res.writableEnded) {
+                await reader.cancel('response connection closed');
+                return;
+            }
             while (true) {
                 const { done, value } = await reader.read();
-                if (done)
+                if (done || connectionClosed)
                     break;
-                if (res.write(value) === false)
-                    await new Promise((resolve) => {
-                        res.once('drain', resolve);
-                    });
+                if (res.write(value) === false) {
+                    try {
+                        if (!(await waitForDrain(res))) {
+                            await reader.cancel('response connection closed');
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        await reader.cancel(error).catch(() => { });
+                        throw error;
+                    }
+                }
             }
         }
         finally {
+            res.removeListener('close', onClose);
             reader.releaseLock();
         }
     }
-    res.end();
+    if (!isResponseClosed(res))
+        res.end();
+}
+/** Returns whether the HTTP/1 response or underlying HTTP/2 stream has closed. */
+function isResponseClosed(res) {
+    const stream = 'stream' in res ? res.stream : undefined;
+    return Boolean(res.destroyed || res.writableEnded || stream?.destroyed || stream?.closed);
+}
+/**
+ * Waits for write backpressure to clear.
+ *
+ * Returns `true` on drain, `false` when the response closes, and rejects on a
+ * write-side error. Event listeners are always removed before settlement.
+ */
+function waitForDrain(res) {
+    if (isResponseClosed(res))
+        return Promise.resolve(false);
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            res.removeListener('drain', onDrain);
+            res.removeListener('close', onClose);
+            res.removeListener('error', onError);
+        };
+        const onDrain = () => {
+            cleanup();
+            resolve(true);
+        };
+        const onClose = () => {
+            cleanup();
+            resolve(false);
+        };
+        const onError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        res.once('drain', onDrain);
+        res.once('close', onClose);
+        res.once('error', onError);
+        if (isResponseClosed(res))
+            onClose();
+    });
 }
 //# sourceMappingURL=NodeListener.js.map

package/dist/server/Request.d.ts

@@ -2,9 +2,17 @@ import type { IncomingMessage, RequestListener, ServerResponse } from 'node:http
 export type FetchHandler = (request: Request) => Promise<Response> | Response;
 export type RequestListenerOptions = {
     host?: string | undefined;
+    /** Maximum accepted request body size in bytes. @default 10485760 (10 MiB) */
+    maxBodySize?: number | undefined;
     onError?: ((error: unknown) => void | Response | Promise<void | Response>) | undefined;
     protocol?: string | undefined;
 };
+/** Options used only while converting a Node request to a Fetch request. */
+export type NodeConversionOptions = Omit<RequestListenerOptions, 'onError'>;
+/** Raised when a Node request body exceeds the configured byte limit. */
+export declare class RequestBodyTooLargeError extends Error {
+    readonly name = "RequestBodyTooLargeError";
+}
 /**
  * Converts a Fetch API handler into a Node.js HTTP request listener.
  *
@@ -20,5 +28,7 @@ export declare function toNodeListener(handler: FetchHandler, options?: RequestL
  * @param res - The Node.js ServerResponse (used for abort signal lifecycle).
  * @returns A Fetch API Request.
  */
-export declare function fromNodeListener(req: IncomingMessage, res: ServerResponse, options?: RequestListenerOptions | undefined): Request;
+export declare function fromNodeListener(req: IncomingMessage, res: ServerResponse, options?: NodeConversionOptions | undefined): Request;
+/** Waits for a Node-backed request body to finish and enforces its size limit. */
+export declare function waitForBody(request: Request): Promise<void>;
 //# sourceMappingURL=Request.d.ts.map