@mionjs/router 0.8.10 → 0.13.2

package/.dist/esm/src/dispatch.js

@@ -1,141 +1,233 @@
+import { markResponseFailed, recordUndeclaredError } from "./lib/dispatchError.js";
+import { createCallContext, createContextFromChain, getRequestBodyType } from "./callContext.js";
 import { getRouterOptions } from "./router.js";
-import { HeadersSubset, HandlerType, SerializerModes, RpcError, StatusCodes } from "@mionjs/core";
-import { onExecutableError } from "./lib/dispatchError.js";
-import { acquireCallContext, releaseCallContext } from "./callContext.js";
+import { FatalError, HandlerType, HeadersSubset, MION_ROUTES, StatusCodes, isNativeError, trustedHeadersSubset } from "@mionjs/core";
+import { UNSAFE_PROPERTY_NAME_MESSAGE } from "@mionjs/run-types";
+//#region src/dispatch.ts
+/** The one-call form for a caller that already has the body (tests, a host that parsed it). */
 async function dispatchRoute(path, reqRawBody, reqHeaders, respHeaders, rawRequest, rawResponse, reqBodyType, urlQuery) {
-  const opts = getRouterOptions();
-  const usePooling = opts.maxContextPoolSize > 0;
-  const context = acquireCallContext(
-    usePooling,
-    path,
-    opts,
-    reqRawBody,
-    rawRequest,
-    reqHeaders,
-    respHeaders,
-    reqBodyType,
-    urlQuery
-  );
-  try {
-    await runExecutionChain(context, rawRequest, rawResponse, opts);
-    return context.response;
-  } catch (err) {
-    return Promise.reject(err);
-  } finally {
-    if (usePooling) {
-      releaseCallContext(context, opts.maxContextPoolSize);
-    }
-  }
-}
-async function runExecutionChain(context, rawRequest, rawResponse, opts) {
-  const { response, request } = context;
-  const executionList = context.executionChain.methods;
-  response.serializer = context.executionChain.serializer;
-  for (let i = 0; i < executionList.length; i++) {
-    const executable = executionList[i];
-    if (response.hasErrors && !executable.options.runOnError) continue;
-    try {
-      const methodCaller = executable.methodCaller || getMethodCaller(executable);
-      const result = await methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
-      if (result === void 0 || !executable.hasReturnData) continue;
-      if (executable.headersReturn && result instanceof HeadersSubset) {
-        const headersMap = result.headers;
-        for (const name in headersMap) {
-          const value = headersMap[name];
-          if (value !== void 0 && value !== null) {
-            response.headers.set(name, value);
-          }
-        }
-        continue;
-      }
-      response.body[executable.id] = result;
-    } catch (err) {
-      onExecutableError(context, executable, err);
-    }
-  }
-  return context.response;
-}
-async function runRawMiddleFn(context, executable, req, resp, opts, rawRequest, rawResponse) {
-  const result = await executable.handler(context, rawRequest, rawResponse, opts);
-  return result;
-}
-async function runHeadersMiddleFn(context, executable, request) {
-  const headerNames = executable.headersParam.headerNames;
-  const params = deserializeBodyParamsOrThrow(request, executable);
-  const headersMap = {};
-  headerNames.forEach((name) => {
-    const value = request.headers.get(name);
-    if (value) headersMap[name] = value;
-  });
-  const headersSubset = new HeadersSubset(headersMap);
-  validateHeaderParamsOrThrow(headersSubset, executable);
-  if (executable.options.validateParams) validateParametersOrThrow(params, executable);
-  const result = await executable.handler(context, headersSubset, ...params);
-  return result;
-}
-async function runRouteOrMiddleFn(context, executable, request) {
-  const params = deserializeBodyParamsOrThrow(request, executable);
-  if (executable.options.validateParams) validateParametersOrThrow(params, executable);
-  const result = await executable.handler(context, ...params);
-  return result;
+	return dispatchWithContext(createCallContext(path, urlQuery, rawRequest, reqHeaders, respHeaders, reqRawBody, reqBodyType), rawRequest, rawResponse);
 }
+/** A streaming adapter builds the context before reading the body, to check `context.maxBodySize`, then passes it. */
+async function dispatchWithContext(context, rawRequest, rawResponse, reqRawBody, reqBodyType) {
+	if (reqRawBody !== void 0) {
+		const request = context.request;
+		request.rawBody = reqRawBody;
+		request.bodyType = reqBodyType ?? getRequestBodyType(reqRawBody);
+	}
+	return dispatchMaybeSync(context, rawRequest, rawResponse);
+}
+/** `dispatchWithContext` for a context built with its body, minus the promise when no step needs one. */
+function dispatchMaybeSync(context, rawRequest, rawResponse) {
+	const opts = getRouterOptions();
+	if (opts.alwaysAwait) return runExecutionChain(context, rawRequest, rawResponse, opts, 0);
+	return runSyncExecutionChain(context, rawRequest, rawResponse, opts);
+}
+/** Dispatches a request the platform adapter refused after its route resolved: a body past the limit.
+*  The error is recorded exactly as a thrown one is, so the chain runs only the members that declare
+*  `alwaysRun` (a rate limiter, an access log) and answers with the same envelope. The adapter stopped
+*  the read, so the context is built without a body.
+*  `path` and `urlQuery` travel with the chain rather than on it: mion's not-found chains and a merged
+*  batch chain each answer for many paths, so they carry none of their own, and a refusal does reach one
+*  of those (an adapter checks a declared content-length before asking whether the chain reads a body). */
+function dispatchPlatformError(chain, path, urlQuery, platformError, reqHeaders, respHeaders, rawRequest, rawResponse) {
+	const context = createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders);
+	recordUndeclaredError(context, MION_ROUTES.platformError, platformError);
+	return dispatchWithContext(context, rawRequest, rawResponse);
+}
+async function runExecutionChain(context, rawRequest, rawResponse, opts, startIndex) {
+	const { response, request, executionChain } = context;
+	const alwaysAwait = opts.alwaysAwait;
+	const executionList = executionChain.methods;
+	const executionCount = executionList.length;
+	for (let i = startIndex; i < executionCount; i++) {
+		const executable = executionList[i];
+		if (response.hasErrors && !executable.alwaysRun) continue;
+		try {
+			let result;
+			if (alwaysAwait || executable.isAsync) result = await executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+			else {
+				result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+				if (isUncheckedPromise(executable, result)) result = await result;
+			}
+			applyResult(context, executable, result);
+		} catch (err) {
+			recordUndeclaredError(context, executable.id, err);
+		}
+	}
+	return context.response;
+}
+/** `runExecutionChain` without awaits: from the first async step on it hands over, so both give the same result. */
+function runSyncExecutionChain(context, rawRequest, rawResponse, opts) {
+	const { response, request, executionChain } = context;
+	const executionList = executionChain.methods;
+	const executionCount = executionList.length;
+	for (let i = 0; i < executionCount; i++) {
+		const executable = executionList[i];
+		if (response.hasErrors && !executable.alwaysRun) continue;
+		if (executable.isAsync) return runExecutionChain(context, rawRequest, rawResponse, opts, i);
+		try {
+			const result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+			if (isUncheckedPromise(executable, result)) return Promise.resolve(result).then((resolved) => applyResult(context, executable, resolved)).catch((err) => recordUndeclaredError(context, executable.id, err)).then(() => runExecutionChain(context, rawRequest, rawResponse, opts, i + 1));
+			applyResult(context, executable, result);
+		} catch (err) {
+			recordUndeclaredError(context, executable.id, err);
+		}
+	}
+	return response;
+}
+/** Backstop for a wrong or missing declared type, else the promise is serialized as the answer. */
+function isUncheckedPromise(executable, result) {
+	if (executable.asyncChecked === true) return false;
+	executable.asyncChecked = true;
+	if (result === null || typeof result !== "object" || typeof result.then !== "function") return false;
+	executable.isAsync = true;
+	return true;
+}
+/** A throw here is the caller's to record, like the step's own. */
+function applyResult(context, executable, result) {
+	if (result === void 0) return;
+	const response = context.response;
+	const isMionError = result !== null && result["mion@isΣrrθr"] === true;
+	if (!executable.hasReturnData) {
+		if (isMionError || isNativeError(result)) recordUndeclaredError(context, executable.id, result);
+		return;
+	}
+	if (isMionError) {
+		if (result.isFatal === true) markResponseFailed(context, result, StatusCodes.APPLICATION_ERROR);
+	} else if (isNativeError(result)) {
+		recordUndeclaredError(context, executable.id, result);
+		return;
+	}
+	if (executable.headersReturn && result instanceof HeadersSubset) {
+		const headersMap = result.headers;
+		for (const name of Object.keys(headersMap)) {
+			const value = headersMap[name];
+			if (value !== void 0 && value !== null) response.headers.set(name, value);
+		}
+		return;
+	}
+	response.body[executable.id] = result;
+}
+function runRawMiddleware(context, executable, req, resp, opts, rawRequest, rawResponse) {
+	return executable.handler(context, rawRequest, rawResponse, opts);
+}
+function runHeadersMiddleware(context, executable, request) {
+	const headerNames = executable.headersParam.headerNames;
+	const params = sanitizeParams(deserializeBodyParamsOrThrow(request, executable), request, executable);
+	const headersMap = {};
+	headerNames.forEach((name) => {
+		const value = request.headers.get(name);
+		if (value) headersMap[name] = value;
+	});
+	const headersSubset = trustedHeadersSubset(headersMap);
+	validateHeaderParamsOrThrow(headersSubset, executable);
+	validateParametersOrThrow(params, executable);
+	return executable.handler(context, headersSubset, ...params);
+}
+function runRouteOrMiddleware(context, executable, request) {
+	const params = sanitizeParams(deserializeBodyParamsOrThrow(request, executable), request, executable);
+	validateParametersOrThrow(params, executable);
+	return executable.handler(context, ...params);
+}
+/** Applies the rewrites the params types declare under a format's `transform` key (trim / case /
+*  replace / stripSeparators) in place, after decode and BEFORE validation. Params only: headers and
+*  return values are never sanitized. A transform over wrong-shaped input can throw (`.trim()` on a
+*  number): the raw params fall through so validation reports the real error instead of a 500. */
+function sanitizeParams(params, request, executable) {
+	if (!executable.options.sanitizeParams) return params;
+	const formatTransform = executable.paramsJitFns.formatTransform;
+	if (!formatTransform || formatTransform.isNoop) return params;
+	try {
+		const sanitized = formatTransform.fn(params);
+		request.body[executable.id] = sanitized;
+		return sanitized;
+	} catch {
+		return params;
+	}
+}
+/** The caller for a method kind. Read ONCE, when the method is registered, so the dispatch loop
+*  reads a field instead of branching on the method type on every request. */
+function callerForType(type) {
+	if (type === HandlerType.rawMiddleware) return runRawMiddleware;
+	if (type === HandlerType.headersMiddleware) return runHeadersMiddleware;
+	return runRouteOrMiddleware;
+}
+/** The caller already stored on a registered method. */
 function getMethodCaller(executable) {
-  if (executable.type === HandlerType.rawMiddleFn) {
-    executable.methodCaller = runRawMiddleFn;
-  } else if (executable.type === HandlerType.headersMiddleFn) {
-    executable.methodCaller = runHeadersMiddleFn;
-  } else {
-    executable.methodCaller = runRouteOrMiddleFn;
-  }
-  return executable.methodCaller;
+	return executable.methodCaller;
 }
+/** Shared, for the members whose id is absent from the body: a fresh empty array per member per request
+*  bought nothing. Frozen, so a handler that tried to mutate its params fails loudly instead of corrupting
+*  the next request; nothing can reach it anyway, an empty tuple is spread into the call. */
+var EMPTY_PARAMS = [];
+Object.freeze(EMPTY_PARAMS);
 function deserializeBodyParamsOrThrow(request, executable) {
-  const params = request.body[executable.id] || [];
-  if (request.bodyType === SerializerModes.binary) return params;
-  if (executable.paramsJitFns.restoreFromJson.isNoop) return params;
-  try {
-    request.body[executable.id] = executable.paramsJitFns.restoreFromJson.fn(params);
-    return request.body[executable.id];
-  } catch (e) {
-    throw new RpcError({
-      statusCode: StatusCodes.UNEXPECTED_ERROR,
-      type: "serialization-error",
-      publicMessage: `Invalid params '${executable.id}', can not deserialize. Parameters might be of the wrong type.`,
-      originalError: e,
-      errorData: {
-        deserializeError: e?.message || "Unknown error"
-      }
-    });
-  }
+	const body = request.body;
+	const params = Object.hasOwn(body, executable.id) ? body[executable.id] : void 0;
+	if (!params) return EMPTY_PARAMS;
+	if (!Array.isArray(params)) throw new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "serialization-error",
+		publicMessage: `Invalid params '${executable.id}', params must be an array.`,
+		errorData: { deserializeError: "params must be an array" }
+	});
+	const { decode } = executable.paramsJitFns.json;
+	if (decode.isNoop) return params;
+	try {
+		const decoded = decode.fn(params);
+		body[executable.id] = decoded;
+		return decoded;
+	} catch (e) {
+		if (isStackOverflow(e)) throw nestingTooDeep(executable, e);
+		const detail = typeof e?.message === "string" && e.message.startsWith(UNSAFE_PROPERTY_NAME_MESSAGE) ? e.message : "Parameters might be of the wrong type.";
+		throw new FatalError({
+			statusCode: StatusCodes.UNEXPECTED_ERROR,
+			type: "serialization-error",
+			publicMessage: `Invalid params '${executable.id}', can not deserialize. ${detail}`,
+			originalError: e,
+			errorData: { deserializeError: detail }
+		});
+	}
+}
+/** A RangeError out of a compiled function is the engine's stack limit: the request nested deeper
+*  than a recursive type can be walked. Reported as its own typed 4xx, never as an unknown error. */
+function isStackOverflow(err) {
+	return err instanceof RangeError;
+}
+function nestingTooDeep(executable, originalError) {
+	return new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "request-nesting-too-deep",
+		publicMessage: `Invalid params in '${executable.id}', the request is nested too deep.`,
+		originalError
+	});
 }
 function validateParametersOrThrow(params, executable) {
-  if (executable.paramsJitFns.isType.isNoop) return;
-  if (!executable.paramsJitFns.isType.fn(params)) {
-    const validationError = new RpcError({
-      statusCode: StatusCodes.UNEXPECTED_ERROR,
-      type: "validation-error",
-      publicMessage: `Invalid params in '${executable.id}', validation failed.`,
-      errorData: {
-        typeErrors: executable.paramsJitFns.typeErrors.fn(params)
-      }
-    });
-    throw validationError;
-  }
+	if (executable.paramsJitFns.isType.isNoop) return;
+	let isValid;
+	try {
+		isValid = executable.paramsJitFns.isType.fn(params);
+	} catch (e) {
+		if (isStackOverflow(e)) throw nestingTooDeep(executable, e);
+		throw e;
+	}
+	if (!isValid) throw new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "validation-error",
+		publicMessage: `Invalid params in '${executable.id}', validation failed.`,
+		errorData: { typeErrors: executable.paramsJitFns.typeErrors.fn(params) }
+	});
 }
 function validateHeaderParamsOrThrow(headers, executable) {
-  if (!executable.headersParam.jitFns.isType.fn(headers)) {
-    const validationError = new RpcError({
-      statusCode: StatusCodes.UNEXPECTED_ERROR,
-      type: "validation-error",
-      publicMessage: `Invalid params in '${executable.id}', validation failed.`,
-      errorData: {
-        typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers)
-      }
-    });
-    throw validationError;
-  }
-}
-export {
-  dispatchRoute
-};
-//# sourceMappingURL=dispatch.js.map
+	if (!executable.headersParam.jitFns.isType.fn(headers)) throw new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "validation-error",
+		publicMessage: `Invalid params in '${executable.id}', validation failed.`,
+		errorData: { typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers) }
+	});
+}
+//#endregion
+export { callerForType, dispatchMaybeSync, dispatchPlatformError, dispatchRoute, dispatchWithContext, getMethodCaller };
+
+//# sourceMappingURL=dispatch.js.map

package/.dist/esm/src/dispatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.js","sources":["../../../src/dispatch.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {CallContext, MionResponse, MionRequest, MionHeaders, RawRequestBody} from './types/context.ts';\nimport {type RouterOptions} from './types/general.ts';\nimport {HeadersMethod, RemoteMethod, RawMethod} from './types/remoteMethods.ts';\nimport {getRouterOptions} from './router.ts';\nimport {Mutable, AnyObject, StatusCodes, HeadersSubset, SerializerModes, SerializerCode} from '@mionjs/core';\nimport {RpcError, HandlerType, ValidationError} from '@mionjs/core';\nimport {onExecutableError} from './lib/dispatchError.ts';\nimport {acquireCallContext, releaseCallContext} from './callContext.ts';\n\n/*\n * PERFORMANCE PROFILING NOTE:\n * different options has been tested to improve performance but were discarded due to worst or no noticeable improvements\n * - using promisify(setImmediate): worst or no improvement\n * - using queueMicrotask instead of setImmediate: definitely worst\n * - using callback instead promises: seems to be more slow but use less memory in some scenarios.\n */\n\n// ############# PUBLIC METHODS #############\n\nexport async function dispatchRoute<Req, Resp>(\n    path: string,\n    reqRawBody: RawRequestBody,\n    reqHeaders: MionHeaders,\n    respHeaders: MionHeaders,\n    rawRequest: Req,\n    rawResponse?: Resp,\n    reqBodyType?: SerializerCode,\n    urlQuery?: string\n): Promise<MionResponse> {\n    const opts = getRouterOptions();\n    const usePooling = opts.maxContextPoolSize > 0;\n    const context = acquireCallContext(\n        usePooling,\n        path,\n        opts,\n        reqRawBody,\n        rawRequest,\n        reqHeaders,\n        respHeaders,\n        reqBodyType,\n        urlQuery\n    );\n\n    try {\n        await runExecutionChain(context, rawRequest, rawResponse, opts);\n        return context.response;\n    } catch (err: any | RpcError<string> | Error) {\n        // this should never happen, exceptions should be handled inside runExecutionChain\n        return Promise.reject(err);\n    } finally {\n        // Release context back to pool if pooling is enabled\n        if (usePooling) {\n            releaseCallContext(context, opts.maxContextPoolSize);\n        }\n    }\n}\n\n// ############# PRIVATE METHODS #############\n\n// runs the ExecutionChain of a route\nasync function runExecutionChain(\n    context: CallContext,\n    rawRequest: unknown,\n    rawResponse: unknown,\n    opts: RouterOptions\n): Promise<MionResponse> {\n    const {response, request} = context;\n    const executionList = context.executionChain.methods;\n    (response as Mutable<MionResponse>).serializer = context.executionChain.serializer;\n    for (let i = 0; i < executionList.length; i++) {\n        const executable = executionList[i];\n        if (response.hasErrors && !executable.options.runOnError) continue;\n\n        try {\n            const methodCaller = executable.methodCaller || getMethodCaller(executable);\n            // runRawMiddleFn , runHeadersMiddleFn & runRouteOrMiddleFn must always accept the same parameters in the same order\n            const result = await methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n\n            if (result === undefined || !executable.hasReturnData) continue;\n            if (executable.headersReturn && result instanceof HeadersSubset) {\n                const headersMap = result.headers;\n                for (const name in headersMap) {\n                    const value = headersMap[name];\n                    if (value !== undefined && value !== null) {\n                        response.headers.set(name, value);\n                    }\n                }\n                continue;\n            }\n            (response.body as Mutable<AnyObject>)[executable.id] = result;\n        } catch (err: any | RpcError<string> | Error) {\n            // All thrown errors are unexpected\n            onExecutableError(context, executable, err);\n        }\n    }\n    return context.response;\n}\n\nasync function runRawMiddleFn(\n    context: CallContext,\n    executable: RawMethod,\n    req,\n    resp,\n    opts: RouterOptions,\n    rawRequest: unknown,\n    rawResponse: unknown\n) {\n    const result = await executable.handler(context, rawRequest, rawResponse, opts);\n    return result;\n}\n\nasync function runHeadersMiddleFn(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n    const headerNames = executable.headersParam.headerNames;\n    const params = deserializeBodyParamsOrThrow(request, executable as RemoteMethod);\n    const headersMap: Record<string, string> = {};\n    headerNames.forEach((name) => {\n        const value = request.headers.get(name);\n        if (value) headersMap[name] = value;\n    });\n    const headersSubset = new HeadersSubset(headersMap);\n    validateHeaderParamsOrThrow(headersSubset, executable as HeadersMethod);\n    if (executable.options.validateParams) validateParametersOrThrow(params, executable as HeadersMethod);\n\n    const result = await executable.handler(context, headersSubset, ...params);\n    return result;\n}\n\nasync function runRouteOrMiddleFn(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n    const params = deserializeBodyParamsOrThrow(request, executable as RemoteMethod);\n    if (executable.options.validateParams) validateParametersOrThrow(params, executable as RemoteMethod);\n    const result = await executable.handler(context, ...params);\n    return result;\n}\n\nfunction getMethodCaller(executable: RemoteMethod) {\n    if (executable.type === HandlerType.rawMiddleFn) {\n        executable.methodCaller = runRawMiddleFn;\n    } else if (executable.type === HandlerType.headersMiddleFn) {\n        executable.methodCaller = runHeadersMiddleFn;\n    } else {\n        executable.methodCaller = runRouteOrMiddleFn;\n    }\n    return executable.methodCaller;\n}\n\nfunction deserializeBodyParamsOrThrow(request: MionRequest, executable: RemoteMethod): any[] {\n    const params: any[] = (request.body[executable.id] as any[]) || [];\n    // For binary requests, params are already deserialized in the serializer middleFn\n    // (deserializeBinaryRequestBody in serializer.routes.ts)\n    if (request.bodyType === SerializerModes.binary) return params;\n\n    // For JSON requests, use restoreFromJson to deserialize\n    if (executable.paramsJitFns.restoreFromJson.isNoop) return params;\n    try {\n        (request.body as Mutable<MionRequest['body']>)[executable.id] = executable.paramsJitFns.restoreFromJson.fn(params);\n        return request.body[executable.id] as any[];\n    } catch (e: any) {\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'serialization-error',\n            publicMessage: `Invalid params '${executable.id}', can not deserialize. Parameters might be of the wrong type.`,\n            originalError: e,\n            errorData: {\n                deserializeError: e?.message || 'Unknown error',\n            },\n        });\n    }\n}\n\nfunction validateParametersOrThrow(params: any[], executable: RemoteMethod): void {\n    if (executable.paramsJitFns.isType.isNoop) return;\n    if (!executable.paramsJitFns.isType.fn(params)) {\n        const validationError: ValidationError = new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'validation-error',\n            publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n            errorData: {\n                typeErrors: executable.paramsJitFns.typeErrors.fn(params),\n            },\n        });\n        throw validationError;\n    }\n}\n\nfunction validateHeaderParamsOrThrow(headers: HeadersSubset<string, string>, executable: HeadersMethod): void {\n    if (!executable.headersParam.jitFns.isType.fn(headers)) {\n        const validationError: ValidationError = new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'validation-error',\n            publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n            errorData: {\n                typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers),\n            },\n        });\n        throw validationError;\n    }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"dispatch.js","names":[],"sources":["../../../src/dispatch.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {CallContext, MionResponse, MionRequest, MionHeaders, RawRequestBody} from './types/context.ts';\nimport {type RouterOptions} from './types/general.ts';\nimport {HeadersMethod, RemoteMethod, RawMethod} from './types/remoteMethods.ts';\nimport type {MethodsExecutionChain} from './types/remoteMethods.ts';\nimport {getRouterOptions} from './router.ts';\nimport {Mutable, AnyObject, StatusCodes, HeadersSubset, SerializerCode, MION_ROUTES, trustedHeadersSubset} from '@mionjs/core';\nimport {RpcError, FatalError, HandlerType, ValidationError, isNativeError} from '@mionjs/core';\nimport {UNSAFE_PROPERTY_NAME_MESSAGE} from '@mionjs/run-types';\nimport {markResponseFailed, recordUndeclaredError} from './lib/dispatchError.ts';\nimport {createCallContext, createContextFromChain, getRequestBodyType} from './callContext.ts';\n\n// Profiled and discarded: promisify(setImmediate) (worse or no gain), queueMicrotask instead of\n// setImmediate (definitely worse), callbacks instead of promises (slower, less memory in some scenarios).\n\n// ############# PUBLIC METHODS #############\n\n/** The one-call form for a caller that already has the body (tests, a host that parsed it). */\nexport async function dispatchRoute<Req, Resp>(\n  path: string,\n  reqRawBody: RawRequestBody,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  rawRequest: Req,\n  rawResponse?: Resp,\n  reqBodyType?: SerializerCode,\n  urlQuery?: string\n): Promise<MionResponse> {\n  const context = createCallContext(path, urlQuery, rawRequest, reqHeaders, respHeaders, reqRawBody, reqBodyType);\n  return dispatchWithContext(context, rawRequest, rawResponse);\n}\n\n/** A streaming adapter builds the context before reading the body, to check `context.maxBodySize`, then passes it. */\nexport async function dispatchWithContext<Req, Resp>(\n  context: CallContext,\n  rawRequest: Req,\n  rawResponse?: Resp,\n  reqRawBody?: RawRequestBody,\n  reqBodyType?: SerializerCode\n): Promise<MionResponse> {\n  if (reqRawBody !== undefined) {\n    const request = context.request as Mutable<MionRequest>;\n    request.rawBody = reqRawBody;\n    request.bodyType = reqBodyType ?? getRequestBodyType(reqRawBody);\n  }\n  // No catch: the chain runners handle every exception themselves, so one that only re-rejects changes nothing.\n  return dispatchMaybeSync(context, rawRequest, rawResponse);\n}\n\n/** `dispatchWithContext` for a context built with its body, minus the promise when no step needs one. */\nexport function dispatchMaybeSync<Req, Resp>(\n  context: CallContext,\n  rawRequest: Req,\n  rawResponse?: Resp\n): MionResponse | Promise<MionResponse> {\n  const opts = getRouterOptions();\n  if (opts.alwaysAwait) return runExecutionChain(context, rawRequest, rawResponse, opts, 0);\n  return runSyncExecutionChain(context, rawRequest, rawResponse, opts);\n}\n\n/** Dispatches a request the platform adapter refused after its route resolved: a body past the limit.\n *  The error is recorded exactly as a thrown one is, so the chain runs only the members that declare\n *  `alwaysRun` (a rate limiter, an access log) and answers with the same envelope. The adapter stopped\n *  the read, so the context is built without a body.\n *  `path` and `urlQuery` travel with the chain rather than on it: mion's not-found chains and a merged\n *  batch chain each answer for many paths, so they carry none of their own, and a refusal does reach one\n *  of those (an adapter checks a declared content-length before asking whether the chain reads a body). */\nexport function dispatchPlatformError<Req, Resp>(\n  chain: MethodsExecutionChain,\n  path: string,\n  urlQuery: string | undefined,\n  platformError: RpcError<string>,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  rawRequest: Req,\n  rawResponse?: Resp\n): Promise<MionResponse> {\n  const context = createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders);\n  recordUndeclaredError(context, MION_ROUTES.platformError, platformError);\n  return dispatchWithContext(context, rawRequest, rawResponse);\n}\n\n// ############# PRIVATE METHODS #############\n\nasync function runExecutionChain(\n  context: CallContext,\n  rawRequest: unknown,\n  rawResponse: unknown,\n  opts: RouterOptions,\n  startIndex: number\n): Promise<MionResponse> {\n  const {response, request, executionChain} = context;\n  // `alwaysAwait: false` skips the await on sync steps: awaiting one only costs a promise frame\n  const alwaysAwait = opts.alwaysAwait;\n  const executionList = executionChain.methods;\n  const executionCount = executionList.length;\n  for (let i = startIndex; i < executionCount; i++) {\n    const executable = executionList[i];\n    if (response.hasErrors && !executable.alwaysRun) continue;\n\n    try {\n      // runRawMiddleware, runHeadersMiddleware & runRouteOrMiddleware must take the same params in the same order\n      // methodCaller is resolved at registration, so the loop never picks one\n      // `isAsync` comes from the type checker, so a plain function returning a promise still awaits\n      let result;\n      if (alwaysAwait || executable.isAsync) {\n        result = await executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n      } else {\n        result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n        if (isUncheckedPromise(executable, result)) result = await result;\n      }\n      applyResult(context, executable, result);\n    } catch (err: any) {\n      // All thrown errors are undeclared and fatal\n      recordUndeclaredError(context, executable.id, err);\n    }\n  }\n  return context.response;\n}\n\n/** `runExecutionChain` without awaits: from the first async step on it hands over, so both give the same result. */\nfunction runSyncExecutionChain(\n  context: CallContext,\n  rawRequest: unknown,\n  rawResponse: unknown,\n  opts: RouterOptions\n): MionResponse | Promise<MionResponse> {\n  const {response, request, executionChain} = context;\n  const executionList = executionChain.methods;\n  const executionCount = executionList.length;\n  for (let i = 0; i < executionCount; i++) {\n    const executable = executionList[i];\n    if (response.hasErrors && !executable.alwaysRun) continue;\n    if (executable.isAsync) return runExecutionChain(context, rawRequest, rawResponse, opts, i);\n\n    try {\n      const result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n      if (isUncheckedPromise(executable, result)) {\n        return Promise.resolve(result)\n          .then((resolved) => applyResult(context, executable, resolved))\n          .catch((err) => recordUndeclaredError(context, executable.id, err))\n          .then(() => runExecutionChain(context, rawRequest, rawResponse, opts, i + 1));\n      }\n      applyResult(context, executable, result);\n    } catch (err: any) {\n      // All thrown errors are undeclared and fatal\n      recordUndeclaredError(context, executable.id, err);\n    }\n  }\n  return response;\n}\n\n/** Backstop for a wrong or missing declared type, else the promise is serialized as the answer. */\nfunction isUncheckedPromise(executable: RemoteMethod, result: any): result is PromiseLike<unknown> {\n  if (executable.asyncChecked === true) return false;\n  executable.asyncChecked = true;\n  if (result === null || typeof result !== 'object' || typeof result.then !== 'function') return false;\n  (executable as Mutable<RemoteMethod>).isAsync = true;\n  return true;\n}\n\n/** A throw here is the caller's to record, like the step's own. */\nfunction applyResult(context: CallContext, executable: RemoteMethod, result: any): void {\n  if (result === undefined) return;\n  const response = context.response;\n  // One brand read serves every branch below: it is an own property on every mion error, wire copies too\n  // `null` is a valid answer and reading a property off it throws, so it is excluded first\n  const isMionError = result !== null && result['mion@isΣrrθr'] === true;\n  if (!executable.hasReturnData) {\n    // a raw middleware declares no return, so a returned error is undeclared and halts like a thrown one\n    if (isMionError || isNativeError(result)) recordUndeclaredError(context, executable.id, result);\n    return;\n  }\n  if (isMionError) {\n    // a returned FatalError is declared: it ends the chain but keeps its slot; a plain RpcError lets the chain run on\n    if (result.isFatal === true) markResponseFailed(context, result, StatusCodes.APPLICATION_ERROR);\n  }\n  // A brandless Error is a bug with no typed slot; in the body it would be served as a SUCCESSFUL answer\n  else if (isNativeError(result)) {\n    recordUndeclaredError(context, executable.id, result);\n    return; // like a thrown one: it belongs in @thrownErrors, never in the body\n  }\n  if (executable.headersReturn && result instanceof HeadersSubset) {\n    // own keys only: a HeadersSubset built over a parsed body must not turn inherited keys into headers\n    const headersMap = result.headers;\n    for (const name of Object.keys(headersMap)) {\n      const value = headersMap[name];\n      if (value !== undefined && value !== null) {\n        response.headers.set(name, value);\n      }\n    }\n    return;\n  }\n  (response.body as Mutable<AnyObject>)[executable.id] = result;\n}\n\n// The three callers below are NOT async: awaiting the handler only to return its value adds a promise\n// frame per chain member, and the loop's own await and try/catch cover the value and the promise alike.\nfunction runRawMiddleware(\n  context: CallContext,\n  executable: RawMethod,\n  req,\n  resp,\n  opts: RouterOptions,\n  rawRequest: unknown,\n  rawResponse: unknown\n) {\n  return executable.handler(context, rawRequest, rawResponse, opts);\n}\n\nfunction runHeadersMiddleware(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n  const headerNames = executable.headersParam.headerNames;\n  const params = sanitizeParams(\n    deserializeBodyParamsOrThrow(request, executable as RemoteMethod),\n    request,\n    executable as RemoteMethod\n  );\n  const headersMap: Record<string, string> = {};\n  headerNames.forEach((name) => {\n    const value = request.headers.get(name);\n    if (value) headersMap[name] = value;\n  });\n  const headersSubset = trustedHeadersSubset(headersMap);\n  validateHeaderParamsOrThrow(headersSubset, executable as HeadersMethod);\n  validateParametersOrThrow(params, executable as HeadersMethod);\n\n  return executable.handler(context, headersSubset, ...params);\n}\n\nfunction runRouteOrMiddleware(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n  const params = sanitizeParams(\n    deserializeBodyParamsOrThrow(request, executable as RemoteMethod),\n    request,\n    executable as RemoteMethod\n  );\n  validateParametersOrThrow(params, executable as RemoteMethod);\n  return executable.handler(context, ...params);\n}\n\n/** Applies the rewrites the params types declare under a format's `transform` key (trim / case /\n *  replace / stripSeparators) in place, after decode and BEFORE validation. Params only: headers and\n *  return values are never sanitized. A transform over wrong-shaped input can throw (`.trim()` on a\n *  number): the raw params fall through so validation reports the real error instead of a 500. */\nfunction sanitizeParams(params: any[], request: MionRequest, executable: RemoteMethod): any[] {\n  if (!executable.options.sanitizeParams) return params;\n  const formatTransform = executable.paramsJitFns.formatTransform;\n  if (!formatTransform || formatTransform.isNoop) return params;\n  try {\n    const sanitized = formatTransform.fn(params) as any[];\n    (request.body as Mutable<MionRequest['body']>)[executable.id] = sanitized;\n    return sanitized;\n  } catch {\n    return params;\n  }\n}\n\n/** The caller for a method kind. Read ONCE, when the method is registered, so the dispatch loop\n *  reads a field instead of branching on the method type on every request. */\nexport function callerForType(type: RemoteMethod['type']): (...args: any[]) => any {\n  if (type === HandlerType.rawMiddleware) return runRawMiddleware;\n  if (type === HandlerType.headersMiddleware) return runHeadersMiddleware;\n  return runRouteOrMiddleware;\n}\n\n/** The caller already stored on a registered method. */\nexport function getMethodCaller(executable: RemoteMethod) {\n  return executable.methodCaller;\n}\n\n/** Shared, for the members whose id is absent from the body: a fresh empty array per member per request\n *  bought nothing. Frozen, so a handler that tried to mutate its params fails loudly instead of corrupting\n *  the next request; nothing can reach it anyway, an empty tuple is spread into the call. */\nconst EMPTY_PARAMS: any[] = [];\nObject.freeze(EMPTY_PARAMS);\n\nfunction deserializeBodyParamsOrThrow(request: MionRequest, executable: RemoteMethod): any[] {\n  // own key only: an id like `toString` would otherwise read Object.prototype off the parsed body\n  const body = request.body;\n  const params = (Object.hasOwn(body, executable.id) ? body[executable.id] : undefined) as any[] | undefined;\n  // EMPTY_PARAMS is frozen and the decoders mutate what they are handed, so decoding the sentinel would\n  // report a raw serialization error where validation should refuse the missing body.\n  if (!params) return EMPTY_PARAMS;\n  // a route without params has no validator, so a spread string would reach the handler as its characters\n  if (!Array.isArray(params))\n    throw new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'serialization-error',\n      publicMessage: `Invalid params '${executable.id}', params must be an array.`,\n      errorData: {deserializeError: 'params must be an array'},\n    });\n\n  const {decode} = executable.paramsJitFns.json;\n  if (decode.isNoop) return params;\n  try {\n    const decoded = decode.fn(params);\n    (body as Mutable<MionRequest['body']>)[executable.id] = decoded;\n    return decoded;\n  } catch (e: any) {\n    if (isStackOverflow(e)) throw nestingTooDeep(executable, e);\n    // Fixed wire text: the decoder's message quotes internal detail; the original stays on `originalError`.\n    // A refused-key message is safe to pass on: mion's own constant, naming a key the caller sent.\n    const refusedKey = typeof e?.message === 'string' && e.message.startsWith(UNSAFE_PROPERTY_NAME_MESSAGE);\n    const detail = refusedKey ? (e.message as string) : 'Parameters might be of the wrong type.';\n    throw new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'serialization-error',\n      publicMessage: `Invalid params '${executable.id}', can not deserialize. ${detail}`,\n      originalError: e,\n      errorData: {\n        deserializeError: detail,\n      },\n    });\n  }\n}\n\n/** A RangeError out of a compiled function is the engine's stack limit: the request nested deeper\n *  than a recursive type can be walked. Reported as its own typed 4xx, never as an unknown error. */\nfunction isStackOverflow(err: unknown): boolean {\n  return err instanceof RangeError;\n}\n\nfunction nestingTooDeep(executable: RemoteMethod, originalError: Error): RpcError<'request-nesting-too-deep'> {\n  return new FatalError({\n    statusCode: StatusCodes.UNEXPECTED_ERROR,\n    type: 'request-nesting-too-deep',\n    publicMessage: `Invalid params in '${executable.id}', the request is nested too deep.`,\n    originalError,\n  });\n}\n\nfunction validateParametersOrThrow(params: any[], executable: RemoteMethod): void {\n  if (executable.paramsJitFns.isType.isNoop) return;\n  let isValid: boolean;\n  try {\n    isValid = executable.paramsJitFns.isType.fn(params);\n  } catch (e: any) {\n    if (isStackOverflow(e)) throw nestingTooDeep(executable, e);\n    throw e;\n  }\n  if (!isValid) {\n    const validationError: ValidationError = new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'validation-error',\n      publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n      errorData: {\n        typeErrors: executable.paramsJitFns.typeErrors.fn(params),\n      },\n    });\n    throw validationError;\n  }\n}\n\nfunction validateHeaderParamsOrThrow(headers: HeadersSubset<string, string>, executable: HeadersMethod): void {\n  if (!executable.headersParam.jitFns.isType.fn(headers)) {\n    const validationError: ValidationError = new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'validation-error',\n      publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n      errorData: {\n        typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers),\n      },\n    });\n    throw validationError;\n  }\n}\n"],"mappings":"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"}

package/.dist/esm/src/lib/bodyLimit.d.ts

@@ -0,0 +1,5 @@
+import { RemoteMethod, RouteMethod } from '../types/remoteMethods.ts';
+import { RouterOptions } from '../types/general.ts';
+export declare const MIN_CHAIN_BODY_SIZE = 64;
+export declare function resolveChainMaxBodySize(methods: RemoteMethod[], route: RouteMethod, opts: RouterOptions): number | undefined;
+//# sourceMappingURL=bodyLimit.d.ts.map

package/.dist/esm/src/lib/bodyLimit.js

@@ -0,0 +1,35 @@
+import { HandlerType } from "@mionjs/core";
+//#region src/lib/bodyLimit.ts
+/** Floor of a derived chain limit: a body of `{}` / `[]`, whitespace, or a no-params slot is never refused. */
+var MIN_CHAIN_BODY_SIZE = 64;
+/** A member's contribution: its own `maxBodySize` option, else the compact-JSON maximum of its params
+*  tuple the build computed, else unknown. One with no params and no option costs no slot at all. */
+function memberBodyBytes(method) {
+	if (method.type === HandlerType.rawMiddleware) return null;
+	const declared = method.options.maxBodySize;
+	if (declared !== void 0) return declared;
+	if (!method.paramsCount) return null;
+	return method.paramsJsonMaxBytes;
+}
+/** The request limit of one chain, settled once at registration: the route's own `maxBodySize` option,
+*  else, when every member with params has a number, the largest keyed body `{"<id>":<params>,…}` times
+*  `maxBodySizeFactor`, else undefined, meaning the types cannot say and the request takes the adapter's
+*  `maxBodySize` at resolve time. Reads `options.maxBodySize` BEFORE it is overwritten with the result. */
+function resolveChainMaxBodySize(methods, route, opts) {
+	if (route.options.maxBodySize !== void 0) return route.options.maxBodySize;
+	let total = 2;
+	let slots = 0;
+	for (const method of methods) {
+		const bytes = memberBodyBytes(method);
+		if (bytes === null) continue;
+		if (bytes === void 0) return void 0;
+		total += method.quotedId.length + 1 + bytes;
+		slots++;
+	}
+	if (slots > 1) total += slots - 1;
+	return Math.max(Math.ceil(total * opts.maxBodySizeFactor), 64);
+}
+//#endregion
+export { MIN_CHAIN_BODY_SIZE, resolveChainMaxBodySize };
+
+//# sourceMappingURL=bodyLimit.js.map

package/.dist/esm/src/lib/bodyLimit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bodyLimit.js","names":[],"sources":["../../../../src/lib/bodyLimit.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {HandlerType} from '@mionjs/core';\nimport type {RemoteMethod, RouteMethod} from '../types/remoteMethods.ts';\nimport type {RouterOptions} from '../types/general.ts';\n\n/** Floor of a derived chain limit: a body of `{}` / `[]`, whitespace, or a no-params slot is never refused. */\nexport const MIN_CHAIN_BODY_SIZE = 64;\n\n/** A member's contribution: its own `maxBodySize` option, else the compact-JSON maximum of its params\n *  tuple the build computed, else unknown. One with no params and no option costs no slot at all. */\nfunction memberBodyBytes(method: RemoteMethod): number | undefined | null {\n  if (method.type === HandlerType.rawMiddleware) return null;\n  const declared = method.options.maxBodySize;\n  if (declared !== undefined) return declared;\n  if (!method.paramsCount) return null;\n  return method.paramsJsonMaxBytes;\n}\n\n/** The request limit of one chain, settled once at registration: the route's own `maxBodySize` option,\n *  else, when every member with params has a number, the largest keyed body `{\"<id>\":<params>,…}` times\n *  `maxBodySizeFactor`, else undefined, meaning the types cannot say and the request takes the adapter's\n *  `maxBodySize` at resolve time. Reads `options.maxBodySize` BEFORE it is overwritten with the result. */\nexport function resolveChainMaxBodySize(methods: RemoteMethod[], route: RouteMethod, opts: RouterOptions): number | undefined {\n  if (route.options.maxBodySize !== undefined) return route.options.maxBodySize;\n  let total = 2; // the braces\n  let slots = 0;\n  for (const method of methods) {\n    const bytes = memberBodyBytes(method);\n    if (bytes === null) continue;\n    if (bytes === undefined) return undefined;\n    total += method.quotedId.length + 1 + bytes; // `\"id\":` + params\n    slots++;\n  }\n  if (slots > 1) total += slots - 1; // the commas\n  return Math.max(Math.ceil(total * opts.maxBodySizeFactor), MIN_CHAIN_BODY_SIZE);\n}\n"],"mappings":";;;AAYA,IAAa,sBAAsB;;;AAInC,SAAS,gBAAgB,QAAiD;CACxE,IAAI,OAAO,SAAS,YAAY,eAAe,OAAO;CACtD,MAAM,WAAW,OAAO,QAAQ;CAChC,IAAI,aAAa,KAAA,GAAW,OAAO;CACnC,IAAI,CAAC,OAAO,aAAa,OAAO;CAChC,OAAO,OAAO;AAChB;;;;;AAMA,SAAgB,wBAAwB,SAAyB,OAAoB,MAAyC;CAC5H,IAAI,MAAM,QAAQ,gBAAgB,KAAA,GAAW,OAAO,MAAM,QAAQ;CAClE,IAAI,QAAQ;CACZ,IAAI,QAAQ;CACZ,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,QAAQ,gBAAgB,MAAM;EACpC,IAAI,UAAU,MAAM;EACpB,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;EAChC,SAAS,OAAO,SAAS,SAAS,IAAI;EACtC;CACF;CACA,IAAI,QAAQ,GAAG,SAAS,QAAQ;CAChC,OAAO,KAAK,IAAI,KAAK,KAAK,QAAQ,KAAK,iBAAiB,GAAA,EAAsB;AAChF"}

package/.dist/esm/src/lib/bodyReader.d.ts

@@ -0,0 +1,10 @@
+import { RpcError } from '@mionjs/core';
+export declare function requestPayloadTooLarge(): RpcError<'request-payload-too-large'>;
+export declare const BodyReadStrategy: {
+    readonly stream: 1;
+    readonly text: 2;
+    readonly buffered: 3;
+};
+export type BodyReadStrategy = (typeof BodyReadStrategy)[keyof typeof BodyReadStrategy];
+export declare function readRequestBody(req: Request, maxBodySize: number, strategy: BodyReadStrategy): Promise<string | undefined>;
+//# sourceMappingURL=bodyReader.d.ts.map

package/.dist/esm/src/lib/bodyReader.js

@@ -0,0 +1,76 @@
+import { FatalError, StatusCodes } from "@mionjs/core";
+//#region src/lib/bodyReader.ts
+/** The 413 a platform adapter answers when a body passes the route's limit while it arrives. */
+function requestPayloadTooLarge() {
+	return new FatalError({
+		statusCode: StatusCodes.PAYLOAD_TOO_LARGE,
+		publicMessage: "Payload Too Large",
+		type: "request-payload-too-large"
+	});
+}
+/** How a fetch-style runtime reads a body fastest, a numeric code so the per-request check is one integer
+*  compare. Measured on each runtime with a real server:
+*  `stream` pulls the body stream and decodes once: node's Request (undici, the vercel node runtime), where
+*  `text()` is slower than its own stream at every size.
+*  `text` is `text()` when a content-length is declared, the stream otherwise: workerd, where both are
+*  native and only the stream can stop an upload mid-flight.
+*  `buffered` is `text()` or `arrayBuffer()`, never the stream reader: bun buffers the body natively and its
+*  stream reader is over ten times slower, so its server-wide native limit is the one mid-flight guard. */
+var BodyReadStrategy = {
+	stream: 1,
+	text: 2,
+	buffered: 3
+};
+var utf8 = new TextDecoder();
+/** Reads a fetch-style request body as text against the route's limit, the way the runtime reads fastest
+*  (`strategy`). A declared `content-length` past the limit is refused before a byte is read. Sizes are
+*  counted in bytes, never less than the character count the router checks again before parsing, so the
+*  byte-exact refusal here always fires first. Undefined for a request with no body, else the router's 413. */
+async function readRequestBody(req, maxBodySize, strategy) {
+	if (!req.body) return void 0;
+	const declared = req.headers.get("content-length");
+	if (declared !== null) {
+		if (Number(declared) > maxBodySize) throw requestPayloadTooLarge();
+		if (strategy !== BodyReadStrategy.stream) return req.text();
+		return readStream(req, maxBodySize);
+	}
+	if (strategy !== BodyReadStrategy.buffered) return readStream(req, maxBodySize);
+	const bytes = await req.arrayBuffer();
+	if (bytes.byteLength > maxBodySize) throw requestPayloadTooLarge();
+	return utf8.decode(bytes);
+}
+/** Pulls the body chunk by chunk with the running size counted, cancels the stream the moment it
+*  passes the limit so the rest is never pulled, and decodes ONCE at the end. */
+async function readStream(req, maxBodySize) {
+	const reader = req.body.getReader();
+	const chunks = [];
+	let size = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		size += value.byteLength;
+		if (size > maxBodySize) {
+			await reader.cancel();
+			throw requestPayloadTooLarge();
+		}
+		chunks.push(value);
+	}
+	return decodeOnce(chunks, size);
+}
+/** One UTF-8 decode over the whole body: a single chunk decodes in place, several are joined into
+*  one buffer first so a character split across chunks is never decoded in halves. */
+function decodeOnce(chunks, size) {
+	if (chunks.length === 0) return "";
+	if (chunks.length === 1) return utf8.decode(chunks[0]);
+	const joined = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		joined.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return utf8.decode(joined);
+}
+//#endregion
+export { BodyReadStrategy, readRequestBody, requestPayloadTooLarge };
+
+//# sourceMappingURL=bodyReader.js.map

package/.dist/esm/src/lib/bodyReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bodyReader.js","names":[],"sources":["../../../../src/lib/bodyReader.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {FatalError, RpcError, StatusCodes} from '@mionjs/core';\n\n/** The 413 a platform adapter answers when a body passes the route's limit while it arrives. */\nexport function requestPayloadTooLarge(): RpcError<'request-payload-too-large'> {\n  return new FatalError({\n    statusCode: StatusCodes.PAYLOAD_TOO_LARGE,\n    publicMessage: 'Payload Too Large',\n    type: 'request-payload-too-large',\n  });\n}\n\n/** How a fetch-style runtime reads a body fastest, a numeric code so the per-request check is one integer\n *  compare. Measured on each runtime with a real server:\n *  `stream` pulls the body stream and decodes once: node's Request (undici, the vercel node runtime), where\n *  `text()` is slower than its own stream at every size.\n *  `text` is `text()` when a content-length is declared, the stream otherwise: workerd, where both are\n *  native and only the stream can stop an upload mid-flight.\n *  `buffered` is `text()` or `arrayBuffer()`, never the stream reader: bun buffers the body natively and its\n *  stream reader is over ten times slower, so its server-wide native limit is the one mid-flight guard. */\nexport const BodyReadStrategy = {stream: 1, text: 2, buffered: 3} as const;\nexport type BodyReadStrategy = (typeof BodyReadStrategy)[keyof typeof BodyReadStrategy];\n\n// One decoder for every request: a non-streaming `decode` keeps no state between calls, so sharing it is\n// safe. A streaming decode (`{stream: true}`) would not be, which is why the stream path decodes ONCE.\nconst utf8 = new TextDecoder();\n\n/** Reads a fetch-style request body as text against the route's limit, the way the runtime reads fastest\n *  (`strategy`). A declared `content-length` past the limit is refused before a byte is read. Sizes are\n *  counted in bytes, never less than the character count the router checks again before parsing, so the\n *  byte-exact refusal here always fires first. Undefined for a request with no body, else the router's 413. */\nexport async function readRequestBody(\n  req: Request,\n  maxBodySize: number,\n  strategy: BodyReadStrategy\n): Promise<string | undefined> {\n  if (!req.body) return undefined;\n  const declared = req.headers.get('content-length');\n  if (declared !== null) {\n    if (Number(declared) > maxBodySize) throw requestPayloadTooLarge();\n    // the runtime delivers exactly content-length bytes: one native decode\n    if (strategy !== BodyReadStrategy.stream) return req.text();\n    return readStream(req, maxBodySize);\n  }\n  if (strategy !== BodyReadStrategy.buffered) return readStream(req, maxBodySize);\n  // no content-length on a runtime whose stream reader is the slow path: take the bytes whole\n  // (the native server limit already bounded them) and refuse past the limit before decoding\n  const bytes = await req.arrayBuffer();\n  if (bytes.byteLength > maxBodySize) throw requestPayloadTooLarge();\n  return utf8.decode(bytes);\n}\n\n/** Pulls the body chunk by chunk with the running size counted, cancels the stream the moment it\n *  passes the limit so the rest is never pulled, and decodes ONCE at the end. */\nasync function readStream(req: Request, maxBodySize: number): Promise<string> {\n  const reader = req.body!.getReader();\n  const chunks: Uint8Array[] = [];\n  let size = 0;\n  for (;;) {\n    const {done, value} = await reader.read();\n    if (done) break;\n    size += value.byteLength;\n    if (size > maxBodySize) {\n      await reader.cancel();\n      throw requestPayloadTooLarge();\n    }\n    chunks.push(value);\n  }\n  return decodeOnce(chunks, size);\n}\n\n/** One UTF-8 decode over the whole body: a single chunk decodes in place, several are joined into\n *  one buffer first so a character split across chunks is never decoded in halves. */\nfunction decodeOnce(chunks: Uint8Array[], size: number): string {\n  if (chunks.length === 0) return '';\n  if (chunks.length === 1) return utf8.decode(chunks[0]);\n  const joined = new Uint8Array(size);\n  let offset = 0;\n  for (const chunk of chunks) {\n    joined.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return utf8.decode(joined);\n}\n"],"mappings":";;;AAUA,SAAgB,yBAAgE;CAC9E,OAAO,IAAI,WAAW;EACpB,YAAY,YAAY;EACxB,eAAe;EACf,MAAM;CACR,CAAC;AACH;;;;;;;;;AAUA,IAAa,mBAAmB;CAAC,QAAQ;CAAG,MAAM;CAAG,UAAU;AAAC;AAKhE,IAAM,OAAO,IAAI,YAAY;;;;;AAM7B,eAAsB,gBACpB,KACA,aACA,UAC6B;CAC7B,IAAI,CAAC,IAAI,MAAM,OAAO,KAAA;CACtB,MAAM,WAAW,IAAI,QAAQ,IAAI,gBAAgB;CACjD,IAAI,aAAa,MAAM;EACrB,IAAI,OAAO,QAAQ,IAAI,aAAa,MAAM,uBAAuB;EAEjE,IAAI,aAAa,iBAAiB,QAAQ,OAAO,IAAI,KAAK;EAC1D,OAAO,WAAW,KAAK,WAAW;CACpC;CACA,IAAI,aAAa,iBAAiB,UAAU,OAAO,WAAW,KAAK,WAAW;CAG9E,MAAM,QAAQ,MAAM,IAAI,YAAY;CACpC,IAAI,MAAM,aAAa,aAAa,MAAM,uBAAuB;CACjE,OAAO,KAAK,OAAO,KAAK;AAC1B;;;AAIA,eAAe,WAAW,KAAc,aAAsC;CAC5E,MAAM,SAAS,IAAI,KAAM,UAAU;CACnC,MAAM,SAAuB,CAAC;CAC9B,IAAI,OAAO;CACX,SAAS;EACP,MAAM,EAAC,MAAM,UAAS,MAAM,OAAO,KAAK;EACxC,IAAI,MAAM;EACV,QAAQ,MAAM;EACd,IAAI,OAAO,aAAa;GACtB,MAAM,OAAO,OAAO;GACpB,MAAM,uBAAuB;EAC/B;EACA,OAAO,KAAK,KAAK;CACnB;CACA,OAAO,WAAW,QAAQ,IAAI;AAChC;;;AAIA,SAAS,WAAW,QAAsB,MAAsB;CAC9D,IAAI,OAAO,WAAW,GAAG,OAAO;CAChC,IAAI,OAAO,WAAW,GAAG,OAAO,KAAK,OAAO,OAAO,EAAE;CACrD,MAAM,SAAS,IAAI,WAAW,IAAI;CAClC,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ;EAC1B,OAAO,IAAI,OAAO,MAAM;EACxB,UAAU,MAAM;CAClB;CACA,OAAO,KAAK,OAAO,MAAM;AAC3B"}

package/.dist/esm/src/lib/dispatchError.d.ts

@@ -1,6 +1,10 @@
 import { RpcError } from '@mionjs/core';
 import { CallContext, MionHeaders, MionResponse } from '../types/context.ts';
-import { RemoteMethod } from '../types/remoteMethods.ts';
 export declare function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse;
-export declare function onExecutableError(context: CallContext, executable: RemoteMethod, err: any | RpcError<string> | Error): void;
+export declare function errorHeaderValue(type: string): string;
+export declare function markResponseFailed(context: CallContext, rpcError: RpcError<string>, fallbackStatus: number): void;
+export declare function toRpcError(err: unknown): RpcError<string>;
+export declare function recordUndeclaredError(context: CallContext, key: string, err: any): void;
+export declare function addThrownError(context: CallContext, key: string, rpcError: RpcError<string>): void;
+export declare function hasThrownError(context: CallContext, key: string): boolean;
 //# sourceMappingURL=dispatchError.d.ts.map