@mionjs/router 0.8.7 → 0.8.10

package/.dist/esm/src/types/definitions.d.ts

@@ -18,3 +18,4 @@ export declare type __ΩMiddleFnDef = any[];
 export declare type __ΩHeadersMiddleFnDef = any[];
 export declare type __ΩRawMiddleFnDef = any[];
 export declare type __ΩAnyHandlerDef = any[];
+//# sourceMappingURL=definitions.d.ts.map

package/.dist/esm/src/types/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../../src/types/definitions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACzE,OAAO,EACH,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,WAAW,EACd,MAAM,oBAAoB,CAAC;AAM5B,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,OAAO,GAAG,GAAG,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG;IACvF,OAAO,CAAC,EAAE,YAAY,CAAC;CAC1B,CAAC;AAKF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,OAAO,GAAG,GAAG,IAAI,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG;IAC7F,OAAO,CAAC,EAAE,eAAe,CAAC;CAC7B,CAAC;AAKF,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,aAAa,GAAG,GAAG,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG;IACzG,OAAO,CAAC,EAAE,sBAAsB,CAAC;CACpC,CAAC;AAQF,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,kBAAkB,GAAG,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG;IACtG,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAChC,CAAC;AAGF,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,WAAW,GAAG,kBAAkB,GAAG,cAAc,CAAC"}

package/.dist/esm/src/types/general.d.ts

@@ -26,3 +26,4 @@ export declare type __ΩRoute = any[];
 export declare type __ΩRouterEntry = any[];
 export declare type __ΩRoutes = any[];
 export declare type __ΩRouterOptions = any[];
+//# sourceMappingURL=general.d.ts.map

package/.dist/esm/src/types/general.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../../../src/types/general.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,iBAAiB,EAAE,cAAc,EAAC,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAC,kBAAkB,EAAC,MAAM,cAAc,CAAC;AAChD,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC3F,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAItD,MAAM,MAAM,KAAK,GAAG,QAAQ,CAAC;AAG7B,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,cAAc,GAAG,kBAAkB,CAAC;AAGhG,MAAM,WAAW,MAAM;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC;CAC9B;AAKD,MAAM,WAAW,aAAa,CAAC,GAAG,GAAG,GAAG,EAAE,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAE,SAAQ,iBAAiB;IAG9G,QAAQ,EAAE,MAAM,CAAC;IAGjB,MAAM,EAAE,MAAM,CAAC;IAEf,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAEvD,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IASrD,UAAU,EAAE,cAAc,CAAC;IAE3B,cAAc,EAAE,cAAc,CAAC;IAE/B,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,mBAAmB,EAAE,OAAO,CAAC;IAE7B,mBAAmB,EAAE,OAAO,CAAC;IAE7B,gBAAgB,EAAE,OAAO,CAAC;IAQ1B,GAAG,EAAE,OAAO,CAAC;IASb,kBAAkB,EAAE,MAAM,CAAC;IAS3B,uBAAuB,EAAE,MAAM,CAAC;CACnC"}

package/.dist/esm/src/types/guards.d.ts

@@ -15,3 +15,4 @@ export declare function isRawExecutable(entry: RemoteMethod): entry is RawMethod
 export declare function isPublicExecutable(entry: RemoteMethod): entry is RemoteMethod;
 export declare function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod;
 export declare function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod;
+//# sourceMappingURL=guards.d.ts.map

package/.dist/esm/src/types/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../../src/types/guards.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC3F,OAAO,EAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAC,MAAM,cAAc,CAAC;AACxD,OAAO,EAAC,SAAS,EAAC,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAKhD,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,QAAQ,CAEhE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,WAAW,CAEtE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,cAAc,CAE5E;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,kBAAkB,CAEpF;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,kBAAkB,GAAG,WAAW,GAAG,cAAc,CAE/G;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,KAAK,CAE1D;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,KAAK,IAAI,KAAK,CAEpE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAC,GAAG,KAAK,IAAI,YAAY,CAKjG;AACD,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,IAAI,SAAS,CAEvE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,IAAI,YAAY,CAO7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,IAAI,aAAa,CAE9E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,IAAI,WAAW,CAE3E"}

package/.dist/esm/src/types/handlers.d.ts

@@ -10,3 +10,4 @@ export declare type __ΩHandler = any[];
 export declare type __ΩHeaderHandler = any[];
 export declare type __ΩRawMiddleFnHandler = any[];
 export declare type __ΩAnyHandler = any[];
+//# sourceMappingURL=handlers.d.ts.map

package/.dist/esm/src/types/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../src/types/handlers.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,aAAa,EAAC,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAC,WAAW,EAAC,MAAM,cAAc,CAAC;AACzC,OAAO,EAAC,aAAa,EAAC,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAMlD,MAAM,MAAM,OAAO,CAAC,OAAO,SAAS,WAAW,GAAG,GAAG,EAAE,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,IAAI,CAE9F,OAAO,EAAE,OAAO,EAEhB,GAAG,UAAU,EAAE,MAAM,KACpB,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAIxB,MAAM,MAAM,aAAa,CACrB,OAAO,SAAS,WAAW,GAAG,GAAG,EACjC,eAAe,SAAS,aAAa,CAAC,GAAG,CAAC,GAAG,GAAG,EAChD,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,EAC5B,GAAG,GAAG,GAAG,IACT,CAEA,OAAO,EAAE,OAAO,EAEhB,OAAO,EAAE,eAAe,EAExB,GAAG,UAAU,EAAE,MAAM,KACpB,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAGxB,MAAM,MAAM,kBAAkB,CAC1B,OAAO,SAAS,WAAW,GAAG,GAAG,EACjC,MAAM,GAAG,GAAG,EACZ,OAAO,GAAG,GAAG,EACb,IAAI,SAAS,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC,IAC1D,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,KAAK,cAAc,CAAC;AAGrF,MAAM,MAAM,UAAU,CAAC,OAAO,SAAS,WAAW,GAAG,GAAG,EAAE,MAAM,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC"}

package/.dist/esm/src/types/publicMethods.d.ts

@@ -43,3 +43,4 @@ export declare type __ΩPublicRoute = any[];
 export declare type __ΩPublicMiddleFn = any[];
 export declare type __ΩPublicHeadersFn = any[];
 export declare type __ΩPublicHandler = any[];
+//# sourceMappingURL=publicMethods.d.ts.map

package/.dist/esm/src/types/publicMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicMethods.d.ts","sourceRoot":"","sources":["../../../../src/types/publicMethods.ts"],"names":[],"mappings":"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"}

package/.dist/esm/src/types/remoteMethods.d.ts

@@ -42,3 +42,4 @@ export declare type __ΩMiddleFnOptions = any[];
 export declare type __ΩHeadersMiddleFnOptions = any[];
 export declare type __ΩRawMiddleFnOptions = any[];
 export declare type __ΩMethodsExecutionChain = any[];
+//# sourceMappingURL=remoteMethods.d.ts.map

package/.dist/esm/src/types/remoteMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteMethods.d.ts","sourceRoot":"","sources":["../../../../src/types/remoteMethods.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,uBAAuB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,cAAc,EAAC,MAAM,cAAc,CAAC;AAChI,OAAO,KAAK,EAAC,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAC,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAC,WAAW,EAAC,MAAM,cAAc,CAAC;AAGzC,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,CAAE,SAAQ,gBAAgB;IAErF,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,CAAC,CAAC;IACX,YAAY,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;CAC1C;AAED,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,OAAO,GAAG,GAAG,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IACzE,IAAI,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAC/B,OAAO,EAAE,gBAAgB,CAAC;CAC7B;AACD,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,OAAO,GAAG,GAAG,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAC5E,IAAI,EAAE,OAAO,WAAW,CAAC,QAAQ,CAAC;CACrC;AACD,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,aAAa,GAAG,GAAG,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IACjF,IAAI,EAAE,OAAO,WAAW,CAAC,eAAe,CAAC;IACzC,YAAY,EAAE,uBAAuB,CAAC;CACzC;AACD,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,kBAAkB,GAAG,GAAG,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAClF,IAAI,EAAE,OAAO,WAAW,CAAC,WAAW,CAAC;IACrC,OAAO,EAAE,gBAAgB,GAAG;QACxB,cAAc,EAAE,KAAK,CAAC;QACtB,cAAc,CAAC,EAAE,KAAK,CAAC;KAC1B,CAAC;CACL;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,CAC9B,IAAI,CACA,WAAW,CAAC,SAAS,CAAC,EACtB,aAAa,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,YAAY,GAAG,YAAY,GAAG,aAAa,CACpG,CACJ,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,CACjC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,aAAa,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,YAAY,GAAG,aAAa,CAAC,CACtH,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,OAAO,CACxC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE,aAAa,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,YAAY,GAAG,aAAa,CAAC,CACrH,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,aAAa,GAAG,YAAY,CAAC,CAAC,CAAC;AAEnG,MAAM,WAAW,qBAAqB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,YAAY,EAAE,CAAC;IAExB,UAAU,EAAE,cAAc,CAAC;CAC9B"}

package/index.ts

@@ -0,0 +1,29 @@
+/* ########
+ * 2022 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+export * from './src/types/context.ts';
+export * from './src/types/definitions.ts';
+export * from './src/types/remoteMethods.ts';
+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/constants.ts';
+export * from './src/router.ts';
+export * from './src/dispatch.ts';
+export * from './src/callContext.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/lib/queryBody.ts';
+export * from './src/lib/methodsCache.ts';
+// Note: aotEmitter.ts is NOT exported here to avoid loading it in production.
+// It is dynamically imported only when MION_COMPILE is set.
+// For multi-step route registration, use: import('@mionjs/router/src/lib/aotEmitter.ts')
+export * from './src/routes/errors.routes.ts';
+export * from './src/routes/mion.routes.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mionjs/router",
-  "version": "0.8.7",
+  "version": "0.8.10",
   "type": "module",
   "description": "Typescript RPC Like router with automatic Validation and Serialization",
   "keywords": [
@@ -37,7 +37,11 @@
     "lib": ".dist"
   },
   "files": [
-    ".dist"
+    ".dist",
+    "index.ts",
+    "src",
+    "!src/**/*.spec.ts",
+    "!src/**/*.test.ts"
   ],
   "repository": {
     "type": "git",
@@ -60,8 +64,8 @@
     "url": "https://github.com/MionKit/mion/issues"
   },
   "dependencies": {
-    "@mionjs/core": "0.8.7",
-    "@mionjs/run-types": "0.8.7"
+    "@mionjs/core": "0.8.10",
+    "@mionjs/run-types": "0.8.10"
   },
-  "gitHead": "03190d1125582fe2e37c9168f6e406a91b3c4cff"
+  "gitHead": "3e2b3b633ceb0b054fc1f1aad914d779ddd6c8b0"
 }

package/src/aot/aotCacheLoader.ts

@@ -0,0 +1,15 @@
+/* ########
+ * 2026 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {getRawAOTCaches, loadAOTCaches} from '@mionjs/core/aot-caches';
+import {loadCompiledMethods} from '../lib/methodsCache.ts';
+
+/** Loads pre-compiled AOT caches from virtual modules and registers them in the global caches. */
+export function loadRouterAOTCaches(): void {
+    loadAOTCaches();
+    loadCompiledMethods(getRawAOTCaches().routerCache);
+}

package/src/callContext.ts

@@ -0,0 +1,193 @@
+/* ########
+ * 2026 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {WORKFLOW_PATH} from './constants.ts';
+import {getRouteExecutionChain} from './router.ts';
+import type {
+    CallContext,
+    MionResponse,
+    MionRequest,
+    MionHeaders,
+    RawRequestBody,
+    RoutesFlowExecutionResult,
+} from './types/context.ts';
+import type {RouterOptions} from './types/general.ts';
+import {Mutable, StatusCodes, SerializerModes, SerializerCode, RpcError, MION_ROUTES, getRoutePath} from '@mionjs/core';
+import {getRoutesFlowExecutionChain} from './routesFlow.ts';
+
+// ############# POOL STATE #############
+
+let contextPool: CallContext[] = [];
+
+/** Get current pool statistics for monitoring */
+export function getContextPoolStats(): {poolSize: number} {
+    return {
+        poolSize: contextPool.length,
+    };
+}
+
+/** Clear the context pool - useful for testing */
+export function clearContextPool(): void {
+    contextPool = [];
+}
+
+// ############# CONTEXT CREATION #############
+
+/** Creates a new CallContext without pooling (original behavior) */
+export function createCallContext(
+    path: string,
+    opts: RouterOptions,
+    reqRawBody: RawRequestBody,
+    rawRequest: unknown,
+    reqHeaders: MionHeaders,
+    respHeaders: MionHeaders,
+    reqBodyType?: SerializerCode,
+    urlQuery?: string
+): CallContext {
+    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: undefined,
+        },
+        response: {
+            statusCode: StatusCodes.OK,
+            hasErrors: false,
+            headers: respHeaders,
+            body: {},
+            rawBody: '',
+            serializer: SerializerModes.json,
+            binSerializer: undefined,
+        },
+        executionChain,
+        shared: opts.contextDataFactory ? opts.contextDataFactory() : {},
+        urlQuery,
+        routesFlowRouteIds,
+    } as CallContext;
+}
+
+/** Acquires a CallContext from the pool or creates a new one */
+export function acquireCallContext(
+    usePooling: boolean,
+    path: string,
+    opts: RouterOptions,
+    reqRawBody: RawRequestBody,
+    rawRequest: unknown,
+    reqHeaders: MionHeaders,
+    respHeaders: MionHeaders,
+    reqBodyType?: SerializerCode,
+    urlQuery?: string
+): CallContext {
+    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) {
+        // Reuse the pooled context shell, but create fresh body objects
+        const ctx = pooledContext as Mutable<CallContext>;
+        ctx.path = transformedPath;
+        // Reset request - reuse the request object shell
+        const req = ctx.request as Mutable<MionRequest>;
+        req.headers = reqHeaders;
+        req.rawBody = reqRawBody;
+        req.bodyType = reqBodyType ?? getRequestBodyType(reqRawBody);
+        req.body = {}; // Must be fresh - handlers write to this
+        req.thrownErrors = undefined;
+        // Reset response - reuse the response object shell
+        const resp = ctx.response as Mutable<MionResponse>;
+        resp.statusCode = StatusCodes.OK;
+        resp.hasErrors = false;
+        resp.headers = respHeaders;
+        resp.body = {}; // Must be fresh - handlers write to this
+        resp.rawBody = '';
+        resp.serializer = SerializerModes.json;
+        resp.binSerializer = undefined;
+        // Reset execution chain and routesFlow route IDs
+        const {executionChain, routesFlowRouteIds} = getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);
+        ctx.executionChain = executionChain;
+        ctx.routesFlowRouteIds = routesFlowRouteIds;
+        // Reset shared data
+        ctx.shared = opts.contextDataFactory ? opts.contextDataFactory() : {};
+        // Reset urlQuery
+        ctx.urlQuery = urlQuery;
+        return ctx;
+    }
+    // No pooled context available, create new one
+    return createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery);
+}
+
+/** Releases a CallContext back to the pool for reuse */
+export function releaseCallContext(ctx: CallContext, maxPoolSize: number): void {
+    if (contextPool.length < maxPoolSize) {
+        const mutableCtx = ctx as Mutable<CallContext>;
+        const req = mutableCtx.request as Mutable<MionRequest>;
+        // Clear request data - safe to mutate since request is not returned to caller
+        req.rawBody = '';
+        req.body = null as any; // Will be set when context is acquired
+        req.thrownErrors = undefined;
+        // Create fresh response object - the old one may still be referenced by the caller
+        // IMPORTANT: We must NOT mutate the existing response object because it's returned
+        // to the platform wrapper (e.g., HTTP handler) which may still be using it
+        mutableCtx.response = {
+            statusCode: StatusCodes.OK,
+            hasErrors: false,
+            headers: null as any, // Will be set when context is acquired
+            body: null as any, // Will be set when context is acquired
+            rawBody: '',
+            serializer: SerializerModes.json,
+            binSerializer: undefined,
+        };
+        mutableCtx.shared = null as any;
+        mutableCtx.executionChain = null as any;
+        mutableCtx.routesFlowRouteIds = undefined;
+        contextPool.push(ctx);
+    }
+    // If pool is full, let the context be garbage collected
+}
+
+// ############# HELPER FUNCTIONS #############
+
+function getRequestBodyType(rawBody: RawRequestBody): SerializerCode {
+    if (typeof rawBody === 'string') return SerializerModes.stringifyJson;
+    if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array) return SerializerModes.binary;
+    return SerializerModes.json;
+}
+
+/** Gets the execution chain for a path, handling routesFlow paths specially */
+function getExecutionChain(
+    originalPath: string,
+    transformedPath: string,
+    urlQuery: string | undefined,
+    rawRequest: unknown,
+    opts: RouterOptions
+): RoutesFlowExecutionResult {
+    const hasPrefix = !!opts.basePath;
+    // Handle routesFlow path - check if the original path ends with the workflow key
+    // This works with any prefix (e.g., /mion-routes-flow, /api/v1/mion-routes-flow)
+    const isRoutesFlowPath = hasPrefix ? originalPath.endsWith(WORKFLOW_PATH) : originalPath === WORKFLOW_PATH;
+    if (isRoutesFlowPath) return getRoutesFlowExecutionChain(rawRequest, opts, urlQuery);
+
+    // Normal path - get execution chain from router using transformed path
+    let executionChain = getRouteExecutionChain(transformedPath);
+    if (!executionChain) {
+        const notFoundPath = getRoutePath([MION_ROUTES.notFound], opts);
+        executionChain = getRouteExecutionChain(notFoundPath);
+        if (!executionChain) {
+            throw new RpcError({
+                statusCode: StatusCodes.UNEXPECTED_ERROR,
+                type: 'not-found',
+                publicMessage: 'Not-found route is not registered. This should never happen.',
+            });
+        }
+    }
+    return {executionChain};
+}

package/src/constants.ts

@@ -0,0 +1,45 @@
+/* ########
+ * 2022 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {RouterOptions} from './types/general.ts';
+import {getENV, MION_ROUTES, PATH_SEPARATOR} from '@mionjs/core';
+
+export const IS_TEST_ENV = getENV('JEST_WORKER_ID') !== undefined || getENV('NODE_ENV') === 'test';
+
+export const ROUTE_DEFAULT_PARAMS = ['context'];
+export const HEADER_HOOK_DEFAULT_PARAMS = ['context', 'headers'];
+
+export const DEFAULT_ROUTE_OPTIONS = {
+    /** Prefix for all routes, i.e: api/v1. Path separator is added between the prefix and the route */
+    basePath: '',
+    /** Suffix for all routes, i.e: .json. No path separator is added between the route and the suffix */
+    suffix: '',
+    /** Function that transforms the path before finding a route */
+    pathTransform: undefined,
+    /** Default serializer mode - json as default native serializer, and minimum overhead to transform just required fields */
+    serializer: 'json',
+    /** Default run type compiling options for routes and middleFns, can't be configured by the user as would break functionality  */
+    runTypeOptions: {},
+    /** set to true to generate router spec for clients.  */
+    getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === 'true',
+    /** Set true to automatically generate and id for every error.  */
+    autoGenerateErrorId: false,
+    /** client routes are initialized by default */
+    skipClientRoutes: IS_TEST_ENV,
+    /** AOT mode is disabled by default */
+    aot: false,
+    /** Context pooling size == 100 by default */
+    maxContextPoolSize: 100,
+    /** RoutesFlow cache size == 100 by default */
+    maxRoutesFlowsCacheSize: 100,
+} as Readonly<RouterOptions>;
+
+export const MAX_ROUTE_NESTING = 10;
+export const NOT_FOUND_HOOK_NAME = '_miΦn404NΦtfΦundHΦΦk_';
+export const NOT_FOUND_PATH = `${PATH_SEPARATOR}${MION_ROUTES.notFound}`;
+export const WORKFLOW_KEY = `mion-routes-flow`;
+export const WORKFLOW_PATH = `${PATH_SEPARATOR}${WORKFLOW_KEY}`;

package/src/defaultRoutes.ts

@@ -0,0 +1,37 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+/**
+ * Default routes script for AOT cache generation.
+ *
+ * This script initializes the mion router with only the built-in internal routes
+ * (error routes, metadata routes, etc.). It is used by the Vite plugin as a fallback
+ * when no user-provided startScript is configured.
+ *
+ * When run with MION_COMPILE=buildOnly, the router's emitAOTCaches() will automatically
+ * collect and send the serialized caches for these internal routes via IPC.
+ *
+ * Internal routes included:
+ * - @thrownErrors: Error serialization route
+ * - mion@notFound: Not-found handler
+ * - mion@platformError: Platform error handler
+ * - mion@methodsMetadataById: Remote methods metadata by ID
+ * - mion@methodsMetadata: Methods metadata middleware (returns metadata alongside any route response)
+ */
+
+import {middleFn, initMionRouter} from '@mionjs/router';
+import type {Routes} from '@mionjs/router';
+
+const routes = {
+    // Only required as initMionRouter needs at least one route/middleFn
+    'mion@mionEmptyMiddleFn': middleFn((): void => undefined),
+} satisfies Routes;
+
+// Initialize the router — this registers all internal routes and emits AOT caches
+// skipClientRoutes must be false to ensure metadata routes are included in AOT caches
+export const defaultApi = initMionRouter(routes, {skipClientRoutes: false});
+export type DefaultApi = typeof defaultApi;

package/src/dispatch.ts

@@ -0,0 +1,204 @@
+/* ########
+ * 2022 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {CallContext, MionResponse, MionRequest, MionHeaders, RawRequestBody} from './types/context.ts';
+import {type RouterOptions} from './types/general.ts';
+import {HeadersMethod, RemoteMethod, RawMethod} from './types/remoteMethods.ts';
+import {getRouterOptions} from './router.ts';
+import {Mutable, AnyObject, StatusCodes, HeadersSubset, SerializerModes, SerializerCode} from '@mionjs/core';
+import {RpcError, HandlerType, ValidationError} from '@mionjs/core';
+import {onExecutableError} from './lib/dispatchError.ts';
+import {acquireCallContext, releaseCallContext} from './callContext.ts';
+
+/*
+ * PERFORMANCE PROFILING NOTE:
+ * different options has been tested to improve performance but were discarded due to worst or no noticeable improvements
+ * - using promisify(setImmediate): worst or no improvement
+ * - using queueMicrotask instead of setImmediate: definitely worst
+ * - using callback instead promises: seems to be more slow but use less memory in some scenarios.
+ */
+
+// ############# PUBLIC METHODS #############
+
+export async function dispatchRoute<Req, Resp>(
+    path: string,
+    reqRawBody: RawRequestBody,
+    reqHeaders: MionHeaders,
+    respHeaders: MionHeaders,
+    rawRequest: Req,
+    rawResponse?: Resp,
+    reqBodyType?: SerializerCode,
+    urlQuery?: string
+): Promise<MionResponse> {
+    const opts = getRouterOptions();
+    const usePooling = opts.maxContextPoolSize > 0;
+    const context = acquireCallContext(
+        usePooling,
+        path,
+        opts,
+        reqRawBody,
+        rawRequest,
+        reqHeaders,
+        respHeaders,
+        reqBodyType,
+        urlQuery
+    );
+
+    try {
+        await runExecutionChain(context, rawRequest, rawResponse, opts);
+        return context.response;
+    } catch (err: any | RpcError<string> | Error) {
+        // this should never happen, exceptions should be handled inside runExecutionChain
+        return Promise.reject(err);
+    } finally {
+        // Release context back to pool if pooling is enabled
+        if (usePooling) {
+            releaseCallContext(context, opts.maxContextPoolSize);
+        }
+    }
+}
+
+// ############# PRIVATE METHODS #############
+
+// runs the ExecutionChain of a route
+async function runExecutionChain(
+    context: CallContext,
+    rawRequest: unknown,
+    rawResponse: unknown,
+    opts: RouterOptions
+): Promise<MionResponse> {
+    const {response, request} = context;
+    const executionList = context.executionChain.methods;
+    (response as Mutable<MionResponse>).serializer = context.executionChain.serializer;
+    for (let i = 0; i < executionList.length; i++) {
+        const executable = executionList[i];
+        if (response.hasErrors && !executable.options.runOnError) continue;
+
+        try {
+            const methodCaller = executable.methodCaller || getMethodCaller(executable);
+            // runRawMiddleFn , runHeadersMiddleFn & runRouteOrMiddleFn must always accept the same parameters in the same order
+            const result = await methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+
+            if (result === undefined || !executable.hasReturnData) continue;
+            if (executable.headersReturn && result instanceof HeadersSubset) {
+                const headersMap = result.headers;
+                for (const name in headersMap) {
+                    const value = headersMap[name];
+                    if (value !== undefined && value !== null) {
+                        response.headers.set(name, value);
+                    }
+                }
+                continue;
+            }
+            (response.body as Mutable<AnyObject>)[executable.id] = result;
+        } catch (err: any | RpcError<string> | Error) {
+            // All thrown errors are unexpected
+            onExecutableError(context, executable, err);
+        }
+    }
+    return context.response;
+}
+
+async function runRawMiddleFn(
+    context: CallContext,
+    executable: RawMethod,
+    req,
+    resp,
+    opts: RouterOptions,
+    rawRequest: unknown,
+    rawResponse: unknown
+) {
+    const result = await executable.handler(context, rawRequest, rawResponse, opts);
+    return result;
+}
+
+async function runHeadersMiddleFn(context: CallContext, executable: HeadersMethod, request: MionRequest) {
+    const headerNames = executable.headersParam.headerNames;
+    const params = deserializeBodyParamsOrThrow(request, executable as RemoteMethod);
+    const headersMap: Record<string, string> = {};
+    headerNames.forEach((name) => {
+        const value = request.headers.get(name);
+        if (value) headersMap[name] = value;
+    });
+    const headersSubset = new HeadersSubset(headersMap);
+    validateHeaderParamsOrThrow(headersSubset, executable as HeadersMethod);
+    if (executable.options.validateParams) validateParametersOrThrow(params, executable as HeadersMethod);
+
+    const result = await executable.handler(context, headersSubset, ...params);
+    return result;
+}
+
+async function runRouteOrMiddleFn(context: CallContext, executable: HeadersMethod, request: MionRequest) {
+    const params = deserializeBodyParamsOrThrow(request, executable as RemoteMethod);
+    if (executable.options.validateParams) validateParametersOrThrow(params, executable as RemoteMethod);
+    const result = await executable.handler(context, ...params);
+    return result;
+}
+
+function getMethodCaller(executable: RemoteMethod) {
+    if (executable.type === HandlerType.rawMiddleFn) {
+        executable.methodCaller = runRawMiddleFn;
+    } else if (executable.type === HandlerType.headersMiddleFn) {
+        executable.methodCaller = runHeadersMiddleFn;
+    } else {
+        executable.methodCaller = runRouteOrMiddleFn;
+    }
+    return executable.methodCaller;
+}
+
+function deserializeBodyParamsOrThrow(request: MionRequest, executable: RemoteMethod): any[] {
+    const params: any[] = (request.body[executable.id] as any[]) || [];
+    // For binary requests, params are already deserialized in the serializer middleFn
+    // (deserializeBinaryRequestBody in serializer.routes.ts)
+    if (request.bodyType === SerializerModes.binary) return params;
+
+    // For JSON requests, use restoreFromJson to deserialize
+    if (executable.paramsJitFns.restoreFromJson.isNoop) return params;
+    try {
+        (request.body as Mutable<MionRequest['body']>)[executable.id] = executable.paramsJitFns.restoreFromJson.fn(params);
+        return request.body[executable.id] as any[];
+    } catch (e: any) {
+        throw new RpcError({
+            statusCode: StatusCodes.UNEXPECTED_ERROR,
+            type: 'serialization-error',
+            publicMessage: `Invalid params '${executable.id}', can not deserialize. Parameters might be of the wrong type.`,
+            originalError: e,
+            errorData: {
+                deserializeError: e?.message || 'Unknown error',
+            },
+        });
+    }
+}
+
+function validateParametersOrThrow(params: any[], executable: RemoteMethod): void {
+    if (executable.paramsJitFns.isType.isNoop) return;
+    if (!executable.paramsJitFns.isType.fn(params)) {
+        const validationError: ValidationError = new RpcError({
+            statusCode: StatusCodes.UNEXPECTED_ERROR,
+            type: 'validation-error',
+            publicMessage: `Invalid params in '${executable.id}', validation failed.`,
+            errorData: {
+                typeErrors: executable.paramsJitFns.typeErrors.fn(params),
+            },
+        });
+        throw validationError;
+    }
+}
+
+function validateHeaderParamsOrThrow(headers: HeadersSubset<string, string>, executable: HeadersMethod): void {
+    if (!executable.headersParam.jitFns.isType.fn(headers)) {
+        const validationError: ValidationError = new RpcError({
+            statusCode: StatusCodes.UNEXPECTED_ERROR,
+            type: 'validation-error',
+            publicMessage: `Invalid params in '${executable.id}', validation failed.`,
+            errorData: {
+                typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers),
+            },
+        });
+        throw validationError;
+    }
+}