@mionjs/router 0.8.10 → 0.13.2

package/.dist/esm/.mion/types/rt/shared/b3OCOIQ3Az.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"b3OCOIQ3Az.js","names":[],"sources":["../../../../../../.mion/types/rt/shared/b3OCOIQ3Az.js"],"sourcesContent":["import {__rt_rts_X6LLuPu8LB} from './X6LLuPu8LB.js';\nexport const __rt_rts_b3OCOIQ3Az=[4,()=>[__rt_rts_X6LLuPu8LB],,'rts_crJWzxNhTw',[['BncpXor',32,,,'alwaysThrowMessage',,!0,!0,,,,!0],\n['BxY3rlq',32,,,'pureFnDependencies',,!0,!0,,,,!0],\n['CWgyGNK',32,,,'params',,,,,,,!0],\n['CmEoLLf',32,,,'syncId',,!0,,,,,!0],\n['DVkmLqU',32,,,'returnJitHash',,,,,,,!0],\n['ENsN2pD',31],\n['EVPHpQK',15,,,'stack',,!0,,,,,!0,,,,,,,,,!0],\n['FZntjUO',15,,,'errorData',,!0,!0,,,0,!0],\n['FkQ3B14',32,,,'isMutation',,!0,,,,,!0],\n['GCScwwB',32,,,'parser',,!0,,,,,!0],\n['GE1QgIl',32,,,'code',,!0,!0,,,,!0],\n['H9z2JRL',30,,'MethodMetadata'],\n['I9X8wxa',32,,,'jitHash',,,,,,,!0],\n['IJpcjGV',30,,'RemoteMethodOpts'],\n['INJT62z',32,,,'type',,,,,,,!0],\n['J4BcOys',32,,,'nestLevel',,,,,,,!0],\n['JNJI6M9',32,,,'hasReturnData',,,,,,,!0],\n['JmyrGf9',30,,'SerializablePureFunction'],\n['Jv3Eofu',32,,,'sanitizeParams',,!0,,,,,!0],\n['K4tzolL',32,,,'fnID',,,!0,,,,!0],\n['KJLQvg9',32,,,'maxBodySize',,!0,,,,,!0],\n['KW2BeGf',30,,'HeadersMetaData'],\n['KblyjTO',32,,,'id',,,,,,,!0],\n['Klb3sEb',32,,,'typeName',,,!0,,,,!0],\n['KnRc4Vl',32,,,'isAsync',,,,,,,!0],\n['L95VIji',32,,,'headersReturn',,!0,,,,,!0],\n['MOVU3Lw',13,,,,'compact'],\n['MxJiVnX',32,,,'description',,!0,,,,,!0],\n['NnuRgLd',32,,,'defaultParamValues',,,!0,,,,!0],\n['OCpWpSc',15,,,'mion@isΣrrθr',,,!0,,,0],\n['PcH2Jga',15,,,'message',,!0,,,,,!0,,,,,,,,,!0],\n['PwNcSuS',31],\n['QD8D1GX',32,,,'paramsCount',,!0,,,,,!0],\n['RBtYmYB',32,,,'paramsRest',,!0,,,,,!0],\n['Rnm7eCO',32,,,'paramNames',,!0,,,,,!0],\n['SJBMH8X',30,,'MethodsCache'],\n['SW6Ke6X',30,,'SerializableMethodsData'],\n['SYYLxEY',32,,,'paramNames',,!0,,,,,!0],\n['TiUuEgO',32,,,'paramNames',,,!0,,,,!0],\n['U4XYTLz',15,,,'statusCode',,!0,,,,,!0],\n['ULlBExU',32,,,'methods',,,,,,,!0],\n['VU2j3Ds',30,,'CompiledFnData'],\n['VtWqM7u',25],\n['Vveyjb1',32,,,'hasReturnData',,,,,,,!0],\n['WDATAS7',15,,,'type',,,!0,,,0,!0],\n['WIhjWe9',23,,'ReturnParserStrategy'],\n['WgAWvIr',32,,,'paramsJitHash',,,,,,,!0],\n['XvV6JAt',32,,,'middlewareIds',,!0,,,,,!0],\n['XzfxjFZ',32,,,'options',,,,,,,!0],\n['YnrIYeO',32,,,'batches',,!0,,,,,!0],\n['Z5D90YY',32,,,'syncId',,!0,,,,,!0],\n['ZL9w0Lg',32,,,'args',,,!0,,,,!0],\n['ZRJiRyT',23,,'ParserStrategy'],\n['Zdevfid',30,,'PureFnsDataCache'],\n['ZryqeRF',7],\n['a2A0Jor',32,,,'return',,,,,,,!0],\n['aCKVpQw',32,,,'headerNames',,,,,,,!0],\n['aXREI5X',15,,,'publicMessage',,,!0,,,0,!0],\n['aYkiywW',30,,'Readonly'],\n['bUyU2Dd',13,,,,'mutateStrict'],\n['bWaxkU3',32,,,'id',,,!0,,,,!0],\n['bshoytY',32,,,'id',,,,,,,!0],\n['cnyqXhw',32,,,'code',,,!0,,,,!0],\n['cpQJBPY',31],\n['eGY9NIx',32,,,'deps',,,,,,,!0],\n['hTOdaJv',32,,,'alwaysRun',,!0,,,,,!0],\n['hU1aCVt',32,,,'isAsync',,,,,,,!0],\n['hYkSGg6',32,,,'headersParam',,!0,,,,,!0],\n['iiyi1a0',32,,,'rtDependencies',,!0,!0,,,,!0],\n['jAty5lT',32,,,'headersParam',,!0,,,,,!0],\n['jLPpyyg',13,,,,'mutate'],\n['kPwJnx8',32,,,'paramsCount',,!0,,,,,!0],\n['kc48AIR',13,,,,'clone'],\n['kuE24Ar',30,,'CompiledFnArgs'],\n['lgzT62q',32,,,'pointer',,,,,,,!0],\n['maymWVK',32,,,'isNoop',,!0,!0,,,,!0],\n['mxdUAap',32,,,'headersReturn',,!0,,,,,!0],\n['ngYl0pG',20,,'RpcError'],\n['oSk9jXy',32,,,'vλl'],\n['od0j6kO',30,,'FnsDataCache'],\n['ptcWzPo',32,,,'pureFnDependencies',,!0,!0,,,,!0],\n['py2Gb7p',32,,,'nestLevel',,,,,,,!0],\n['qGlu38s',32,,,'pointer',,,,,,,!0],\n['qQEgxt7',15,,,'isFatal',,!0,,,,,!0,,,,,,,,,!0],\n['stcxQjR',15,,,'cause',,!0,,,,,!0,,,,,,,,,!0],\n['u3xjjco',3],\n['uBBOy7L',32,,,'paramNames',,!0,,,,,!0],\n['uz6TmiD',30,,'ResolvedParser'],\n['v0dt7iM',32,,,'paramsRest',,!0,,,,,!0],\n['vbxZ0wi',15,,,'name',,!0,,,,,!0,,,,,,,,,!0],\n['vei3XnC',30,,'MethodWithOptions'],\n['vtFBGPI',15,,,'id',,!0,!0,,,0,!0],\n['w6GZ5w0',32,,,'purFnDeps',,,,,,,!0],\n['wXtLEOq',32,,,'rtFnHash',,,!0,,,,!0],\n['weJHHik',32,,,'returnJitHash',,,,,,,!0],\n['xAqIaQD',32,,,'paramsJitHash',,,,,,,!0],\n['yLB3LF9',32,,,'middlewareIds',,!0,,,,,!0],\n['zUfkFkJ',32,,,'type',,,,,,,!0],\n['zaqNSiX',32,,,'familyTag',,!0,!0,,,,!0],\n['zlp1w1d',31]],[['eatg0z3'],[42],[52],['eatg0z3'],['eatg0z3'],[41,,'eatg0z3'],['eatg0z3'],[58],[54],[87],['eatg0z3'],[,[97,22,66,43,32,37,33,46,94,67,25,3,96,74,15]],['eatg0z3'],[,[65,27,9,8,18,20]],['AriM0QK'],['AriM0QK'],[54],[,[60,38,62,1]],[54],['eatg0z3'],['AriM0QK'],[,[56,12]],['eatg0z3'],['eatg0z3'],[54],[21],,['eatg0z3'],[73],['pjlOBRH'],['eatg0z3'],['eatg0z3',,'eatg0z3'],['AriM0QK'],[54],[42],[,[99]],[,[40,64,92,49]],[42],[42],['AriM0QK'],[35],[,[23,19,98,93,51,28,75,10,68,80,86,0]],['eatg0z3'],[54],['a7EVsr7'],[,[72,26,70],,,,,[72,26,70]],['eatg0z3'],[42],[13],[42],['eatg0z3'],[73],[,[72,26,70,59],,,,,[72,26,70,59]],[,[63]],,[45],[42],['eatg0z3'],[,,,,,,,,,['a7EVsr7']],,['eatg0z3'],['eatg0z3'],['eatg0z3'],[17,,'eatg0z3'],[79],[54],[54],[21],[42],[21],,['AriM0QK'],,[,[78,31]],[42],[54],[21],[,[91,57,7,39,83,6,84,29,44,30,89],,,,,,,,,['a7EVsr7','a7EVsr7'],['yLMWODR'],['KlL8jSg']],['eatg0z3'],[,[5]],[42],['AriM0QK'],[42],['pjlOBRH'],['a7EVsr7'],,[42],[,[2,55]],[54],['eatg0z3'],[,[48,14,61,24,16,71,34,88,95,4,69,76,50,47,82,81],,,,,,,,,,,,[11]],['m13oqC7'],[53],['eatg0z3'],['eatg0z3'],['eatg0z3'],[42],['AriM0QK'],['eatg0z3'],[90,,'eatg0z3']]];\n"],"mappings":"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"}

package/.dist/esm/index.d.ts

@@ -5,16 +5,17 @@ export * from './src/types/general.ts';
 export * from './src/types/guards.ts';
 export * from './src/types/handlers.ts';
 export * from './src/types/publicMethods.ts';
+export * from './src/types/resolvedOptions.ts';
 export * from './src/constants.ts';
 export * from './src/router.ts';
 export * from './src/dispatch.ts';
 export * from './src/callContext.ts';
+export * from './src/batches.ts';
 export * from './src/lib/dispatchError.ts';
 export * from './src/lib/headers.ts';
 export * from './src/lib/remoteMethods.ts';
-export * from './src/lib/handlers.ts';
+export * from './src/types/mionRouter.ts';
 export * from './src/lib/queryBody.ts';
-export * from './src/lib/methodsCache.ts';
-export * from './src/routes/errors.routes.ts';
-export * from './src/routes/mion.routes.ts';
+export * from './src/lib/bodyReader.ts';
+export { mionErrorsRoutes } from './src/routes/errors.routes.ts';
 //# sourceMappingURL=index.d.ts.map

package/.dist/esm/index.js

@@ -1,147 +1,13 @@
-import { __ΩCallContext, __ΩContextDataFactory, __ΩMionHeaders, __ΩMionRequest, __ΩMionResponse, __ΩRawRequestBody, __ΩRawResponseBody, __ΩResponseBody, __ΩRoutesFlowExecutionResult } from "./src/types/context.js";
-import { __ΩAnyHandlerDef, __ΩHeadersMiddleFnDef, __ΩMiddleFnDef, __ΩRawMiddleFnDef, __ΩRouteDef } from "./src/types/definitions.js";
-import { __ΩHeadersMethod, __ΩHeadersMiddleFnOptions, __ΩMethodsExecutionChain, __ΩMiddleFnMethod, __ΩMiddleFnOptions, __ΩRawMethod, __ΩRawMiddleFnOptions, __ΩRemoteMethod, __ΩRouteMethod, __ΩRouteOptions } from "./src/types/remoteMethods.js";
-import { __ΩRoute, __ΩRouterEntry, __ΩRouterOptions, __ΩRoutes } from "./src/types/general.js";
-import { isAnyMiddleFnDef, isExecutable, isHeaderExecutable, isHeadersMiddleFnDef, isMiddleFnDef, isPublicExecutable, isRawExecutable, isRawMiddleFnDef, isRoute, isRouteDef, isRouteExecutable, isRoutes } from "./src/types/guards.js";
-import { __ΩAnyHandler, __ΩHandler, __ΩHeaderHandler, __ΩRawMiddleFnHandler } from "./src/types/handlers.js";
-import { __ΩMayReturnError, __ΩMiddleFnsCollection, __ΩPrivateDef, __ΩPrivateMiddleFnDef, __ΩPublicApi, __ΩPublicHandler, __ΩPublicHeadersFn, __ΩPublicMiddleFn, __ΩPublicRoute, __ΩRemoteApi } from "./src/types/publicMethods.js";
-import { DEFAULT_ROUTE_OPTIONS, HEADER_HOOK_DEFAULT_PARAMS, IS_TEST_ENV, MAX_ROUTE_NESTING, NOT_FOUND_HOOK_NAME, NOT_FOUND_PATH, ROUTE_DEFAULT_PARAMS, WORKFLOW_KEY, WORKFLOW_PATH } from "./src/constants.js";
-import { addEndMiddleFns, addStartMiddleFns, endMiddleFns, geMiddleFnsSize, geRoutesSize, getAllExecutablesIds, getAnyExecutable, getComplexity, getExecutableFromMiddleFn, getExecutableFromRawMiddleFn, getExecutableFromRoute, getMiddleFnExecutable, getPlatformConfig, getRouteEntries, getRouteExecutable, getRouteExecutableFromPath, getRouteExecutionChain, getRouterOptions, getTotalExecutables, initMionRouter, initRouter, isPrivateDefinition, isPrivateExecutable, registerRoutes, resetRouter, setPlatformConfig, shouldFullGenerateSpec, startMiddleFns } from "./src/router.js";
-import { dispatchRoute } from "./src/dispatch.js";
-import { acquireCallContext, clearContextPool, createCallContext, getContextPoolStats, releaseCallContext } from "./src/callContext.js";
-import { getRouterFatalErrorResponse, onExecutableError } from "./src/lib/dispatchError.js";
-import { headersFromRecord } from "./src/lib/headers.js";
+import { isAnyMiddlewareDef, isExecutable, isHeaderExecutable, isHeadersMiddlewareDef, isMiddlewareDef, isPublicExecutable, isRawExecutable, isRawMiddlewareDef, isRoute, isRouteDef, isRouteExecutable, isRoutes } from "./src/types/guards.js";
+import { DEFAULT_ROUTE_OPTIONS, JSON_CONTENT_TYPE, MAX_ROUTE_NESTING } from "./src/constants.js";
+import { addThrownError, errorHeaderValue, getRouterFatalErrorResponse, hasThrownError, markResponseFailed, recordUndeclaredError, toRpcError } from "./src/lib/dispatchError.js";
+import { capBatchBodySizes, clearBatches, getBatch, getBatchExecutionChain, getBatchIds, getMaxBatchBodySize, readBatchId, refreshBatchChainBodyLimits, registerBatches, replaceBatches, resolveBatchMaxBodySize } from "./src/batches.js";
+import { createCallContext, createContextFromChain, getRequestBodyType, resolveExecutionChain } from "./src/callContext.js";
+import { callerForType, dispatchMaybeSync, dispatchPlatformError, dispatchRoute, dispatchWithContext, getMethodCaller } from "./src/dispatch.js";
 import { getPublicApi, getSerializableMethod, resetRemoteMethodsMetadata, serializeJitFn, serializeMethodDeps, serializePureDeps } from "./src/lib/remoteMethods.js";
-import { headersFn, middleFn, mutation, query, rawMiddleFn, route } from "./src/lib/handlers.js";
-import { __ΩQueryBodyResult, decodeQueryBody } from "./src/lib/queryBody.js";
-import { addToPersistedMethods, getPersistedMethod, getPersistedMethodMetadata, getPersistedMethods, loadCompiledMethods, persistedMethods, resetPersistedMethods, setPersistedMethods } from "./src/lib/methodsCache.js";
 import { mionErrorsRoutes } from "./src/routes/errors.routes.js";
-import { __ΩMionRoutes, mionRoutes } from "./src/routes/mion.routes.js";
-export {
-  DEFAULT_ROUTE_OPTIONS,
-  HEADER_HOOK_DEFAULT_PARAMS,
-  IS_TEST_ENV,
-  MAX_ROUTE_NESTING,
-  NOT_FOUND_HOOK_NAME,
-  NOT_FOUND_PATH,
-  ROUTE_DEFAULT_PARAMS,
-  WORKFLOW_KEY,
-  WORKFLOW_PATH,
-  __ΩAnyHandler,
-  __ΩAnyHandlerDef,
-  __ΩCallContext,
-  __ΩContextDataFactory,
-  __ΩHandler,
-  __ΩHeaderHandler,
-  __ΩHeadersMethod,
-  __ΩHeadersMiddleFnDef,
-  __ΩHeadersMiddleFnOptions,
-  __ΩMayReturnError,
-  __ΩMethodsExecutionChain,
-  __ΩMiddleFnDef,
-  __ΩMiddleFnMethod,
-  __ΩMiddleFnOptions,
-  __ΩMiddleFnsCollection,
-  __ΩMionHeaders,
-  __ΩMionRequest,
-  __ΩMionResponse,
-  __ΩMionRoutes,
-  __ΩPrivateDef,
-  __ΩPrivateMiddleFnDef,
-  __ΩPublicApi,
-  __ΩPublicHandler,
-  __ΩPublicHeadersFn,
-  __ΩPublicMiddleFn,
-  __ΩPublicRoute,
-  __ΩQueryBodyResult,
-  __ΩRawMethod,
-  __ΩRawMiddleFnDef,
-  __ΩRawMiddleFnHandler,
-  __ΩRawMiddleFnOptions,
-  __ΩRawRequestBody,
-  __ΩRawResponseBody,
-  __ΩRemoteApi,
-  __ΩRemoteMethod,
-  __ΩResponseBody,
-  __ΩRoute,
-  __ΩRouteDef,
-  __ΩRouteMethod,
-  __ΩRouteOptions,
-  __ΩRouterEntry,
-  __ΩRouterOptions,
-  __ΩRoutes,
-  __ΩRoutesFlowExecutionResult,
-  acquireCallContext,
-  addEndMiddleFns,
-  addStartMiddleFns,
-  addToPersistedMethods,
-  clearContextPool,
-  createCallContext,
-  decodeQueryBody,
-  dispatchRoute,
-  endMiddleFns,
-  geMiddleFnsSize,
-  geRoutesSize,
-  getAllExecutablesIds,
-  getAnyExecutable,
-  getComplexity,
-  getContextPoolStats,
-  getExecutableFromMiddleFn,
-  getExecutableFromRawMiddleFn,
-  getExecutableFromRoute,
-  getMiddleFnExecutable,
-  getPersistedMethod,
-  getPersistedMethodMetadata,
-  getPersistedMethods,
-  getPlatformConfig,
-  getPublicApi,
-  getRouteEntries,
-  getRouteExecutable,
-  getRouteExecutableFromPath,
-  getRouteExecutionChain,
-  getRouterFatalErrorResponse,
-  getRouterOptions,
-  getSerializableMethod,
-  getTotalExecutables,
-  headersFn,
-  headersFromRecord,
-  initMionRouter,
-  initRouter,
-  isAnyMiddleFnDef,
-  isExecutable,
-  isHeaderExecutable,
-  isHeadersMiddleFnDef,
-  isMiddleFnDef,
-  isPrivateDefinition,
-  isPrivateExecutable,
-  isPublicExecutable,
-  isRawExecutable,
-  isRawMiddleFnDef,
-  isRoute,
-  isRouteDef,
-  isRouteExecutable,
-  isRoutes,
-  loadCompiledMethods,
-  middleFn,
-  mionErrorsRoutes,
-  mionRoutes,
-  mutation,
-  onExecutableError,
-  persistedMethods,
-  query,
-  rawMiddleFn,
-  registerRoutes,
-  releaseCallContext,
-  resetPersistedMethods,
-  resetRemoteMethodsMetadata,
-  resetRouter,
-  route,
-  serializeJitFn,
-  serializeMethodDeps,
-  serializePureDeps,
-  setPersistedMethods,
-  setPlatformConfig,
-  shouldFullGenerateSpec,
-  startMiddleFns
-};
-//# sourceMappingURL=index.js.map
+import { addEndMiddlewares, addStartMiddlewares, createMionRouter, endMiddlewares, geRoutesSize, getAllExecutablesIds, getAnyExecutable, getBuildVersion, getComplexity, getExecutableFromMiddleware, getExecutableFromRawMiddleware, getExecutableFromRoute, getHostRequestHandler, getMaxRouteBodySize, getMiddlewareExecutable, getMiddlewaresSize, getNotFoundExecutionChain, getPlatformConfig, getPlatformMaxBodySize, getPlatformRequestCap, getResponseDefaults, getRouteEntries, getRouteExecutable, getRouteExecutionChain, getRouterOptions, getTotalExecutables, handOverToHost, hostOwnsSocket, isPrivateDefinition, resetRouter, setHostOwnsSocket, setPlatformConfig, shouldFullGenerateSpec, startMiddlewares } from "./src/router.js";
+import { FetchResponseHeaders, RecordResponseHeaders, getDefaultFetchHeaders, getDefaultHeaders, headersFromRecord, releaseHeaders, replyFetch } from "./src/lib/headers.js";
+import { decodeQueryBody } from "./src/lib/queryBody.js";
+import { BodyReadStrategy, readRequestBody, requestPayloadTooLarge } from "./src/lib/bodyReader.js";
+export { BodyReadStrategy, DEFAULT_ROUTE_OPTIONS, FetchResponseHeaders, JSON_CONTENT_TYPE, MAX_ROUTE_NESTING, RecordResponseHeaders, addEndMiddlewares, addStartMiddlewares, addThrownError, callerForType, capBatchBodySizes, clearBatches, createCallContext, createContextFromChain, createMionRouter, decodeQueryBody, dispatchMaybeSync, dispatchPlatformError, dispatchRoute, dispatchWithContext, endMiddlewares, errorHeaderValue, geRoutesSize, getAllExecutablesIds, getAnyExecutable, getBatch, getBatchExecutionChain, getBatchIds, getBuildVersion, getComplexity, getDefaultFetchHeaders, getDefaultHeaders, getExecutableFromMiddleware, getExecutableFromRawMiddleware, getExecutableFromRoute, getHostRequestHandler, getMaxBatchBodySize, getMaxRouteBodySize, getMethodCaller, getMiddlewareExecutable, getMiddlewaresSize, getNotFoundExecutionChain, getPlatformConfig, getPlatformMaxBodySize, getPlatformRequestCap, getPublicApi, getRequestBodyType, getResponseDefaults, getRouteEntries, getRouteExecutable, getRouteExecutionChain, getRouterFatalErrorResponse, getRouterOptions, getSerializableMethod, getTotalExecutables, handOverToHost, hasThrownError, headersFromRecord, hostOwnsSocket, isAnyMiddlewareDef, isExecutable, isHeaderExecutable, isHeadersMiddlewareDef, isMiddlewareDef, isPrivateDefinition, isPublicExecutable, isRawExecutable, isRawMiddlewareDef, isRoute, isRouteDef, isRouteExecutable, isRoutes, markResponseFailed, mionErrorsRoutes, readBatchId, readRequestBody, recordUndeclaredError, refreshBatchChainBodyLimits, registerBatches, releaseHeaders, replaceBatches, replyFetch, requestPayloadTooLarge, resetRemoteMethodsMetadata, resetRouter, resolveBatchMaxBodySize, resolveExecutionChain, serializeJitFn, serializeMethodDeps, serializePureDeps, setHostOwnsSocket, setPlatformConfig, shouldFullGenerateSpec, startMiddlewares, toRpcError };

package/.dist/esm/middlewares.d.ts

@@ -0,0 +1,3 @@
+export { mionFetchMetadata } from './src/middlewares/fetchMetadata.ts';
+export { mionSyncRoutes } from './src/middlewares/syncRoutes.ts';
+//# sourceMappingURL=middlewares.d.ts.map

package/.dist/esm/middlewares.js

@@ -0,0 +1,3 @@
+import { mionFetchMetadata } from "./src/middlewares/fetchMetadata.js";
+import { mionSyncRoutes } from "./src/middlewares/syncRoutes.js";
+export { mionFetchMetadata, mionSyncRoutes };

package/.dist/esm/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/esm/src/batches.js

@@ -0,0 +1,321 @@
+import { addThrownError, hasThrownError } from "./lib/dispatchError.js";
+import { findMionQueryParam } from "./lib/urlQuery.js";
+import { getMethodCaller } from "./dispatch.js";
+import { endMiddlewares, getPlatformRequestCap, getRouteExecutionChain, getRouterOptions, startMiddlewares } from "./router.js";
+import { FatalError, HandlerType, ROUTER_ITEM_SEPARATOR_CHAR, RpcError, StatusCodes, getInputMapper, getNoopJitFns, getOrCreateGlobal, getRoutePath, hasInputMapper, isRpcError } from "@mionjs/core";
+//#region src/batches.ts
+var batchesById = getOrCreateGlobal("mion.router.batchesById", () => /* @__PURE__ */ new Map());
+var mappingMethodCache = 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, 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 = 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 = getRouteExecutionChain(getRoutePath(routeId.split(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 = 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) => getRoutePath(routeId.split(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(startMiddlewares.map((method) => method.id));
+	const endMiddlewareIds = new Set(endMiddlewares.map((method) => method.id));
+	transformedPaths.forEach((transformedPath, index) => {
+		const chain = getRouteExecutionChain(transformedPath);
+		if (!chain) throw new FatalError({
+			statusCode: 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 = [
+		...startMiddlewares,
+		...middleMethods,
+		...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 FatalError({
+			statusCode: 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 FatalError({
+			statusCode: 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 FatalError({
+			statusCode: 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 (!hasInputMapper(mapping.mapperKey)) throw new FatalError({
+			statusCode: 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 (hasThrownError(context, executable.id)) return void 0;
+			return 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 = getNoopJitFns();
+	const method = {
+		type: 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 (isRpcError(sourceOutput) || hasThrownError(ctx, mapping.fromId)) {
+			addThrownError(ctx, mapping.toId, new RpcError({
+				statusCode: 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 = getInputMapper(mapping.mapperKey);
+		if (!pureFn) throw new FatalError({
+			statusCode: 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 FatalError({
+				statusCode: 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
+export { capBatchBodySizes, clearBatches, getBatch, getBatchExecutionChain, getBatchIds, getMaxBatchBodySize, readBatchId, refreshBatchChainBodyLimits, registerBatches, replaceBatches, resolveBatchMaxBodySize };
+
+//# sourceMappingURL=batches.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"batches.js","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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"}