@mionjs/router 0.8.10 → 0.13.2

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

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

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

@@ -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/cjs/src/lib/bodyReader.cjs

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

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

@@ -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/cjs/src/lib/dispatchError.cjs

@@ -1,39 +1,82 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const core = require("@mionjs/core");
+const require_src_constants = require("../constants.cjs");
+let _mionjs_core = require("@mionjs/core");
+//#region src/lib/dispatchError.ts
+/** The response for an error raised outside the router by any adapter; it goes in `@thrownErrors` like a route error. */
 function getRouterFatalErrorResponse(returnErr, respHeaders) {
-  const body = {
-    "@thrownErrors": { [core.MION_ROUTES.platformError]: returnErr }
-  };
-  respHeaders.set("content-type", "application/json; charset=utf-8");
-  const response = {
-    statusCode: returnErr.statusCode || core.StatusCodes.SERVER_ERROR,
-    // Global errors are always unexpected
-    hasErrors: true,
-    headers: respHeaders,
-    body,
-    rawBody: JSON.stringify(body),
-    serializer: core.SerializerModes.json
-    // global errors are always json
-  };
-  return response;
+	(0, _mionjs_core.markFatal)(returnErr);
+	const body = { "@thrownErrors": { [_mionjs_core.MION_ROUTES.platformError]: returnErr } };
+	respHeaders.set("x-rpc-error", errorHeaderValue(returnErr.type));
+	return {
+		statusCode: returnErr.statusCode || _mionjs_core.StatusCodes.SERVER_ERROR,
+		contentType: require_src_constants.JSON_CONTENT_TYPE,
+		hasErrors: true,
+		fatalError: returnErr,
+		headers: respHeaders,
+		body
+	};
 }
-function onExecutableError(context, executable, err) {
-  const response = context.response;
-  const path = executable.id;
-  const rpcError = err instanceof core.RpcError ? err : new core.RpcError({
-    statusCode: core.StatusCodes.UNEXPECTED_ERROR,
-    publicMessage: `Unknown error in handler "${path}" of route ExecutionChain.`,
-    originalError: err,
-    type: "unknown-error"
-  });
-  if (!response.hasErrors) response.headers.set("x-rpc-error", rpcError.type);
-  response.statusCode = rpcError.statusCode ?? core.StatusCodes.UNEXPECTED_ERROR;
-  response.hasErrors = true;
-  const thrownErrors = context.request.thrownErrors || {};
-  thrownErrors[path] = rpcError;
-  context.request.thrownErrors = thrownErrors;
+/** An app-thrown RpcError may carry any string as its `type`, and a CR or LF there is header injection on
+*  adapters that write headers unchecked (or an ERR_INVALID_CHAR throw on node). Anything outside the token
+*  alphabet reports as `unknown-error` on the header; the body still carries the full type. */
+var HEADER_SAFE_TYPE = /^[A-Za-z0-9_.:@-]{1,128}$/;
+function errorHeaderValue(type) {
+	return HEADER_SAFE_TYPE.test(type) ? type : "unknown-error";
 }
+/** Marks the response as ended by `rpcError`: the error header (first error only), the status code,
+*  `hasErrors` (what the dispatcher's skip rule reads) and `fatalError` (first one wins). Shared by the
+*  thrown path and a returned FatalError; where the error itself lands is the caller's decision.
+*  `fallbackStatus` answers when the error carries no statusCode: a thrown one is unexpected (422), a
+*  returned FatalError a declared application error (400). */
+function markResponseFailed(context, rpcError, fallbackStatus) {
+	const response = context.response;
+	if (!response.hasErrors) {
+		response.headers.set("x-rpc-error", errorHeaderValue(rpcError.type));
+		response.fatalError = rpcError;
+	}
+	response.statusCode = rpcError.statusCode ?? fallbackStatus;
+	response.hasErrors = true;
+}
+/** Whatever an adapter caught, as the mion error the wire carries. */
+function toRpcError(err) {
+	return err instanceof _mionjs_core.RpcError ? err : new _mionjs_core.FatalError({
+		publicMessage: "Unknown Error",
+		type: "unknown-error",
+		originalError: err
+	});
+}
+/** Records an undeclared error under `key` and ends the request: it lands in `@thrownErrors` untyped, sets
+*  the status and the error header, and stops every later member that does not declare `alwaysRun`.
+*  Undeclared means thrown, or returned by a raw middleware, which cannot declare a return type; a declared
+*  error is returned from a handler and goes straight into `response.body`. The key is normally the member
+*  that failed; an adapter passes its own (`mion@platformError`) for a request no member could run. */
+function recordUndeclaredError(context, key, err) {
+	const rpcError = (0, _mionjs_core.markFatal)(err instanceof _mionjs_core.RpcError ? err : new _mionjs_core.FatalError({
+		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+		publicMessage: `Unknown error in handler "${key}" of route ExecutionChain.`,
+		originalError: err,
+		type: "unknown-error"
+	}));
+	markResponseFailed(context, rpcError, _mionjs_core.StatusCodes.UNEXPECTED_ERROR);
+	addThrownError(context, key, rpcError);
+}
+/** Unlike recordUndeclaredError, does not end the request. */
+function addThrownError(context, key, rpcError) {
+	const thrownErrors = context.request.thrownErrors || {};
+	thrownErrors[key] = rpcError;
+	context.request.thrownErrors = thrownErrors;
+}
+function hasThrownError(context, key) {
+	const thrownErrors = context.request.thrownErrors;
+	return !!thrownErrors && Object.hasOwn(thrownErrors, key);
+}
+//#endregion
+exports.addThrownError = addThrownError;
+exports.errorHeaderValue = errorHeaderValue;
 exports.getRouterFatalErrorResponse = getRouterFatalErrorResponse;
-exports.onExecutableError = onExecutableError;
-//# sourceMappingURL=dispatchError.cjs.map
+exports.hasThrownError = hasThrownError;
+exports.markResponseFailed = markResponseFailed;
+exports.recordUndeclaredError = recordUndeclaredError;
+exports.toRpcError = toRpcError;
+
+//# sourceMappingURL=dispatchError.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"dispatchError.cjs","sources":["../../../../src/lib/dispatchError.ts"],"sourcesContent":["import {RpcError, MION_ROUTES, Mutable, StatusCodes, SerializerModes} from '@mionjs/core';\nimport type {CallContext, MionHeaders, MionRequest, MionResponse, ResponseBody} from '../types/context.ts';\nimport type {RemoteMethod} from '../types/remoteMethods.ts';\n\n/**\n * Return a Response mion response for any error that happens before or outside the router.\n * to be used by any adapter layer. ie: node/http, aws/lambda, bun, etc.\n * Uses thrownErrors with a special platformError key to maintain consistency with route errors.\n * @param returnErr\n * @param respHeaders\n * @returns\n */\n\nexport function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse {\n    // Store platform error in thrownErrors with special platformError key\n    const body: ResponseBody = {\n        '@thrownErrors': {[MION_ROUTES.platformError]: returnErr},\n    };\n    respHeaders.set('content-type', 'application/json; charset=utf-8');\n    const response: Mutable<MionResponse> = {\n        statusCode: returnErr.statusCode || StatusCodes.SERVER_ERROR, // Global errors are always unexpected\n        hasErrors: true,\n        headers: respHeaders,\n        body,\n        rawBody: JSON.stringify(body),\n        serializer: SerializerModes.json, // global errors are always json\n    };\n    return response;\n}\n\n/**\n * Handles errors during route dispatch.\n * All errors passed to this function are unexpected (thrown errors).\n * Expected errors are returned from handlers and added directly to response.body.\n * @param context\n * @param executable\n * @param err\n * @returns\n */\nexport function onExecutableError(context: CallContext, executable: RemoteMethod, err: any | RpcError<string> | Error) {\n    const response = context.response as Mutable<MionResponse>;\n    const path = executable.id;\n    const rpcError: RpcError<string> =\n        err instanceof RpcError\n            ? err\n            : new RpcError({\n                  statusCode: StatusCodes.UNEXPECTED_ERROR,\n                  publicMessage: `Unknown error in handler \"${path}\" of route ExecutionChain.`,\n                  originalError: err,\n                  type: 'unknown-error',\n              });\n    // only first error sets the error header\n    if (!response.hasErrors) response.headers.set('x-rpc-error', rpcError.type);\n    response.statusCode = rpcError.statusCode ?? StatusCodes.UNEXPECTED_ERROR;\n    response.hasErrors = true;\n    // Store unexpected errors for serialization\n    const thrownErrors = context.request.thrownErrors || ({} as Record<string, RpcError<string>>);\n    thrownErrors[path] = rpcError;\n    (context.request as Mutable<MionRequest>).thrownErrors = thrownErrors;\n}\n"],"names":["MION_ROUTES","StatusCodes","SerializerModes","RpcError"],"mappings":";;;AAaO,SAAS,4BAA4B,WAA6B,aAAwC;AAE7G,QAAM,OAAqB;AAAA,IACvB,iBAAiB,EAAC,CAACA,iBAAY,aAAa,GAAG,UAAA;AAAA,EAAS;AAE5D,cAAY,IAAI,gBAAgB,iCAAiC;AACjE,QAAM,WAAkC;AAAA,IACpC,YAAY,UAAU,cAAcC,KAAAA,YAAY;AAAA;AAAA,IAChD,WAAW;AAAA,IACX,SAAS;AAAA,IACT;AAAA,IACA,SAAS,KAAK,UAAU,IAAI;AAAA,IAC5B,YAAYC,KAAAA,gBAAgB;AAAA;AAAA,EAAA;AAEhC,SAAO;AACX;AAWO,SAAS,kBAAkB,SAAsB,YAA0B,KAAqC;AACnH,QAAM,WAAW,QAAQ;AACzB,QAAM,OAAO,WAAW;AACxB,QAAM,WACF,eAAeC,KAAAA,WACT,MACA,IAAIA,KAAAA,SAAS;AAAA,IACT,YAAYF,KAAAA,YAAY;AAAA,IACxB,eAAe,6BAA6B,IAAI;AAAA,IAChD,eAAe;AAAA,IACf,MAAM;AAAA,EAAA,CACT;AAEX,MAAI,CAAC,SAAS,UAAW,UAAS,QAAQ,IAAI,eAAe,SAAS,IAAI;AAC1E,WAAS,aAAa,SAAS,cAAcA,KAAAA,YAAY;AACzD,WAAS,YAAY;AAErB,QAAM,eAAe,QAAQ,QAAQ,gBAAiB,CAAA;AACtD,eAAa,IAAI,IAAI;AACpB,UAAQ,QAAiC,eAAe;AAC7D;;;"}
+{"version":3,"file":"dispatchError.cjs","names":[],"sources":["../../../../src/lib/dispatchError.ts"],"sourcesContent":["import {RpcError, FatalError, MION_ROUTES, Mutable, StatusCodes, markFatal} from '@mionjs/core';\nimport {JSON_CONTENT_TYPE} from '../constants.ts';\nimport type {CallContext, MionHeaders, MionRequest, MionResponse, ResponseBody} from '../types/context.ts';\n\n/** The response for an error raised outside the router by any adapter; it goes in `@thrownErrors` like a route error. */\n\nexport function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse {\n  // a platform error ends the request before any handler runs, so it is fatal by definition\n  markFatal(returnErr);\n  const body: ResponseBody = {\n    '@thrownErrors': {[MION_ROUTES.platformError]: returnErr},\n  };\n  respHeaders.set('x-rpc-error', errorHeaderValue(returnErr.type));\n  const response: Mutable<MionResponse> = {\n    statusCode: returnErr.statusCode || StatusCodes.SERVER_ERROR, // Global errors are always unexpected\n    contentType: JSON_CONTENT_TYPE,\n    hasErrors: true,\n    fatalError: returnErr,\n    headers: respHeaders,\n    body,\n  };\n  return response;\n}\n\n/** An app-thrown RpcError may carry any string as its `type`, and a CR or LF there is header injection on\n *  adapters that write headers unchecked (or an ERR_INVALID_CHAR throw on node). Anything outside the token\n *  alphabet reports as `unknown-error` on the header; the body still carries the full type. */\nconst HEADER_SAFE_TYPE = /^[A-Za-z0-9_.:@-]{1,128}$/;\nexport function errorHeaderValue(type: string): string {\n  return HEADER_SAFE_TYPE.test(type) ? type : 'unknown-error';\n}\n\n/** Marks the response as ended by `rpcError`: the error header (first error only), the status code,\n *  `hasErrors` (what the dispatcher's skip rule reads) and `fatalError` (first one wins). Shared by the\n *  thrown path and a returned FatalError; where the error itself lands is the caller's decision.\n *  `fallbackStatus` answers when the error carries no statusCode: a thrown one is unexpected (422), a\n *  returned FatalError a declared application error (400). */\nexport function markResponseFailed(context: CallContext, rpcError: RpcError<string>, fallbackStatus: number) {\n  const response = context.response as Mutable<MionResponse>;\n  if (!response.hasErrors) {\n    response.headers.set('x-rpc-error', errorHeaderValue(rpcError.type));\n    response.fatalError = rpcError;\n  }\n  response.statusCode = rpcError.statusCode ?? fallbackStatus;\n  response.hasErrors = true;\n}\n\n/** Whatever an adapter caught, as the mion error the wire carries. */\nexport function toRpcError(err: unknown): RpcError<string> {\n  return err instanceof RpcError\n    ? err\n    : new FatalError({publicMessage: 'Unknown Error', type: 'unknown-error', originalError: err as Error});\n}\n\n/** Records an undeclared error under `key` and ends the request: it lands in `@thrownErrors` untyped, sets\n *  the status and the error header, and stops every later member that does not declare `alwaysRun`.\n *  Undeclared means thrown, or returned by a raw middleware, which cannot declare a return type; a declared\n *  error is returned from a handler and goes straight into `response.body`. The key is normally the member\n *  that failed; an adapter passes its own (`mion@platformError`) for a request no member could run. */\nexport function recordUndeclaredError(context: CallContext, key: string, err: any) {\n  const rpcError: RpcError<string> = markFatal(\n    err instanceof RpcError\n      ? err\n      : new FatalError({\n          statusCode: StatusCodes.UNEXPECTED_ERROR,\n          publicMessage: `Unknown error in handler \"${key}\" of route ExecutionChain.`,\n          originalError: err,\n          type: 'unknown-error',\n        })\n  );\n  markResponseFailed(context, rpcError, StatusCodes.UNEXPECTED_ERROR);\n  addThrownError(context, key, rpcError);\n}\n\n/** Unlike recordUndeclaredError, does not end the request. */\nexport function addThrownError(context: CallContext, key: string, rpcError: RpcError<string>) {\n  // tsgo types `readonly || mutable` as readonly, so casting only the `{}` fallback still forbids the write.\n  const thrownErrors = (context.request.thrownErrors || {}) as Record<string, RpcError<string>>;\n  thrownErrors[key] = rpcError;\n  (context.request as Mutable<MionRequest>).thrownErrors = thrownErrors;\n}\n\nexport function hasThrownError(context: CallContext, key: string): boolean {\n  const thrownErrors = context.request.thrownErrors;\n  return !!thrownErrors && Object.hasOwn(thrownErrors, key);\n}\n"],"mappings":";;;;;AAMA,SAAgB,4BAA4B,WAA6B,aAAwC;CAE/G,CAAA,GAAA,aAAA,WAAU,SAAS;CACnB,MAAM,OAAqB,EACzB,iBAAiB,GAAE,aAAA,YAAY,gBAAgB,UAAS,EAC1D;CACA,YAAY,IAAI,eAAe,iBAAiB,UAAU,IAAI,CAAC;CAS/D,OAAO;EAPL,YAAY,UAAU,cAAc,aAAA,YAAY;EAChD,aAAa,sBAAA;EACb,WAAW;EACX,YAAY;EACZ,SAAS;EACT;CAEK;AACT;;;;AAKA,IAAM,mBAAmB;AACzB,SAAgB,iBAAiB,MAAsB;CACrD,OAAO,iBAAiB,KAAK,IAAI,IAAI,OAAO;AAC9C;;;;;;AAOA,SAAgB,mBAAmB,SAAsB,UAA4B,gBAAwB;CAC3G,MAAM,WAAW,QAAQ;CACzB,IAAI,CAAC,SAAS,WAAW;EACvB,SAAS,QAAQ,IAAI,eAAe,iBAAiB,SAAS,IAAI,CAAC;EACnE,SAAS,aAAa;CACxB;CACA,SAAS,aAAa,SAAS,cAAc;CAC7C,SAAS,YAAY;AACvB;;AAGA,SAAgB,WAAW,KAAgC;CACzD,OAAO,eAAe,aAAA,WAClB,MACA,IAAI,aAAA,WAAW;EAAC,eAAe;EAAiB,MAAM;EAAiB,eAAe;CAAY,CAAC;AACzG;;;;;;AAOA,SAAgB,sBAAsB,SAAsB,KAAa,KAAU;CACjF,MAAM,YAAA,GAAA,aAAA,WACJ,eAAe,aAAA,WACX,MACA,IAAI,aAAA,WAAW;EACb,YAAY,aAAA,YAAY;EACxB,eAAe,6BAA6B,IAAI;EAChD,eAAe;EACf,MAAM;CACR,CAAC,CACP;CACA,mBAAmB,SAAS,UAAU,aAAA,YAAY,gBAAgB;CAClE,eAAe,SAAS,KAAK,QAAQ;AACvC;;AAGA,SAAgB,eAAe,SAAsB,KAAa,UAA4B;CAE5F,MAAM,eAAgB,QAAQ,QAAQ,gBAAgB,CAAC;CACvD,aAAa,OAAO;CACpB,QAAS,QAAiC,eAAe;AAC3D;AAEA,SAAgB,eAAe,SAAsB,KAAsB;CACzE,MAAM,eAAe,QAAQ,QAAQ;CACrC,OAAO,CAAC,CAAC,gBAAgB,OAAO,OAAO,cAAc,GAAG;AAC1D"}

package/.dist/cjs/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

package/.dist/cjs/src/lib/handlers.cjs

@@ -1,52 +1,99 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const core = require("@mionjs/core");
-function route(handler, opts) {
-  return {
-    type: core.HandlerType.route,
-    handler,
-    options: opts
-  };
+let _mionjs_core = require("@mionjs/core");
+//#region src/lib/handlers.ts
+var route = (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({
+	type: _mionjs_core.HandlerType.route,
+	handler,
+	options: opts,
+	rtFns: {
+		paramsFns,
+		returnFns,
+		paramsId,
+		returnId,
+		isAsyncId,
+		syncId
+	}
+});
+/** Typed as the same helper as `route()`, so both keep the marker signature the scanner reads at the call site. */
+function routeWithMutation(isMutation) {
+	return (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({
+		type: _mionjs_core.HandlerType.route,
+		handler,
+		options: {
+			...opts,
+			isMutation
+		},
+		rtFns: {
+			paramsFns,
+			returnFns,
+			paramsId,
+			returnId,
+			isAsyncId,
+			syncId
+		}
+	});
 }
-function query(handler, opts) {
-  return {
-    type: core.HandlerType.route,
-    handler,
-    options: { ...opts, isMutation: false }
-  };
+/** Route handler for read-only queries. Uses GET with ?data=base64url on the client when payload fits. */
+var query = routeWithMutation(false);
+var mutation = routeWithMutation(true);
+var middleware = (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({
+	type: _mionjs_core.HandlerType.middleware,
+	handler,
+	options: opts,
+	rtFns: {
+		paramsFns,
+		returnFns,
+		paramsId,
+		returnId,
+		isAsyncId,
+		syncId
+	}
+});
+var headersMiddleware = (handler, opts, headersFns, paramsFns, returnFns, headersId, paramsId, returnId, isAsyncId, syncId) => ({
+	type: _mionjs_core.HandlerType.headersMiddleware,
+	handler,
+	options: opts,
+	rtFns: {
+		paramsFns,
+		returnFns,
+		paramsId,
+		returnId,
+		isAsyncId,
+		syncId,
+		headersFns,
+		headersId
+	}
+});
+var rawMiddleware = (handler, opts) => ({
+	type: _mionjs_core.HandlerType.rawMiddleware,
+	handler,
+	options: opts
+});
+/** Each on-demand middleware, with what it does on every call even without its slot. */
+var onDemandMiddlewares = /* @__PURE__ */ new WeakMap();
+/** Internal: the middleware runs only when the request body carries its slot, so an absent slot costs nothing */
+function markOnDemand(def, onEveryCall) {
+	onDemandMiddlewares.set(def, onEveryCall);
+	return def;
 }
-function mutation(handler, opts) {
-  return {
-    type: core.HandlerType.route,
-    handler,
-    options: { ...opts, isMutation: true }
-  };
+function isOnDemandMiddleware(def) {
+	return onDemandMiddlewares.has(def);
 }
-function middleFn(handler, opts) {
-  return {
-    type: core.HandlerType.middleFn,
-    handler,
-    options: opts
-  };
+function getOnEveryCall(def) {
+	return onDemandMiddlewares.get(def);
 }
-function headersFn(handler, opts) {
-  return {
-    type: core.HandlerType.headersMiddleFn,
-    handler,
-    options: opts
-  };
-}
-function rawMiddleFn(handler, opts) {
-  return {
-    type: core.HandlerType.rawMiddleFn,
-    handler,
-    options: opts
-  };
-}
-exports.headersFn = headersFn;
-exports.middleFn = middleFn;
+/** mion's own ids, never exposed to clients */
+var mionInternalRouteIds = new Set(Object.values(_mionjs_core.MION_ROUTES));
+//#endregion
+exports.getOnEveryCall = getOnEveryCall;
+exports.headersMiddleware = headersMiddleware;
+exports.isOnDemandMiddleware = isOnDemandMiddleware;
+exports.markOnDemand = markOnDemand;
+exports.middleware = middleware;
+exports.mionInternalRouteIds = mionInternalRouteIds;
 exports.mutation = mutation;
 exports.query = query;
-exports.rawMiddleFn = rawMiddleFn;
+exports.rawMiddleware = rawMiddleware;
 exports.route = route;
-//# sourceMappingURL=handlers.cjs.map
+
+//# sourceMappingURL=handlers.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"handlers.cjs","sources":["../../../../src/lib/handlers.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {HeadersMiddleFnOptions, MiddleFnOptions, RawMiddleFnOptions, RouteOptions} from '../types/remoteMethods.ts';\nimport {HandlerType} from '@mionjs/core';\nimport {Handler, HeaderHandler, RawMiddleFnHandler} from '../types/handlers.ts';\nimport {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from '../types/definitions.ts';\n\n// ############# Route & MiddleFns initialization #############\n// these functions are just helpers to initialize the route & middleFns objects and keep route definitions clean\n\nexport function route<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H> {\n    return {\n        type: HandlerType.route,\n        handler,\n        options: opts,\n    };\n}\n\n/** Route handler for read-only queries. Uses GET with ?data=base64url on the client when payload fits. */\nexport function query<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H> {\n    return {\n        type: HandlerType.route,\n        handler,\n        options: {...opts, isMutation: false},\n    };\n}\n\n/** Route handler for mutations. Explicit alias for route() with isMutation: true. */\nexport function mutation<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H> {\n    return {\n        type: HandlerType.route,\n        handler,\n        options: {...opts, isMutation: true},\n    };\n}\n\nexport function middleFn<H extends Handler>(handler: H, opts?: MiddleFnOptions): MiddleFnDef<H> {\n    return {\n        type: HandlerType.middleFn,\n        handler,\n        options: opts,\n    };\n}\n\n/**\n * MiddleFn for handling HTTP header parameters\n * Used to define middleFns that receive values from HTTP headers\n *\n * @example\n * ```ts\n * headersFn(['authorization'], (ctx, token: string): void => {\n *   // token contains the value of the 'authorization' header\n * })\n * ```\n */\nexport function headersFn<H extends HeaderHandler>(handler: H, opts?: HeadersMiddleFnOptions): HeadersMiddleFnDef<H> {\n    return {\n        type: HandlerType.headersMiddleFn,\n        handler,\n        options: opts,\n    };\n}\n\nexport function rawMiddleFn<H extends RawMiddleFnHandler>(handler: H, opts?: RawMiddleFnOptions): RawMiddleFnDef<H> {\n    return {\n        type: HandlerType.rawMiddleFn,\n        handler,\n        options: opts,\n    };\n}\n"],"names":["HandlerType"],"mappings":";;;AAeO,SAAS,MAAyB,SAAY,MAAkC;AACnF,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;AAGO,SAAS,MAAyB,SAAY,MAAkC;AACnF,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS,EAAC,GAAG,MAAM,YAAY,MAAA;AAAA,EAAK;AAE5C;AAGO,SAAS,SAA4B,SAAY,MAAkC;AACtF,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS,EAAC,GAAG,MAAM,YAAY,KAAA;AAAA,EAAI;AAE3C;AAEO,SAAS,SAA4B,SAAY,MAAwC;AAC5F,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;AAaO,SAAS,UAAmC,SAAY,MAAsD;AACjH,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;AAEO,SAAS,YAA0C,SAAY,MAA8C;AAChH,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;;;;;;;"}
+{"version":3,"file":"handlers.cjs","names":[],"sources":["../../../../src/lib/handlers.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {HandlerType, MION_ROUTES} from '@mionjs/core';\nimport type {\n  HeadersMiddlewareHelper,\n  MiddlewareHelper,\n  PinnedMutation,\n  RawMiddlewareHelper,\n  RouteHelper,\n  RouterOptionsInput,\n} from '../types/mionRouter.ts';\nimport type {CallContext} from '../types/context.ts';\n\n// ############# Route & Middlewares initialization (INTERNAL) #############\n// These bodies initialize the definition objects AND are the mion injection points: the trailing marker\n// params are filled at BUILD TIME by @mionjs/devtools. Not exported from the package, consumers reach\n// them as the closures `createMionRouter()` returns; only mion's own middlewares and its error / serializer routes\n// call them directly, each pinning its own `encoder`.\n// ⚠️ There is NO signature here on purpose: each body is TYPED BY its helper interface in\n// types/mionRouter.ts, the one place a helper signature is written, so there is no second surface to keep\n// in step. `RouterOptionsInput` is the widest options shape; `createMionRouter` narrows each helper to\n// its own `O` so a declaration reads the factory's options.\n\nexport const route: RouteHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  paramsFns,\n  returnFns,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.route,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n});\n\n/** Typed as the same helper as `route()`, so both keep the marker signature the scanner reads at the call site. */\nfunction routeWithMutation<M extends boolean>(isMutation: M): RouteHelper<RouterOptionsInput, M> {\n  return (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({\n    type: HandlerType.route,\n    handler,\n    options: {...opts, isMutation} as PinnedMutation<typeof opts & object, M>,\n    rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n  });\n}\n\n/** Route handler for read-only queries. Uses GET with ?data=base64url on the client when payload fits. */\nexport const query = routeWithMutation(false);\n\nexport const mutation = routeWithMutation(true);\n\nexport const middleware: MiddlewareHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  paramsFns,\n  returnFns,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.middleware,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n});\n\nexport const headersMiddleware: HeadersMiddlewareHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  headersFns,\n  paramsFns,\n  returnFns,\n  headersId,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.headersMiddleware,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId, headersFns, headersId},\n});\n\nexport const rawMiddleware: RawMiddlewareHelper<RouterOptionsInput> = (handler, opts) => ({\n  type: HandlerType.rawMiddleware,\n  handler,\n  options: opts,\n});\n\n/** Each on-demand middleware, with what it does on every call even without its slot. */\nconst onDemandMiddlewares = new WeakMap<object, OnEveryCall | undefined>();\ntype OnEveryCall = (ctx: CallContext) => void;\n\n/** Internal: the middleware runs only when the request body carries its slot, so an absent slot costs nothing */\nexport function markOnDemand<Def extends object>(def: Def, onEveryCall?: OnEveryCall): Def {\n  onDemandMiddlewares.set(def, onEveryCall);\n  return def;\n}\n\nexport function isOnDemandMiddleware(def: object): boolean {\n  return onDemandMiddlewares.has(def);\n}\n\nexport function getOnEveryCall(def: object): OnEveryCall | undefined {\n  return onDemandMiddlewares.get(def);\n}\n\n/** mion's own ids, never exposed to clients */\nexport const mionInternalRouteIds: ReadonlySet<string> = new Set(Object.values(MION_ROUTES));\n"],"mappings":";;;AA4BA,IAAa,SACX,SACA,MACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,aAAA,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;CAAM;AACrE;;AAGA,SAAS,kBAAqC,YAAmD;CAC/F,QAAQ,SAAS,MAAM,WAAW,WAAW,UAAU,UAAU,WAAW,YAAY;EACtF,MAAM,aAAA,YAAY;EAClB;EACA,SAAS;GAAC,GAAG;GAAM;EAAU;EAC7B,OAAO;GAAC;GAAW;GAAW;GAAU;GAAU;GAAW;EAAM;CACrE;AACF;;AAGA,IAAa,QAAQ,kBAAkB,KAAK;AAE5C,IAAa,WAAW,kBAAkB,IAAI;AAE9C,IAAa,cACX,SACA,MACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,aAAA,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;CAAM;AACrE;AAEA,IAAa,qBACX,SACA,MACA,YACA,WACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,aAAA,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;EAAQ;EAAY;CAAS;AAC5F;AAEA,IAAa,iBAA0D,SAAS,UAAU;CACxF,MAAM,aAAA,YAAY;CAClB;CACA,SAAS;AACX;;AAGA,IAAM,sCAAsB,IAAI,QAAyC;;AAIzE,SAAgB,aAAiC,KAAU,aAAgC;CACzF,oBAAoB,IAAI,KAAK,WAAW;CACxC,OAAO;AACT;AAEA,SAAgB,qBAAqB,KAAsB;CACzD,OAAO,oBAAoB,IAAI,GAAG;AACpC;AAEA,SAAgB,eAAe,KAAsC;CACnE,OAAO,oBAAoB,IAAI,GAAG;AACpC;;AAGA,IAAa,uBAA4C,IAAI,IAAI,OAAO,OAAO,aAAA,WAAW,CAAC"}

package/.dist/cjs/src/lib/handlers.d.ts

@@ -1,10 +1,15 @@
-import { HeadersMiddleFnOptions, MiddleFnOptions, RawMiddleFnOptions, RouteOptions } from '../types/remoteMethods.ts';
-import { Handler, HeaderHandler, RawMiddleFnHandler } from '../types/handlers.ts';
-import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from '../types/definitions.ts';
-export declare function route<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H>;
-export declare function query<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H>;
-export declare function mutation<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H>;
-export declare function middleFn<H extends Handler>(handler: H, opts?: MiddleFnOptions): MiddleFnDef<H>;
-export declare function headersFn<H extends HeaderHandler>(handler: H, opts?: HeadersMiddleFnOptions): HeadersMiddleFnDef<H>;
-export declare function rawMiddleFn<H extends RawMiddleFnHandler>(handler: H, opts?: RawMiddleFnOptions): RawMiddleFnDef<H>;
+import { HeadersMiddlewareHelper, MiddlewareHelper, RawMiddlewareHelper, RouteHelper, RouterOptionsInput } from '../types/mionRouter.ts';
+import { CallContext } from '../types/context.ts';
+export declare const route: RouteHelper<RouterOptionsInput>;
+export declare const query: RouteHelper<Partial<import('../types/general.ts').RouterOptions<any, any>>, false>;
+export declare const mutation: RouteHelper<Partial<import('../types/general.ts').RouterOptions<any, any>>, true>;
+export declare const middleware: MiddlewareHelper<RouterOptionsInput>;
+export declare const headersMiddleware: HeadersMiddlewareHelper<RouterOptionsInput>;
+export declare const rawMiddleware: RawMiddlewareHelper<RouterOptionsInput>;
+type OnEveryCall = (ctx: CallContext) => void;
+export declare function markOnDemand<Def extends object>(def: Def, onEveryCall?: OnEveryCall): Def;
+export declare function isOnDemandMiddleware(def: object): boolean;
+export declare function getOnEveryCall(def: object): OnEveryCall | undefined;
+export declare const mionInternalRouteIds: ReadonlySet<string>;
+export {};
 //# sourceMappingURL=handlers.d.ts.map