@mionjs/router 0.13.2 → 0.14.0

package/.dist/cjs/src/callContext.cjs

@@ -1,81 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src_constants = require("./constants.cjs");
-const require_src_batches = require("./batches.cjs");
-const require_src_router = require("./router.cjs");
-let _mionjs_core = require("@mionjs/core");
-//#region src/callContext.ts
-/** Resolves a request to the REGISTERED chain that answers it, allocating NOTHING, so a streaming adapter
-*  calls it BEFORE the body to read against `chain.maxBodySize` and `createContextFromChain` after.
-*  Nothing of the request's own may survive the read: such an object is promoted to the old heap and the
-*  parsed body attached to it is promoted with it, which on a 4 MB body costs garbage-collector throughput.
-*  The chain is SHARED and long-lived: mutating what this returns damages the route for the whole process.
-*  An unknown path or batch id resolves to a not-found chain that never reads the body (`readsBody` false)
-*  and runs only the global middlewares that declare `alwaysRun`. */
-function resolveExecutionChain(path, urlQuery, rawRequest) {
-	const opts = require_src_router.getRouterOptions();
-	return getExecutionChain(path, opts.pathTransform?.(rawRequest, path) || path, urlQuery, rawRequest, opts);
-}
-/** `path` and `urlQuery` are the request's; a route chain's own path wins, not-found and batch chains use the request's. */
-function createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders, reqRawBody, reqBodyType) {
-	const request = {
-		headers: reqHeaders,
-		rawBody: reqRawBody,
-		bodyType: reqBodyType ?? getRequestBodyType(reqRawBody),
-		body: EMPTY_BODY,
-		thrownErrors: void 0
-	};
-	const response = {
-		statusCode: _mionjs_core.StatusCodes.OK,
-		contentType: require_src_constants.JSON_CONTENT_TYPE,
-		hasErrors: false,
-		fatalError: void 0,
-		headers: respHeaders,
-		body: {}
-	};
-	const contextDataFactory = require_src_router.getRouterOptions().contextDataFactory;
-	return {
-		path: chain.path ?? path,
-		request,
-		response,
-		executionChain: chain,
-		maxBodySize: chain.maxBodySize,
-		readsBody: chain.readsBody,
-		shared: contextDataFactory ? contextDataFactory() : {},
-		urlQuery,
-		batchId: chain.batchId,
-		batchRouteIds: chain.batchRouteIds
-	};
-}
-var EMPTY_BODY = Object.freeze({});
-/** The one-call form, for a caller that already has the body (a host that parsed it, `dispatchRoute`, a test). */
-function createCallContext(path, urlQuery, rawRequest, reqHeaders, respHeaders, reqRawBody, reqBodyType) {
-	return createContextFromChain(resolveExecutionChain(path, urlQuery, rawRequest), path, urlQuery, reqHeaders, respHeaders, reqRawBody, reqBodyType);
-}
-/** The wire form of a body: a string is stringified JSON, anything else a parsed object. A body
-*  not yet read (a context built before it) reads as an object until the body arrives. */
-function getRequestBodyType(rawBody) {
-	if (typeof rawBody === "string") return _mionjs_core.SerializerModes.stringifyJson;
-	if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array) throw new Error("mion: a byte request body has no encoder; send the body as a JSON string or a parsed object.");
-	return _mionjs_core.SerializerModes.json;
-}
-function getExecutionChain(originalPath, transformedPath, urlQuery, rawRequest, opts) {
-	if (!!opts.basePath ? originalPath.endsWith(_mionjs_core.MION_BATCH_PATH) : originalPath === _mionjs_core.MION_BATCH_PATH) return require_src_batches.getBatchExecutionChain(rawRequest, opts, urlQuery) ?? notFoundChain(_mionjs_core.MION_ROUTES.batchNotFound);
-	return require_src_router.getRouteExecutionChain(transformedPath) ?? notFoundChain(_mionjs_core.MION_ROUTES.notFound);
-}
-/** mion's own not-found chains are built by initRouter, so an absent one is a bug, not a request error. */
-function notFoundChain(chainId) {
-	const executionChain = require_src_router.getNotFoundExecutionChain(chainId);
-	if (!executionChain) throw new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
-		type: "not-found",
-		publicMessage: "Not-found chain is not registered. This should never happen."
-	});
-	return executionChain;
-}
-//#endregion
-exports.createCallContext = createCallContext;
-exports.createContextFromChain = createContextFromChain;
-exports.getRequestBodyType = getRequestBodyType;
-exports.resolveExecutionChain = resolveExecutionChain;
-
-//# sourceMappingURL=callContext.cjs.map

package/.dist/cjs/src/callContext.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"callContext.cjs","names":[],"sources":["../../../src/callContext.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 {getRouteExecutionChain, getNotFoundExecutionChain, getRouterOptions} from './router.ts';\nimport type {CallContext, MionHeaders, MionRequest, MionResponse, RawRequestBody} from './types/context.ts';\nimport type {RouterOptions} from './types/general.ts';\nimport type {MethodsExecutionChain} from './types/remoteMethods.ts';\nimport {StatusCodes, SerializerModes, SerializerCode, FatalError, MION_ROUTES, MION_BATCH_PATH} from '@mionjs/core';\nimport type {AnyObject} from '@mionjs/core';\nimport {getBatchExecutionChain} from './batches.ts';\nimport {JSON_CONTENT_TYPE} from './constants.ts';\n\n// ############# CONTEXT CREATION #############\n\n/** Resolves a request to the REGISTERED chain that answers it, allocating NOTHING, so a streaming adapter\n *  calls it BEFORE the body to read against `chain.maxBodySize` and `createContextFromChain` after.\n *  Nothing of the request's own may survive the read: such an object is promoted to the old heap and the\n *  parsed body attached to it is promoted with it, which on a 4 MB body costs garbage-collector throughput.\n *  The chain is SHARED and long-lived: mutating what this returns damages the route for the whole process.\n *  An unknown path or batch id resolves to a not-found chain that never reads the body (`readsBody` false)\n *  and runs only the global middlewares that declare `alwaysRun`. */\nexport function resolveExecutionChain(path: string, urlQuery: string | undefined, rawRequest: unknown): MethodsExecutionChain {\n  const opts = getRouterOptions();\n  const transformedPath = opts.pathTransform?.(rawRequest, path) || path;\n  return getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);\n}\n\n/** `path` and `urlQuery` are the request's; a route chain's own path wins, not-found and batch chains use the request's. */\nexport function createContextFromChain(\n  chain: MethodsExecutionChain,\n  path: string,\n  urlQuery: string | undefined,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  reqRawBody?: RawRequestBody,\n  reqBodyType?: SerializerCode\n): CallContext {\n  const request: MionRequest = {\n    headers: reqHeaders,\n    rawBody: reqRawBody,\n    bodyType: reqBodyType ?? getRequestBodyType(reqRawBody),\n    // Shared and FROZEN: the parse replaces it, and a write before the parse would leak across requests\n    body: EMPTY_BODY,\n    thrownErrors: undefined,\n  } as MionRequest;\n  const response: MionResponse = {\n    statusCode: StatusCodes.OK,\n    contentType: JSON_CONTENT_TYPE,\n    hasErrors: false,\n    fatalError: undefined,\n    headers: respHeaders,\n    body: {},\n  } as MionResponse;\n  const contextDataFactory = getRouterOptions().contextDataFactory;\n\n  return {\n    path: chain.path ?? path,\n    request,\n    response,\n    executionChain: chain,\n    maxBodySize: chain.maxBodySize,\n    readsBody: chain.readsBody,\n    // Eager: a lazy defineProperty puts contexts in V8 dictionary mode (2x heap, 6% less throughput at 1 KB)\n    shared: contextDataFactory ? contextDataFactory() : {},\n    urlQuery,\n    batchId: chain.batchId,\n    batchRouteIds: chain.batchRouteIds,\n  } as CallContext;\n}\n\nconst EMPTY_BODY: Readonly<AnyObject> = Object.freeze({});\n\n/** The one-call form, for a caller that already has the body (a host that parsed it, `dispatchRoute`, a test). */\nexport function createCallContext(\n  path: string,\n  urlQuery: string | undefined,\n  rawRequest: unknown,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  reqRawBody?: RawRequestBody,\n  reqBodyType?: SerializerCode\n): CallContext {\n  const chain = resolveExecutionChain(path, urlQuery, rawRequest);\n  return createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders, reqRawBody, reqBodyType);\n}\n\n// ############# HELPER FUNCTIONS #############\n\n/** The wire form of a body: a string is stringified JSON, anything else a parsed object. A body\n *  not yet read (a context built before it) reads as an object until the body arrives. */\nexport function getRequestBodyType(rawBody: RawRequestBody | undefined): SerializerCode {\n  if (typeof rawBody === 'string') return SerializerModes.stringifyJson;\n  if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array)\n    throw new Error('mion: a byte request body has no encoder; send the body as a JSON string or a parsed object.');\n  return SerializerModes.json;\n}\n\nfunction getExecutionChain(\n  originalPath: string,\n  transformedPath: string,\n  urlQuery: string | undefined,\n  rawRequest: unknown,\n  opts: RouterOptions\n): MethodsExecutionChain {\n  const hasPrefix = !!opts.basePath;\n  // the batch key ends the path under any prefix (/mion-batch, /api/v1/mion-batch); the query id picks the chain\n  const isBatchPath = hasPrefix ? originalPath.endsWith(MION_BATCH_PATH) : originalPath === MION_BATCH_PATH;\n  if (isBatchPath) {\n    return getBatchExecutionChain(rawRequest, opts, urlQuery) ?? notFoundChain(MION_ROUTES.batchNotFound);\n  }\n\n  return getRouteExecutionChain(transformedPath) ?? notFoundChain(MION_ROUTES.notFound);\n}\n\n/** mion's own not-found chains are built by initRouter, so an absent one is a bug, not a request error. */\nfunction notFoundChain(chainId: string): MethodsExecutionChain {\n  const executionChain = getNotFoundExecutionChain(chainId);\n  if (!executionChain) {\n    throw new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'not-found',\n      publicMessage: 'Not-found chain is not registered. This should never happen.',\n    });\n  }\n  return executionChain;\n}\n"],"mappings":";;;;;;;;;;;;;AAyBA,SAAgB,sBAAsB,MAAc,UAA8B,YAA4C;CAC5H,MAAM,OAAO,mBAAA,iBAAiB;CAE9B,OAAO,kBAAkB,MADD,KAAK,gBAAgB,YAAY,IAAI,KAAK,MAClB,UAAU,YAAY,IAAI;AAC5E;;AAGA,SAAgB,uBACd,OACA,MACA,UACA,YACA,aACA,YACA,aACa;CACb,MAAM,UAAuB;EAC3B,SAAS;EACT,SAAS;EACT,UAAU,eAAe,mBAAmB,UAAU;EAEtD,MAAM;EACN,cAAc,KAAA;CAChB;CACA,MAAM,WAAyB;EAC7B,YAAY,aAAA,YAAY;EACxB,aAAa,sBAAA;EACb,WAAW;EACX,YAAY,KAAA;EACZ,SAAS;EACT,MAAM,CAAC;CACT;CACA,MAAM,qBAAqB,mBAAA,iBAAiB,EAAE;CAE9C,OAAO;EACL,MAAM,MAAM,QAAQ;EACpB;EACA;EACA,gBAAgB;EAChB,aAAa,MAAM;EACnB,WAAW,MAAM;EAEjB,QAAQ,qBAAqB,mBAAmB,IAAI,CAAC;EACrD;EACA,SAAS,MAAM;EACf,eAAe,MAAM;CACvB;AACF;AAEA,IAAM,aAAkC,OAAO,OAAO,CAAC,CAAC;;AAGxD,SAAgB,kBACd,MACA,UACA,YACA,YACA,aACA,YACA,aACa;CAEb,OAAO,uBADO,sBAAsB,MAAM,UAAU,UACtB,GAAO,MAAM,UAAU,YAAY,aAAa,YAAY,WAAW;AACvG;;;AAMA,SAAgB,mBAAmB,SAAqD;CACtF,IAAI,OAAO,YAAY,UAAU,OAAO,aAAA,gBAAgB;CACxD,IAAI,mBAAmB,eAAe,mBAAmB,YACvD,MAAM,IAAI,MAAM,8FAA8F;CAChH,OAAO,aAAA,gBAAgB;AACzB;AAEA,SAAS,kBACP,cACA,iBACA,UACA,YACA,MACuB;CAIvB,IADoB,CAFD,CAAC,KAAK,WAEO,aAAa,SAAS,aAAA,eAAe,IAAI,iBAAiB,aAAA,iBAExF,OAAO,oBAAA,uBAAuB,YAAY,MAAM,QAAQ,KAAK,cAAc,aAAA,YAAY,aAAa;CAGtG,OAAO,mBAAA,uBAAuB,eAAe,KAAK,cAAc,aAAA,YAAY,QAAQ;AACtF;;AAGA,SAAS,cAAc,SAAwC;CAC7D,MAAM,iBAAiB,mBAAA,0BAA0B,OAAO;CACxD,IAAI,CAAC,gBACH,MAAM,IAAI,aAAA,WAAW;EACnB,YAAY,aAAA,YAAY;EACxB,MAAM;EACN,eAAe;CACjB,CAAC;CAEH,OAAO;AACT"}

package/.dist/cjs/src/callContext.d.ts

@@ -1,8 +0,0 @@
-import { CallContext, MionHeaders, RawRequestBody } from './types/context.ts';
-import { MethodsExecutionChain } from './types/remoteMethods.ts';
-import { SerializerCode } from '@mionjs/core';
-export declare function resolveExecutionChain(path: string, urlQuery: string | undefined, rawRequest: unknown): MethodsExecutionChain;
-export declare function createContextFromChain(chain: MethodsExecutionChain, path: string, urlQuery: string | undefined, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqRawBody?: RawRequestBody, reqBodyType?: SerializerCode): CallContext;
-export declare function createCallContext(path: string, urlQuery: string | undefined, rawRequest: unknown, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqRawBody?: RawRequestBody, reqBodyType?: SerializerCode): CallContext;
-export declare function getRequestBodyType(rawBody: RawRequestBody | undefined): SerializerCode;
-//# sourceMappingURL=callContext.d.ts.map

package/.dist/cjs/src/constants.cjs

@@ -1,26 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/constants.ts
-var DEFAULT_ROUTE_OPTIONS = {
-	basePath: "",
-	suffix: "",
-	pathTransform: void 0,
-	/** set to true to generate router spec for clients.  */
-	getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === "true",
-	autoGenerateErrorId: false,
-	/** Every chain step is awaited by default, so the chain keeps yielding between steps */
-	alwaysAwait: true,
-	/** A type-derived request limit is the JSON maximum times this factor */
-	maxBodySizeFactor: 2,
-	releaseRawBody: true,
-	responseHeaders: {},
-	apiVersionCheck: true,
-	getAllRemoteMethodsMaxNumber: 100
-};
-var MAX_ROUTE_NESTING = 10;
-var JSON_CONTENT_TYPE = "application/json; charset=utf-8";
-//#endregion
-exports.DEFAULT_ROUTE_OPTIONS = DEFAULT_ROUTE_OPTIONS;
-exports.JSON_CONTENT_TYPE = JSON_CONTENT_TYPE;
-exports.MAX_ROUTE_NESTING = MAX_ROUTE_NESTING;
-
-//# sourceMappingURL=constants.cjs.map

package/.dist/cjs/src/constants.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.cjs","names":[],"sources":["../../../src/constants.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 {RouterOptions} from './types/general.ts';\n\nexport const DEFAULT_ROUTE_OPTIONS = {\n  basePath: '',\n  suffix: '',\n  pathTransform: undefined,\n  /** set to true to generate router spec for clients.  */\n  getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === 'true',\n  autoGenerateErrorId: false,\n  /** Every chain step is awaited by default, so the chain keeps yielding between steps */\n  alwaysAwait: true,\n  /** A type-derived request limit is the JSON maximum times this factor */\n  maxBodySizeFactor: 2,\n  releaseRawBody: true,\n  responseHeaders: {},\n  apiVersionCheck: true,\n  getAllRemoteMethodsMaxNumber: 100,\n} as Readonly<RouterOptions>;\n\nexport const MAX_ROUTE_NESTING = 10;\n\nexport const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';\n"],"mappings":";;AASA,IAAa,wBAAwB;CACnC,UAAU;CACV,QAAQ;CACR,eAAe,KAAA;;CAEf,qBAAqB,QAAQ,IAAI,yBAAyB;CAC1D,qBAAqB;;CAErB,aAAa;;CAEb,mBAAmB;CACnB,gBAAgB;CAChB,iBAAiB,CAAC;CAClB,iBAAiB;CACjB,8BAA8B;AAChC;AAEA,IAAa,oBAAoB;AAEjC,IAAa,oBAAoB"}

package/.dist/cjs/src/constants.d.ts

@@ -1,5 +0,0 @@
-import { RouterOptions } from './types/general.ts';
-export declare const DEFAULT_ROUTE_OPTIONS: Readonly<RouterOptions>;
-export declare const MAX_ROUTE_NESTING = 10;
-export declare const JSON_CONTENT_TYPE = "application/json; charset=utf-8";
-//# sourceMappingURL=constants.d.ts.map

package/.dist/cjs/src/dispatch.cjs

@@ -1,239 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src_lib_dispatchError = require("./lib/dispatchError.cjs");
-const require_src_callContext = require("./callContext.cjs");
-const require_src_router = require("./router.cjs");
-let _mionjs_core = require("@mionjs/core");
-let _mionjs_run_types = require("@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) {
-	return dispatchWithContext(require_src_callContext.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 ?? require_src_callContext.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 = require_src_router.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 = require_src_callContext.createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders);
-	require_src_lib_dispatchError.recordUndeclaredError(context, _mionjs_core.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) {
-			require_src_lib_dispatchError.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) => require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, err)).then(() => runExecutionChain(context, rawRequest, rawResponse, opts, i + 1));
-			applyResult(context, executable, result);
-		} catch (err) {
-			require_src_lib_dispatchError.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 || (0, _mionjs_core.isNativeError)(result)) require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, result);
-		return;
-	}
-	if (isMionError) {
-		if (result.isFatal === true) require_src_lib_dispatchError.markResponseFailed(context, result, _mionjs_core.StatusCodes.APPLICATION_ERROR);
-	} else if ((0, _mionjs_core.isNativeError)(result)) {
-		require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, result);
-		return;
-	}
-	if (executable.headersReturn && result instanceof _mionjs_core.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 = (0, _mionjs_core.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 === _mionjs_core.HandlerType.rawMiddleware) return runRawMiddleware;
-	if (type === _mionjs_core.HandlerType.headersMiddleware) return runHeadersMiddleware;
-	return runRouteOrMiddleware;
-}
-/** The caller already stored on a registered method. */
-function getMethodCaller(executable) {
-	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 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 _mionjs_core.FatalError({
-		statusCode: _mionjs_core.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(_mionjs_run_types.UNSAFE_PROPERTY_NAME_MESSAGE) ? e.message : "Parameters might be of the wrong type.";
-		throw new _mionjs_core.FatalError({
-			statusCode: _mionjs_core.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 _mionjs_core.FatalError({
-		statusCode: _mionjs_core.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;
-	let isValid;
-	try {
-		isValid = executable.paramsJitFns.isType.fn(params);
-	} catch (e) {
-		if (isStackOverflow(e)) throw nestingTooDeep(executable, e);
-		throw e;
-	}
-	if (!isValid) throw new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.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)) throw new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
-		type: "validation-error",
-		publicMessage: `Invalid params in '${executable.id}', validation failed.`,
-		errorData: { typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers) }
-	});
-}
-//#endregion
-exports.callerForType = callerForType;
-exports.dispatchMaybeSync = dispatchMaybeSync;
-exports.dispatchPlatformError = dispatchPlatformError;
-exports.dispatchRoute = dispatchRoute;
-exports.dispatchWithContext = dispatchWithContext;
-exports.getMethodCaller = getMethodCaller;
-
-//# sourceMappingURL=dispatch.cjs.map

package/.dist/cjs/src/dispatch.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"dispatch.cjs","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/cjs/src/dispatch.d.ts

@@ -1,10 +0,0 @@
-import { CallContext, MionResponse, MionHeaders, RawRequestBody } from './types/context.ts';
-import { RemoteMethod, MethodsExecutionChain } from './types/remoteMethods.ts';
-import { SerializerCode, RpcError } from '@mionjs/core';
-export declare function dispatchRoute<Req, Resp>(path: string, reqRawBody: RawRequestBody, reqHeaders: MionHeaders, respHeaders: MionHeaders, rawRequest: Req, rawResponse?: Resp, reqBodyType?: SerializerCode, urlQuery?: string): Promise<MionResponse>;
-export declare function dispatchWithContext<Req, Resp>(context: CallContext, rawRequest: Req, rawResponse?: Resp, reqRawBody?: RawRequestBody, reqBodyType?: SerializerCode): Promise<MionResponse>;
-export declare function dispatchMaybeSync<Req, Resp>(context: CallContext, rawRequest: Req, rawResponse?: Resp): MionResponse | Promise<MionResponse>;
-export declare function dispatchPlatformError<Req, Resp>(chain: MethodsExecutionChain, path: string, urlQuery: string | undefined, platformError: RpcError<string>, reqHeaders: MionHeaders, respHeaders: MionHeaders, rawRequest: Req, rawResponse?: Resp): Promise<MionResponse>;
-export declare function callerForType(type: RemoteMethod['type']): (...args: any[]) => any;
-export declare function getMethodCaller(executable: RemoteMethod): (...args: any[]) => any;
-//# sourceMappingURL=dispatch.d.ts.map

package/.dist/cjs/src/lib/bodyLimit.cjs

@@ -1,37 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _mionjs_core = require("@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 === _mionjs_core.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
-exports.MIN_CHAIN_BODY_SIZE = MIN_CHAIN_BODY_SIZE;
-exports.resolveChainMaxBodySize = resolveChainMaxBodySize;
-
-//# sourceMappingURL=bodyLimit.cjs.map

package/.dist/cjs/src/lib/bodyLimit.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"bodyLimit.cjs","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,aAAA,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/cjs/src/lib/bodyLimit.d.ts

@@ -1,5 +0,0 @@
-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/cjs/src/lib/bodyReader.cjs

@@ -1,79 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _mionjs_core = require("@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 _mionjs_core.FatalError({
-		statusCode: _mionjs_core.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
-exports.BodyReadStrategy = BodyReadStrategy;
-exports.readRequestBody = readRequestBody;
-exports.requestPayloadTooLarge = requestPayloadTooLarge;
-
-//# sourceMappingURL=bodyReader.cjs.map

package/.dist/cjs/src/lib/bodyReader.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"bodyReader.cjs","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,aAAA,WAAW;EACpB,YAAY,aAAA,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/cjs/src/lib/bodyReader.d.ts

@@ -1,10 +0,0 @@
-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