@mionjs/router 0.8.8 → 0.13.0

package/.dist/cjs/src/batches.cjs

@@ -0,0 +1,332 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src_lib_dispatchError = require("./lib/dispatchError.cjs");
+const require_src_lib_urlQuery = require("./lib/urlQuery.cjs");
+const require_src_dispatch = require("./dispatch.cjs");
+const require_src_router = require("./router.cjs");
+let _mionjs_core = require("@mionjs/core");
+//#region src/batches.ts
+var batchesById = (0, _mionjs_core.getOrCreateGlobal)("mion.router.batchesById", () => /* @__PURE__ */ new Map());
+var mappingMethodCache = (0, _mionjs_core.getOrCreateGlobal)("mion.router.batchMappingMethodCache", () => /* @__PURE__ */ new Map());
+/** A malformed definition is a configuration error and throws at registration, never at request time.
+*  Re-registering an id replaces it; ids not in `table` are left alone (replaceBatches is the whole-table form). */
+function registerBatches(table) {
+	for (const [id, definition] of Object.entries(table)) {
+		assertValidBatchDefinition(id, definition);
+		batchesById.set(id, {
+			id,
+			routes: [...definition.routes],
+			mappings: definition.mappings ? definition.mappings.map((mapping) => ({ ...mapping })) : [],
+			chains: /* @__PURE__ */ new Map()
+		});
+	}
+}
+/** Replaces the WHOLE table. What the generated `.mion/rpc/batches.generated.js` calls, so every
+*  evaluation of it leaves exactly that file's batches registered and nothing from before. */
+function replaceBatches(table) {
+	clearBatches();
+	registerBatches(table);
+}
+/** The table is build-generated, so this only guards against a stale or hand-edited manifest. */
+function assertValidBatchDefinition(id, definition) {
+	const invalid = (reason) => {
+		throw new Error(`[mion batches] batch '${id}' is malformed: ${reason}.`);
+	};
+	if (!id) invalid("empty id");
+	if (!definition || typeof definition !== "object") invalid("expected an object");
+	if (!Array.isArray(definition.routes) || definition.routes.length === 0) invalid("`routes` must be a non-empty array");
+	if (definition.routes.some((route) => typeof route !== "string" || !route)) invalid("`routes` must be route ids");
+	if (definition.mappings === void 0) return;
+	if (!Array.isArray(definition.mappings)) invalid("`mappings` must be an array");
+	for (const mapping of definition.mappings) {
+		if (!mapping || typeof mapping !== "object") invalid("every mapping must be an object");
+		const { fromId, toId, mapperKey, paramIndex } = mapping;
+		if (typeof fromId !== "string" || typeof toId !== "string" || typeof mapperKey !== "string") invalid("mapping `fromId`, `toId` and `mapperKey` must be strings");
+		if (!definition.routes.includes(fromId)) invalid(`mapping source '${fromId}' is not a route of the batch`);
+		if (!definition.routes.includes(toId)) invalid(`mapping target '${toId}' is not a route of the batch`);
+		if (typeof paramIndex !== "number" || !Number.isInteger(paramIndex) || paramIndex < 0) invalid("mapping `paramIndex` must be a non-negative integer");
+	}
+}
+function getBatch(id) {
+	return batchesById.get(id);
+}
+/** Ids of every registered batch, for the metadata route. */
+function getBatchIds() {
+	return [...batchesById.keys()];
+}
+/** Called by resetRouter and replaceBatches. */
+function clearBatches() {
+	batchesById.clear();
+	mappingMethodCache.clear();
+}
+/** The member routes' resolved limits (each already carries its factor and envelope, or the platform's
+*  number when its types cannot say) plus the outer braces, fixed the first time a chain is built. */
+function resolveBatchMaxBodySize(entry, memberChains) {
+	if (entry.maxBodySize === void 0) entry.maxBodySize = sumChainMaxBodySize(memberChains);
+	return entry.maxBodySize;
+}
+function sumChainMaxBodySize(chains) {
+	let total = 2;
+	for (const chain of chains) total += chain.maxBodySize;
+	return Math.min(total, require_src_router.getPlatformRequestCap() ?? Infinity);
+}
+/** The limits not yet settled read the platform ceiling when they are. */
+function capBatchBodySizes(maxRequestSize) {
+	for (const entry of batchesById.values()) if (entry.maxBodySize !== void 0 && entry.maxBodySize > maxRequestSize) entry.maxBodySize = maxRequestSize;
+}
+/** Re-folds every ALREADY built chain from its entry's current number: without it a chain built before
+*  a later setPlatformConfig keeps serving a limit the platform has since promised to refuse. */
+function refreshBatchChainBodyLimits(platformMaxBodySize) {
+	for (const entry of batchesById.values()) {
+		const limit = entry.maxBodySize ?? platformMaxBodySize;
+		for (const chain of entry.chains.values()) {
+			chain.declaredBodySize = entry.maxBodySize;
+			chain.maxBodySize = limit;
+		}
+	}
+}
+/** The largest limit any registered batch resolves to, over the member routes' untransformed
+*  paths: what bun sizes its native server limit with (see getMaxRouteBodySize). */
+function getMaxBatchBodySize() {
+	const opts = require_src_router.getRouterOptions();
+	let largest = 0;
+	for (const entry of batchesById.values()) {
+		if (entry.maxBodySize !== void 0) {
+			largest = Math.max(largest, entry.maxBodySize);
+			continue;
+		}
+		const chains = [];
+		for (const routeId of entry.routes) {
+			const chain = require_src_router.getRouteExecutionChain((0, _mionjs_core.getRoutePath)(routeId.split(_mionjs_core.ROUTER_ITEM_SEPARATOR_CHAR), opts));
+			if (chain) chains.push(chain);
+		}
+		largest = Math.max(largest, sumChainMaxBodySize(chains));
+	}
+	return largest;
+}
+/** `id=<batchId>` is the only parameter the batch endpoint reads; missing or undecodable is an unknown id.
+*  The id is the one query value that IS percent-decoded, so it survives a `/` or a space in a route name. */
+function readBatchId(urlQuery) {
+	const rawId = require_src_lib_urlQuery.findMionQueryParam(urlQuery, "id");
+	if (rawId === void 0) return void 0;
+	try {
+		return decodeURIComponent(rawId) || void 0;
+	} catch {
+		return;
+	}
+}
+/** Runs while the call context is acquired, BEFORE the body is read, so an unknown id costs nothing but
+*  a Map lookup: it answers undefined and the caller resolves the batch not-found chain.
+*  The id is the only untrusted input and it is never echoed back. */
+function getBatchExecutionChain(rawRequest, opts, urlQuery) {
+	const batchId = readBatchId(urlQuery);
+	const entry = batchId ? getBatch(batchId) : void 0;
+	if (!entry) return void 0;
+	const routePaths = entry.routes.map((routeId) => (0, _mionjs_core.getRoutePath)(routeId.split(_mionjs_core.ROUTER_ITEM_SEPARATOR_CHAR), opts));
+	const transformedPaths = opts.pathTransform ? routePaths.map((routePath) => opts.pathTransform(rawRequest, routePath) || routePath) : routePaths;
+	const chainKey = opts.pathTransform ? transformedPaths.join(",") : "";
+	let executionChain = entry.chains.get(chainKey);
+	if (!executionChain) {
+		executionChain = buildMergedExecutionChain(entry, transformedPaths);
+		entry.chains.set(chainKey, executionChain);
+	}
+	return executionChain;
+}
+/** Takes already-transformed paths; each mapping step goes between its source and target route. */
+function buildMergedExecutionChain(entry, transformedPaths) {
+	const seenIds = /* @__PURE__ */ new Set();
+	const middleMethods = [];
+	const memberChains = [];
+	let firstRouteIndex = -1;
+	const startMiddlewareIds = new Set(require_src_router.startMiddlewares.map((method) => method.id));
+	const endMiddlewareIds = new Set(require_src_router.endMiddlewares.map((method) => method.id));
+	transformedPaths.forEach((transformedPath, index) => {
+		const chain = require_src_router.getRouteExecutionChain(transformedPath);
+		if (!chain) throw new _mionjs_core.FatalError({
+			statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+			type: "batch-route-not-found",
+			publicMessage: `Route '${entry.routes[index]}' of batch '${entry.id}' is not registered on this server.`,
+			errorData: {
+				batchId: entry.id,
+				routeId: entry.routes[index]
+			}
+		});
+		memberChains.push(chain);
+		if (firstRouteIndex < 0) firstRouteIndex = chain.routeIndex;
+		for (const method of chain.methods) {
+			if (seenIds.has(method.id)) continue;
+			if (startMiddlewareIds.has(method.id)) continue;
+			if (endMiddlewareIds.has(method.id)) continue;
+			seenIds.add(method.id);
+			middleMethods.push(method);
+		}
+	});
+	if (entry.mappings.length > 0) insertMappingMethods(entry, middleMethods);
+	const methods = [
+		...require_src_router.startMiddlewares,
+		...middleMethods,
+		...require_src_router.endMiddlewares
+	];
+	const declaredBodySize = resolveBatchMaxBodySize(entry, memberChains);
+	return {
+		routeIndex: firstRouteIndex,
+		methods,
+		path: void 0,
+		batchId: entry.id,
+		batchRouteIds: entry.routes,
+		declaredBodySize,
+		maxBodySize: declaredBodySize,
+		readsBody: true
+	};
+}
+/**
+* Inserts mapping methods into the middleMethods array in the correct position.
+* Each mapping method is inserted after the source route (fromId) and before the target route (toId).
+*/
+function insertMappingMethods(entry, middleMethods) {
+	const idToIndex = /* @__PURE__ */ new Map();
+	for (let i = 0; i < middleMethods.length; i++) idToIndex.set(middleMethods[i].id, i);
+	const insertions = [];
+	for (const mapping of entry.mappings) {
+		const fromIndex = idToIndex.get(mapping.fromId);
+		const toIndex = idToIndex.get(mapping.toId);
+		if (fromIndex === void 0) throw new _mionjs_core.FatalError({
+			statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+			type: "batch-mapping-invalid-source",
+			publicMessage: `Mapping source route '${mapping.fromId}' not found in batch '${entry.id}'.`,
+			errorData: {
+				batchId: entry.id,
+				mapping
+			}
+		});
+		if (toIndex === void 0) throw new _mionjs_core.FatalError({
+			statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+			type: "batch-mapping-invalid-target",
+			publicMessage: `Mapping target route '${mapping.toId}' not found in batch '${entry.id}'.`,
+			errorData: {
+				batchId: entry.id,
+				mapping
+			}
+		});
+		const target = middleMethods[toIndex];
+		const targetParamsCount = target.paramsCount ?? 0;
+		if (mapping.paramIndex >= targetParamsCount && !target.paramsRest) throw new _mionjs_core.FatalError({
+			statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+			type: "batch-mapping-invalid-param-index",
+			publicMessage: `Mapping paramIndex ${mapping.paramIndex} is out of range for target route '${mapping.toId}', which takes ${targetParamsCount} parameter(s).`,
+			errorData: {
+				batchId: entry.id,
+				mapping
+			}
+		});
+		if (!(0, _mionjs_core.hasInputMapper)(mapping.mapperKey)) throw new _mionjs_core.FatalError({
+			statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+			type: "batch-mapper-not-allowed",
+			publicMessage: `Input mapper '${mapping.mapperKey}' is not registered on the server.`,
+			errorData: {
+				batchId: entry.id,
+				mapping
+			}
+		});
+		insertions.push({
+			index: fromIndex + 1,
+			method: createMappingMethod(mapping)
+		});
+		middleMethods[toIndex] = guardMappedTarget(middleMethods[toIndex]);
+	}
+	insertions.sort((a, b) => b.index - a.index);
+	for (const { index, method } of insertions) middleMethods.splice(index, 0, method);
+}
+/** A copy, never a mutation: the route's own RemoteMethod is shared with every plain call to that route. */
+function guardMappedTarget(target) {
+	if (target.mappedTargetOf) return target;
+	return {
+		...target,
+		mappedTargetOf: target,
+		isAsync: true,
+		methodCaller: async (context, executable, ...args) => {
+			if (require_src_lib_dispatchError.hasThrownError(context, executable.id)) return void 0;
+			return require_src_dispatch.getMethodCaller(target)(context, executable, ...args);
+		}
+	};
+}
+function createMappingMethod(mapping) {
+	const id = `mionInputFrom_${mapping.fromId}_${mapping.mapperKey}_to_${mapping.toId}`;
+	const cached = mappingMethodCache.get(id);
+	if (cached) return cached;
+	const noopJitFns = (0, _mionjs_core.getNoopJitFns)();
+	const method = {
+		type: _mionjs_core.HandlerType.rawMiddleware,
+		id,
+		hasReturnData: false,
+		paramsJitHash: "",
+		returnJitHash: "",
+		paramsJitFns: noopJitFns,
+		returnJitFns: noopJitFns,
+		handler: createMappingHandler(mapping),
+		options: { alwaysRun: false },
+		alwaysRun: false,
+		isAsync: true,
+		methodCaller: runMappingHandler
+	};
+	mappingMethodCache.set(id, method);
+	return method;
+}
+function createMappingHandler(mapping) {
+	return (ctx) => {
+		const sourceOutput = Object.hasOwn(ctx.response.body, mapping.fromId) ? ctx.response.body[mapping.fromId] : void 0;
+		if ((0, _mionjs_core.isRpcError)(sourceOutput) || require_src_lib_dispatchError.hasThrownError(ctx, mapping.fromId)) {
+			require_src_lib_dispatchError.addThrownError(ctx, mapping.toId, new _mionjs_core.RpcError({
+				statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+				type: "batch-mapping-source-failed",
+				publicMessage: `Route '${mapping.fromId}' failed, so the input it feeds into '${mapping.toId}' could not be computed.`,
+				errorData: {
+					fromId: mapping.fromId,
+					toId: mapping.toId,
+					paramIndex: mapping.paramIndex
+				}
+			}));
+			return;
+		}
+		const pureFn = (0, _mionjs_core.getInputMapper)(mapping.mapperKey);
+		if (!pureFn) throw new _mionjs_core.FatalError({
+			statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+			type: "batch-mapper-not-allowed",
+			publicMessage: `Input mapper '${mapping.mapperKey}' not found at runtime.`
+		});
+		let mappedValue;
+		try {
+			mappedValue = pureFn(sourceOutput);
+		} catch (error) {
+			throw new _mionjs_core.FatalError({
+				statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+				type: "batch-mapper-failed",
+				publicMessage: `The input mapper feeding route '${mapping.toId}' from '${mapping.fromId}' threw.`,
+				errorData: {
+					fromId: mapping.fromId,
+					toId: mapping.toId,
+					paramIndex: mapping.paramIndex
+				},
+				originalError: error
+			});
+		}
+		const targetParams = ctx.request.body[mapping.toId];
+		if (Array.isArray(targetParams)) targetParams[mapping.paramIndex] = mappedValue;
+	};
+}
+async function runMappingHandler(context, executable, ...args) {
+	return executable.handler(context);
+}
+//#endregion
+exports.capBatchBodySizes = capBatchBodySizes;
+exports.clearBatches = clearBatches;
+exports.getBatch = getBatch;
+exports.getBatchExecutionChain = getBatchExecutionChain;
+exports.getBatchIds = getBatchIds;
+exports.getMaxBatchBodySize = getMaxBatchBodySize;
+exports.readBatchId = readBatchId;
+exports.refreshBatchChainBodyLimits = refreshBatchChainBodyLimits;
+exports.registerBatches = registerBatches;
+exports.replaceBatches = replaceBatches;
+exports.resolveBatchMaxBodySize = resolveBatchMaxBodySize;
+
+//# sourceMappingURL=batches.cjs.map

package/.dist/cjs/src/batches.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"batches.cjs","names":[],"sources":["../../../src/batches.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 {\n  RpcError,\n  FatalError,\n  StatusCodes,\n  HandlerType,\n  getNoopJitFns,\n  getOrCreateGlobal,\n  getRoutePath,\n  ROUTER_ITEM_SEPARATOR_CHAR,\n  isRpcError,\n} from '@mionjs/core';\nimport {getInputMapper, hasInputMapper} from '@mionjs/core';\nimport type {BatchDefinition, BatchMapping} from '@mionjs/core';\nimport {getRouteExecutionChain, getPlatformRequestCap, getRouterOptions, startMiddlewares, endMiddlewares} from './router.ts';\nimport {getMethodCaller} from './dispatch.ts';\nimport {findMionQueryParam} from './lib/urlQuery.ts';\nimport {addThrownError, hasThrownError} from './lib/dispatchError.ts';\nimport {RouterOptions} from './types/general.ts';\nimport {MethodsExecutionChain, RemoteMethod} from './types/remoteMethods.ts';\nimport type {CallContext} from './types/context.ts';\n\n// ############# BATCH REGISTRY #############\n//\n// A batch is several routes run in ONE request, with `inputFrom` mappings feeding one route's output\n// into another's input on the server. The client build hashes each `batch([...])` call site's ordered\n// route ids into an id and compiles the id → definition table into the server (the generated\n// `.mion/rpc/batches.generated.js` calls replaceBatches), so a request carries only the id: nothing\n// untrusted describes a chain, there is no shape to check and no count to cap. Batches are NOT routes:\n// they live here apart from the route table, never looked up by path, and the merged chain is built\n// once per id (once per tenant when a pathTransform reads the request) and kept on the entry.\n\nexport interface BatchEntry {\n  readonly id: string;\n  /** Route ids in call order */\n  readonly routes: readonly string[];\n  readonly mappings: readonly BatchMapping[];\n  /** Merged chains keyed by the pathTransform-resolved paths ('' when there is no transform) */\n  readonly chains: Map<string, MethodsExecutionChain>;\n  /** The members' resolved limits plus the envelope, fixed when the first chain is built (see resolveBatchMaxBodySize) */\n  maxBodySize?: number;\n}\n\nconst batchesById = getOrCreateGlobal('mion.router.batchesById', () => new Map<string, BatchEntry>());\nconst mappingMethodCache = getOrCreateGlobal('mion.router.batchMappingMethodCache', () => new Map<string, RemoteMethod>());\n\n/** A malformed definition is a configuration error and throws at registration, never at request time.\n *  Re-registering an id replaces it; ids not in `table` are left alone (replaceBatches is the whole-table form). */\nexport function registerBatches(table: Record<string, BatchDefinition>): void {\n  for (const [id, definition] of Object.entries(table)) {\n    assertValidBatchDefinition(id, definition);\n    batchesById.set(id, {\n      id,\n      routes: [...definition.routes],\n      mappings: definition.mappings ? definition.mappings.map((mapping) => ({...mapping})) : [],\n      chains: new Map(),\n    });\n  }\n}\n\n/** Replaces the WHOLE table. What the generated `.mion/rpc/batches.generated.js` calls, so every\n *  evaluation of it leaves exactly that file's batches registered and nothing from before. */\nexport function replaceBatches(table: Record<string, BatchDefinition>): void {\n  clearBatches();\n  registerBatches(table);\n}\n\n/** The table is build-generated, so this only guards against a stale or hand-edited manifest. */\nfunction assertValidBatchDefinition(id: string, definition: BatchDefinition): void {\n  const invalid = (reason: string): never => {\n    throw new Error(`[mion batches] batch '${id}' is malformed: ${reason}.`);\n  };\n  if (!id) invalid('empty id');\n  if (!definition || typeof definition !== 'object') invalid('expected an object');\n  if (!Array.isArray(definition.routes) || definition.routes.length === 0) invalid('`routes` must be a non-empty array');\n  if (definition.routes.some((route) => typeof route !== 'string' || !route)) invalid('`routes` must be route ids');\n  if (definition.mappings === undefined) return;\n  if (!Array.isArray(definition.mappings)) invalid('`mappings` must be an array');\n  for (const mapping of definition.mappings) {\n    if (!mapping || typeof mapping !== 'object') invalid('every mapping must be an object');\n    const {fromId, toId, mapperKey, paramIndex} = mapping;\n    if (typeof fromId !== 'string' || typeof toId !== 'string' || typeof mapperKey !== 'string')\n      invalid('mapping `fromId`, `toId` and `mapperKey` must be strings');\n    if (!definition.routes.includes(fromId)) invalid(`mapping source '${fromId}' is not a route of the batch`);\n    if (!definition.routes.includes(toId)) invalid(`mapping target '${toId}' is not a route of the batch`);\n    // Integer + non-negative, so paramIndex can only ever be an array INDEX (never a property name\n    // like '__proto__'); the upper bound needs the target's arity, checked while the chain is built.\n    if (typeof paramIndex !== 'number' || !Number.isInteger(paramIndex) || paramIndex < 0)\n      invalid('mapping `paramIndex` must be a non-negative integer');\n  }\n}\n\nexport function getBatch(id: string): BatchEntry | undefined {\n  return batchesById.get(id);\n}\n\n/** Ids of every registered batch, for the metadata route. */\nexport function getBatchIds(): string[] {\n  return [...batchesById.keys()];\n}\n\n/** Called by resetRouter and replaceBatches. */\nexport function clearBatches(): void {\n  batchesById.clear();\n  mappingMethodCache.clear();\n}\n\n/** The member routes' resolved limits (each already carries its factor and envelope, or the platform's\n *  number when its types cannot say) plus the outer braces, fixed the first time a chain is built. */\nexport function resolveBatchMaxBodySize(entry: BatchEntry, memberChains: MethodsExecutionChain[]): number {\n  if (entry.maxBodySize === undefined) entry.maxBodySize = sumChainMaxBodySize(memberChains);\n  return entry.maxBodySize;\n}\n\nfunction sumChainMaxBodySize(chains: MethodsExecutionChain[]): number {\n  let total = 2;\n  for (const chain of chains) total += chain.maxBodySize;\n  return Math.min(total, getPlatformRequestCap() ?? Infinity);\n}\n\n/** The limits not yet settled read the platform ceiling when they are. */\nexport function capBatchBodySizes(maxRequestSize: number): void {\n  for (const entry of batchesById.values()) {\n    if (entry.maxBodySize !== undefined && entry.maxBodySize > maxRequestSize) entry.maxBodySize = maxRequestSize;\n  }\n}\n\n/** Re-folds every ALREADY built chain from its entry's current number: without it a chain built before\n *  a later setPlatformConfig keeps serving a limit the platform has since promised to refuse. */\nexport function refreshBatchChainBodyLimits(platformMaxBodySize: number): void {\n  for (const entry of batchesById.values()) {\n    const limit = entry.maxBodySize ?? platformMaxBodySize;\n    for (const chain of entry.chains.values()) {\n      chain.declaredBodySize = entry.maxBodySize;\n      chain.maxBodySize = limit;\n    }\n  }\n}\n\n/** The largest limit any registered batch resolves to, over the member routes' untransformed\n *  paths: what bun sizes its native server limit with (see getMaxRouteBodySize). */\nexport function getMaxBatchBodySize(): number {\n  const opts = getRouterOptions();\n  let largest = 0;\n  for (const entry of batchesById.values()) {\n    if (entry.maxBodySize !== undefined) {\n      largest = Math.max(largest, entry.maxBodySize);\n      continue;\n    }\n    const chains: MethodsExecutionChain[] = [];\n    for (const routeId of entry.routes) {\n      const chain = getRouteExecutionChain(getRoutePath(routeId.split(ROUTER_ITEM_SEPARATOR_CHAR), opts));\n      if (chain) chains.push(chain);\n    }\n    largest = Math.max(largest, sumChainMaxBodySize(chains));\n  }\n  return largest;\n}\n\n// ############# REQUEST RESOLUTION #############\n\n/** `id=<batchId>` is the only parameter the batch endpoint reads; missing or undecodable is an unknown id.\n *  The id is the one query value that IS percent-decoded, so it survives a `/` or a space in a route name. */\nexport function readBatchId(urlQuery: string | undefined): string | undefined {\n  const rawId = findMionQueryParam(urlQuery, 'id');\n  if (rawId === undefined) return undefined;\n  try {\n    return decodeURIComponent(rawId) || undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Runs while the call context is acquired, BEFORE the body is read, so an unknown id costs nothing but\n *  a Map lookup: it answers undefined and the caller resolves the batch not-found chain.\n *  The id is the only untrusted input and it is never echoed back. */\nexport function getBatchExecutionChain(\n  rawRequest: unknown,\n  opts: RouterOptions,\n  urlQuery?: string\n): MethodsExecutionChain | undefined {\n  const batchId = readBatchId(urlQuery);\n  const entry = batchId ? getBatch(batchId) : undefined;\n  if (!entry) return undefined;\n\n  // pathTransform may read the request (a tenant header, the host), so with a transform the chains are\n  // kept per resolved path list: the same id from two requests that resolve differently never shares a chain.\n  const routePaths = entry.routes.map((routeId) => getRoutePath(routeId.split(ROUTER_ITEM_SEPARATOR_CHAR), opts));\n  const transformedPaths = opts.pathTransform\n    ? routePaths.map((routePath) => opts.pathTransform!(rawRequest, routePath) || routePath)\n    : routePaths;\n  const chainKey = opts.pathTransform ? transformedPaths.join(',') : '';\n  let executionChain = entry.chains.get(chainKey);\n  if (!executionChain) {\n    executionChain = buildMergedExecutionChain(entry, transformedPaths);\n    entry.chains.set(chainKey, executionChain);\n  }\n  return executionChain;\n}\n\n/** Takes already-transformed paths; each mapping step goes between its source and target route. */\nfunction buildMergedExecutionChain(entry: BatchEntry, transformedPaths: string[]): MethodsExecutionChain {\n  const seenIds = new Set<string>();\n  const middleMethods: RemoteMethod[] = [];\n  const memberChains: MethodsExecutionChain[] = [];\n  let firstRouteIndex = -1;\n\n  const startMiddlewareIds = new Set(startMiddlewares.map((method) => method.id));\n  const endMiddlewareIds = new Set(endMiddlewares.map((method) => method.id));\n\n  transformedPaths.forEach((transformedPath, index) => {\n    const chain = getRouteExecutionChain(transformedPath);\n    if (!chain) {\n      throw new FatalError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'batch-route-not-found',\n        publicMessage: `Route '${entry.routes[index]}' of batch '${entry.id}' is not registered on this server.`,\n        errorData: {batchId: entry.id, routeId: entry.routes[index]},\n      });\n    }\n\n    memberChains.push(chain);\n    if (firstRouteIndex < 0) firstRouteIndex = chain.routeIndex;\n\n    // start and end middlewares are added separately, so skip them here\n    for (const method of chain.methods) {\n      if (seenIds.has(method.id)) continue;\n      if (startMiddlewareIds.has(method.id)) continue;\n      if (endMiddlewareIds.has(method.id)) continue;\n      seenIds.add(method.id);\n      middleMethods.push(method);\n    }\n  });\n\n  if (entry.mappings.length > 0) insertMappingMethods(entry, middleMethods);\n\n  const methods = [...startMiddlewares, ...middleMethods, ...endMiddlewares];\n  // A batch declares the sum its members resolved to\n  const declaredBodySize = resolveBatchMaxBodySize(entry, memberChains);\n  return {\n    // where the first route handler sits in the merged methods\n    routeIndex: firstRouteIndex,\n    methods,\n    // cached per member-path list, so one chain answers every endpoint path that reaches it\n    path: undefined,\n    batchId: entry.id,\n    batchRouteIds: entry.routes as string[],\n    declaredBodySize,\n    maxBodySize: declaredBodySize,\n    readsBody: true,\n  };\n}\n\n// ############# MAPPING METHODS #############\n\n/**\n * Inserts mapping methods into the middleMethods array in the correct position.\n * Each mapping method is inserted after the source route (fromId) and before the target route (toId).\n */\nfunction insertMappingMethods(entry: BatchEntry, middleMethods: RemoteMethod[]): void {\n  const idToIndex = new Map<string, number>();\n  for (let i = 0; i < middleMethods.length; i++) idToIndex.set(middleMethods[i].id, i);\n\n  const insertions: Array<{index: number; method: RemoteMethod}> = [];\n\n  for (const mapping of entry.mappings) {\n    const fromIndex = idToIndex.get(mapping.fromId);\n    const toIndex = idToIndex.get(mapping.toId);\n    if (fromIndex === undefined) {\n      throw new FatalError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'batch-mapping-invalid-source',\n        publicMessage: `Mapping source route '${mapping.fromId}' not found in batch '${entry.id}'.`,\n        errorData: {batchId: entry.id, mapping},\n      });\n    }\n    if (toIndex === undefined) {\n      throw new FatalError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'batch-mapping-invalid-target',\n        publicMessage: `Mapping target route '${mapping.toId}' not found in batch '${entry.id}'.`,\n        errorData: {batchId: entry.id, mapping},\n      });\n    }\n\n    // paramIndex is a non-negative integer (registerBatches); the UPPER bound needs the target's\n    // arity, only known here. A mapping can never write past the params the route declares, unless a rest param takes them.\n    const target = middleMethods[toIndex];\n    const targetParamsCount = target.paramsCount ?? 0;\n    if (mapping.paramIndex >= targetParamsCount && !target.paramsRest) {\n      throw new FatalError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'batch-mapping-invalid-param-index',\n        publicMessage:\n          `Mapping paramIndex ${mapping.paramIndex} is out of range for target route '${mapping.toId}', ` +\n          `which takes ${targetParamsCount} parameter(s).`,\n        errorData: {batchId: entry.id, mapping},\n      });\n    }\n\n    // The allow-list is the gate on what a table may reference: the mapper's pure-fn id, as\n    // harvested from the client build. An id that came through no mion lane is REJECTED here,\n    // never evaluated.\n    if (!hasInputMapper(mapping.mapperKey)) {\n      throw new FatalError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'batch-mapper-not-allowed',\n        publicMessage: `Input mapper '${mapping.mapperKey}' is not registered on the server.`,\n        errorData: {batchId: entry.id, mapping},\n      });\n    }\n\n    insertions.push({index: fromIndex + 1, method: createMappingMethod(mapping)});\n    // Run the target only when every mapping into it produced a value: a failed source leaves it a thrown error.\n    middleMethods[toIndex] = guardMappedTarget(middleMethods[toIndex]);\n  }\n\n  // descending, so a splice never shifts the indices still to come\n  insertions.sort((a, b) => b.index - a.index);\n  for (const {index, method} of insertions) middleMethods.splice(index, 0, method);\n}\n\n/** A copy, never a mutation: the route's own RemoteMethod is shared with every plain call to that route. */\nfunction guardMappedTarget(target: RemoteMethod): RemoteMethod {\n  if ((target as GuardedTarget).mappedTargetOf) return target;\n  const guarded = {\n    ...target,\n    mappedTargetOf: target,\n    // async whatever the target is, so the dispatcher must await this member\n    isAsync: true,\n    methodCaller: async (context: CallContext, executable: RemoteMethod, ...args: unknown[]) => {\n      if (hasThrownError(context, executable.id)) return undefined;\n      // the shared method carries its caller from registration, same as the dispatcher reads\n      return getMethodCaller(target)(context, executable, ...args);\n    },\n  } as GuardedTarget;\n  return guarded;\n}\n\ntype GuardedTarget = RemoteMethod & {mappedTargetOf?: RemoteMethod};\n\nfunction createMappingMethod(mapping: BatchMapping): RemoteMethod {\n  const id = `mionInputFrom_${mapping.fromId}_${mapping.mapperKey}_to_${mapping.toId}`;\n  const cached = mappingMethodCache.get(id);\n  if (cached) return cached;\n\n  const noopJitFns = getNoopJitFns();\n  const method = {\n    type: HandlerType.rawMiddleware,\n    id,\n    hasReturnData: false,\n    paramsJitHash: '',\n    returnJitHash: '',\n    paramsJitFns: noopJitFns,\n    returnJitFns: noopJitFns,\n    handler: createMappingHandler(mapping),\n    options: {alwaysRun: false},\n    alwaysRun: false,\n    // runMappingHandler is async, so this member must be awaited\n    isAsync: true,\n    methodCaller: runMappingHandler,\n  } as RemoteMethod;\n\n  mappingMethodCache.set(id, method);\n  return method;\n}\n\nfunction createMappingHandler(mapping: BatchMapping) {\n  return (ctx: CallContext) => {\n    // own key only: a source named like `toString` that stored nothing would feed Object.prototype's function\n    const sourceOutput = Object.hasOwn(ctx.response.body, mapping.fromId) ? ctx.response.body[mapping.fromId] : undefined;\n    // A failed or skipped source has nothing to map: the error goes to @thrownErrors, the target's slots hold only what it declares.\n    if (isRpcError(sourceOutput) || hasThrownError(ctx, mapping.fromId)) {\n      addThrownError(\n        ctx,\n        mapping.toId,\n        new RpcError({\n          statusCode: StatusCodes.UNEXPECTED_ERROR,\n          type: 'batch-mapping-source-failed',\n          publicMessage: `Route '${mapping.fromId}' failed, so the input it feeds into '${mapping.toId}' could not be computed.`,\n          errorData: {fromId: mapping.fromId, toId: mapping.toId, paramIndex: mapping.paramIndex},\n        })\n      );\n      return;\n    }\n    const pureFn = getInputMapper(mapping.mapperKey);\n    if (!pureFn) {\n      throw new FatalError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'batch-mapper-not-allowed',\n        publicMessage: `Input mapper '${mapping.mapperKey}' not found at runtime.`,\n      });\n    }\n    let mappedValue: unknown;\n    try {\n      mappedValue = pureFn(sourceOutput);\n    } catch (error) {\n      // thrown, so the batch stops like any handler error, but typed and with no registry key in the message\n      throw new FatalError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'batch-mapper-failed',\n        publicMessage: `The input mapper feeding route '${mapping.toId}' from '${mapping.fromId}' threw.`,\n        errorData: {fromId: mapping.fromId, toId: mapping.toId, paramIndex: mapping.paramIndex},\n        originalError: error as Error,\n      });\n    }\n    // the client sent a null placeholder at paramIndex\n    // an array check, not truthiness: an id like `toString` finds a prototype function, a wire value may be a string\n    const targetParams = ctx.request.body[mapping.toId];\n    if (Array.isArray(targetParams)) targetParams[mapping.paramIndex] = mappedValue;\n  };\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nasync function runMappingHandler(context: CallContext, executable: RemoteMethod, ...args: unknown[]) {\n  return executable.handler(context);\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,22 @@
+import { BatchDefinition, BatchMapping } from '@mionjs/core';
+import { RouterOptions } from './types/general.ts';
+import { MethodsExecutionChain } from './types/remoteMethods.ts';
+export interface BatchEntry {
+    readonly id: string;
+    readonly routes: readonly string[];
+    readonly mappings: readonly BatchMapping[];
+    readonly chains: Map<string, MethodsExecutionChain>;
+    maxBodySize?: number;
+}
+export declare function registerBatches(table: Record<string, BatchDefinition>): void;
+export declare function replaceBatches(table: Record<string, BatchDefinition>): void;
+export declare function getBatch(id: string): BatchEntry | undefined;
+export declare function getBatchIds(): string[];
+export declare function clearBatches(): void;
+export declare function resolveBatchMaxBodySize(entry: BatchEntry, memberChains: MethodsExecutionChain[]): number;
+export declare function capBatchBodySizes(maxRequestSize: number): void;
+export declare function refreshBatchChainBodyLimits(platformMaxBodySize: number): void;
+export declare function getMaxBatchBodySize(): number;
+export declare function readBatchId(urlQuery: string | undefined): string | undefined;
+export declare function getBatchExecutionChain(rawRequest: unknown, opts: RouterOptions, urlQuery?: string): MethodsExecutionChain | undefined;
+//# sourceMappingURL=batches.d.ts.map

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

@@ -1,125 +1,81 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_constants = require("./constants.cjs");
-const src_router = require("./router.cjs");
-const core = require("@mionjs/core");
-const src_routesFlow = require("./routesFlow.cjs");
-let contextPool = [];
-function getContextPoolStats() {
-  return {
-    poolSize: contextPool.length
-  };
+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);
 }
-function clearContextPool() {
-  contextPool = [];
+/** `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
+	};
 }
-function createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery) {
-  const transformedPath = opts.pathTransform?.(rawRequest, path) || path;
-  const { executionChain, routesFlowRouteIds } = getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);
-  return {
-    path: transformedPath,
-    request: {
-      headers: reqHeaders,
-      rawBody: reqRawBody,
-      bodyType: reqBodyType ?? getRequestBodyType(reqRawBody),
-      body: {},
-      thrownErrors: void 0
-    },
-    response: {
-      statusCode: core.StatusCodes.OK,
-      hasErrors: false,
-      headers: respHeaders,
-      body: {},
-      rawBody: "",
-      serializer: core.SerializerModes.json,
-      binSerializer: void 0
-    },
-    executionChain,
-    shared: opts.contextDataFactory ? opts.contextDataFactory() : {},
-    urlQuery,
-    routesFlowRouteIds
-  };
-}
-function acquireCallContext(usePooling, path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery) {
-  if (!usePooling) return createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery);
-  const pooledContext = contextPool.pop();
-  const transformedPath = opts.pathTransform?.(rawRequest, path) || path;
-  if (pooledContext) {
-    const ctx = pooledContext;
-    ctx.path = transformedPath;
-    const req = ctx.request;
-    req.headers = reqHeaders;
-    req.rawBody = reqRawBody;
-    req.bodyType = reqBodyType ?? getRequestBodyType(reqRawBody);
-    req.body = {};
-    req.thrownErrors = void 0;
-    const resp = ctx.response;
-    resp.statusCode = core.StatusCodes.OK;
-    resp.hasErrors = false;
-    resp.headers = respHeaders;
-    resp.body = {};
-    resp.rawBody = "";
-    resp.serializer = core.SerializerModes.json;
-    resp.binSerializer = void 0;
-    const { executionChain, routesFlowRouteIds } = getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);
-    ctx.executionChain = executionChain;
-    ctx.routesFlowRouteIds = routesFlowRouteIds;
-    ctx.shared = opts.contextDataFactory ? opts.contextDataFactory() : {};
-    ctx.urlQuery = urlQuery;
-    return ctx;
-  }
-  return createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery);
-}
-function releaseCallContext(ctx, maxPoolSize) {
-  if (contextPool.length < maxPoolSize) {
-    const mutableCtx = ctx;
-    const req = mutableCtx.request;
-    req.rawBody = "";
-    req.body = null;
-    req.thrownErrors = void 0;
-    mutableCtx.response = {
-      statusCode: core.StatusCodes.OK,
-      hasErrors: false,
-      headers: null,
-      // Will be set when context is acquired
-      body: null,
-      // Will be set when context is acquired
-      rawBody: "",
-      serializer: core.SerializerModes.json,
-      binSerializer: void 0
-    };
-    mutableCtx.shared = null;
-    mutableCtx.executionChain = null;
-    mutableCtx.routesFlowRouteIds = void 0;
-    contextPool.push(ctx);
-  }
+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 core.SerializerModes.stringifyJson;
-  if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array) return core.SerializerModes.binary;
-  return core.SerializerModes.json;
+	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) {
-  const hasPrefix = !!opts.basePath;
-  const isRoutesFlowPath = hasPrefix ? originalPath.endsWith(src_constants.WORKFLOW_PATH) : originalPath === src_constants.WORKFLOW_PATH;
-  if (isRoutesFlowPath) return src_routesFlow.getRoutesFlowExecutionChain(rawRequest, opts, urlQuery);
-  let executionChain = src_router.getRouteExecutionChain(transformedPath);
-  if (!executionChain) {
-    const notFoundPath = core.getRoutePath([core.MION_ROUTES.notFound], opts);
-    executionChain = src_router.getRouteExecutionChain(notFoundPath);
-    if (!executionChain) {
-      throw new core.RpcError({
-        statusCode: core.StatusCodes.UNEXPECTED_ERROR,
-        type: "not-found",
-        publicMessage: "Not-found route is not registered. This should never happen."
-      });
-    }
-  }
-  return { executionChain };
+	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;
 }
-exports.acquireCallContext = acquireCallContext;
-exports.clearContextPool = clearContextPool;
+//#endregion
 exports.createCallContext = createCallContext;
-exports.getContextPoolStats = getContextPoolStats;
-exports.releaseCallContext = releaseCallContext;
-//# sourceMappingURL=callContext.cjs.map
+exports.createContextFromChain = createContextFromChain;
+exports.getRequestBodyType = getRequestBodyType;
+exports.resolveExecutionChain = resolveExecutionChain;
+
+//# sourceMappingURL=callContext.cjs.map