@mionjs/router 0.8.0-alpha.0

package/.dist/cjs/index.cjs

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_context = require("./src/types/context.cjs");
+const src_types_definitions = require("./src/types/definitions.cjs");
+const src_types_remoteMethods = require("./src/types/remoteMethods.cjs");
+const src_types_general = require("./src/types/general.cjs");
+const src_types_guards = require("./src/types/guards.cjs");
+const src_types_handlers = require("./src/types/handlers.cjs");
+const src_types_publicMethods = require("./src/types/publicMethods.cjs");
+const src_constants = require("./src/constants.cjs");
+const src_router = require("./src/router.cjs");
+const src_dispatch = require("./src/dispatch.cjs");
+const src_callContext = require("./src/callContext.cjs");
+const src_lib_dispatchError = require("./src/lib/dispatchError.cjs");
+const src_lib_headers = require("./src/lib/headers.cjs");
+const src_lib_remoteMethods = require("./src/lib/remoteMethods.cjs");
+const src_lib_handlers = require("./src/lib/handlers.cjs");
+const src_lib_queryBody = require("./src/lib/queryBody.cjs");
+const src_lib_methodsCache = require("./src/lib/methodsCache.cjs");
+const src_routes_errors_routes = require("./src/routes/errors.routes.cjs");
+const src_routes_mion_routes = require("./src/routes/mion.routes.cjs");
+exports.__ΩCallContext = src_types_context.__ΩCallContext;
+exports.__ΩContextDataFactory = src_types_context.__ΩContextDataFactory;
+exports.__ΩMionHeaders = src_types_context.__ΩMionHeaders;
+exports.__ΩMionRequest = src_types_context.__ΩMionRequest;
+exports.__ΩMionResponse = src_types_context.__ΩMionResponse;
+exports.__ΩRawRequestBody = src_types_context.__ΩRawRequestBody;
+exports.__ΩRawResponseBody = src_types_context.__ΩRawResponseBody;
+exports.__ΩResponseBody = src_types_context.__ΩResponseBody;
+exports.__ΩRoutesFlowExecutionResult = src_types_context.__ΩRoutesFlowExecutionResult;
+exports.__ΩAnyHandlerDef = src_types_definitions.__ΩAnyHandlerDef;
+exports.__ΩHeadersMiddleFnDef = src_types_definitions.__ΩHeadersMiddleFnDef;
+exports.__ΩMiddleFnDef = src_types_definitions.__ΩMiddleFnDef;
+exports.__ΩRawMiddleFnDef = src_types_definitions.__ΩRawMiddleFnDef;
+exports.__ΩRouteDef = src_types_definitions.__ΩRouteDef;
+exports.__ΩHeadersMethod = src_types_remoteMethods.__ΩHeadersMethod;
+exports.__ΩHeadersMiddleFnOptions = src_types_remoteMethods.__ΩHeadersMiddleFnOptions;
+exports.__ΩMethodsExecutionChain = src_types_remoteMethods.__ΩMethodsExecutionChain;
+exports.__ΩMiddleFnMethod = src_types_remoteMethods.__ΩMiddleFnMethod;
+exports.__ΩMiddleFnOptions = src_types_remoteMethods.__ΩMiddleFnOptions;
+exports.__ΩRawMethod = src_types_remoteMethods.__ΩRawMethod;
+exports.__ΩRawMiddleFnOptions = src_types_remoteMethods.__ΩRawMiddleFnOptions;
+exports.__ΩRemoteMethod = src_types_remoteMethods.__ΩRemoteMethod;
+exports.__ΩRouteMethod = src_types_remoteMethods.__ΩRouteMethod;
+exports.__ΩRouteOptions = src_types_remoteMethods.__ΩRouteOptions;
+exports.__ΩRoute = src_types_general.__ΩRoute;
+exports.__ΩRouterEntry = src_types_general.__ΩRouterEntry;
+exports.__ΩRouterOptions = src_types_general.__ΩRouterOptions;
+exports.__ΩRoutes = src_types_general.__ΩRoutes;
+exports.isAnyMiddleFnDef = src_types_guards.isAnyMiddleFnDef;
+exports.isExecutable = src_types_guards.isExecutable;
+exports.isHeaderExecutable = src_types_guards.isHeaderExecutable;
+exports.isHeadersMiddleFnDef = src_types_guards.isHeadersMiddleFnDef;
+exports.isMiddleFnDef = src_types_guards.isMiddleFnDef;
+exports.isPublicExecutable = src_types_guards.isPublicExecutable;
+exports.isRawExecutable = src_types_guards.isRawExecutable;
+exports.isRawMiddleFnDef = src_types_guards.isRawMiddleFnDef;
+exports.isRoute = src_types_guards.isRoute;
+exports.isRouteDef = src_types_guards.isRouteDef;
+exports.isRouteExecutable = src_types_guards.isRouteExecutable;
+exports.isRoutes = src_types_guards.isRoutes;
+exports.__ΩAnyHandler = src_types_handlers.__ΩAnyHandler;
+exports.__ΩHandler = src_types_handlers.__ΩHandler;
+exports.__ΩHeaderHandler = src_types_handlers.__ΩHeaderHandler;
+exports.__ΩRawMiddleFnHandler = src_types_handlers.__ΩRawMiddleFnHandler;
+exports.__ΩMayReturnError = src_types_publicMethods.__ΩMayReturnError;
+exports.__ΩMiddleFnsCollection = src_types_publicMethods.__ΩMiddleFnsCollection;
+exports.__ΩPrivateDef = src_types_publicMethods.__ΩPrivateDef;
+exports.__ΩPrivateMiddleFnDef = src_types_publicMethods.__ΩPrivateMiddleFnDef;
+exports.__ΩPublicApi = src_types_publicMethods.__ΩPublicApi;
+exports.__ΩPublicHandler = src_types_publicMethods.__ΩPublicHandler;
+exports.__ΩPublicHeadersFn = src_types_publicMethods.__ΩPublicHeadersFn;
+exports.__ΩPublicMiddleFn = src_types_publicMethods.__ΩPublicMiddleFn;
+exports.__ΩPublicRoute = src_types_publicMethods.__ΩPublicRoute;
+exports.__ΩRemoteApi = src_types_publicMethods.__ΩRemoteApi;
+exports.DEFAULT_ROUTE_OPTIONS = src_constants.DEFAULT_ROUTE_OPTIONS;
+exports.HEADER_HOOK_DEFAULT_PARAMS = src_constants.HEADER_HOOK_DEFAULT_PARAMS;
+exports.IS_TEST_ENV = src_constants.IS_TEST_ENV;
+exports.MAX_ROUTE_NESTING = src_constants.MAX_ROUTE_NESTING;
+exports.NOT_FOUND_HOOK_NAME = src_constants.NOT_FOUND_HOOK_NAME;
+exports.NOT_FOUND_PATH = src_constants.NOT_FOUND_PATH;
+exports.ROUTE_DEFAULT_PARAMS = src_constants.ROUTE_DEFAULT_PARAMS;
+exports.WORKFLOW_KEY = src_constants.WORKFLOW_KEY;
+exports.WORKFLOW_PATH = src_constants.WORKFLOW_PATH;
+exports.addEndMiddleFns = src_router.addEndMiddleFns;
+exports.addStartMiddleFns = src_router.addStartMiddleFns;
+Object.defineProperty(exports, "endMiddleFns", {
+  enumerable: true,
+  get: () => src_router.endMiddleFns
+});
+exports.geMiddleFnsSize = src_router.geMiddleFnsSize;
+exports.geRoutesSize = src_router.geRoutesSize;
+exports.getAllExecutablesIds = src_router.getAllExecutablesIds;
+exports.getAnyExecutable = src_router.getAnyExecutable;
+exports.getComplexity = src_router.getComplexity;
+exports.getExecutableFromMiddleFn = src_router.getExecutableFromMiddleFn;
+exports.getExecutableFromRawMiddleFn = src_router.getExecutableFromRawMiddleFn;
+exports.getExecutableFromRoute = src_router.getExecutableFromRoute;
+exports.getMiddleFnExecutable = src_router.getMiddleFnExecutable;
+exports.getRouteEntries = src_router.getRouteEntries;
+exports.getRouteExecutable = src_router.getRouteExecutable;
+exports.getRouteExecutableFromPath = src_router.getRouteExecutableFromPath;
+exports.getRouteExecutionChain = src_router.getRouteExecutionChain;
+exports.getRouterOptions = src_router.getRouterOptions;
+exports.getTotalExecutables = src_router.getTotalExecutables;
+exports.initMionRouter = src_router.initMionRouter;
+exports.initRouter = src_router.initRouter;
+exports.isPrivateDefinition = src_router.isPrivateDefinition;
+exports.isPrivateExecutable = src_router.isPrivateExecutable;
+exports.registerRoutes = src_router.registerRoutes;
+exports.resetRouter = src_router.resetRouter;
+exports.shouldFullGenerateSpec = src_router.shouldFullGenerateSpec;
+Object.defineProperty(exports, "startMiddleFns", {
+  enumerable: true,
+  get: () => src_router.startMiddleFns
+});
+exports.dispatchRoute = src_dispatch.dispatchRoute;
+exports.acquireCallContext = src_callContext.acquireCallContext;
+exports.clearContextPool = src_callContext.clearContextPool;
+exports.createCallContext = src_callContext.createCallContext;
+exports.getContextPoolStats = src_callContext.getContextPoolStats;
+exports.releaseCallContext = src_callContext.releaseCallContext;
+exports.getRouterFatalErrorResponse = src_lib_dispatchError.getRouterFatalErrorResponse;
+exports.onExecutableError = src_lib_dispatchError.onExecutableError;
+exports.headersFromRecord = src_lib_headers.headersFromRecord;
+exports.getPublicApi = src_lib_remoteMethods.getPublicApi;
+exports.getSerializableMethod = src_lib_remoteMethods.getSerializableMethod;
+exports.resetRemoteMethodsMetadata = src_lib_remoteMethods.resetRemoteMethodsMetadata;
+exports.serializeJitFn = src_lib_remoteMethods.serializeJitFn;
+exports.serializeMethodDeps = src_lib_remoteMethods.serializeMethodDeps;
+exports.serializePureDeps = src_lib_remoteMethods.serializePureDeps;
+exports.headersFn = src_lib_handlers.headersFn;
+exports.middleFn = src_lib_handlers.middleFn;
+exports.mutation = src_lib_handlers.mutation;
+exports.query = src_lib_handlers.query;
+exports.rawMiddleFn = src_lib_handlers.rawMiddleFn;
+exports.route = src_lib_handlers.route;
+exports.__ΩQueryBodyResult = src_lib_queryBody.__ΩQueryBodyResult;
+exports.decodeQueryBody = src_lib_queryBody.decodeQueryBody;
+exports.addToPersistedMethods = src_lib_methodsCache.addToPersistedMethods;
+exports.getPersistedMethod = src_lib_methodsCache.getPersistedMethod;
+exports.getPersistedMethodMetadata = src_lib_methodsCache.getPersistedMethodMetadata;
+exports.getPersistedMethods = src_lib_methodsCache.getPersistedMethods;
+exports.loadCompiledMethods = src_lib_methodsCache.loadCompiledMethods;
+Object.defineProperty(exports, "persistedMethods", {
+  enumerable: true,
+  get: () => src_lib_methodsCache.persistedMethods
+});
+exports.resetPersistedMethods = src_lib_methodsCache.resetPersistedMethods;
+exports.setPersistedMethods = src_lib_methodsCache.setPersistedMethods;
+exports.mionErrorsRoutes = src_routes_errors_routes.mionErrorsRoutes;
+exports.__ΩMionRoutes = src_routes_mion_routes.__ΩMionRoutes;
+exports.mionRoutes = src_routes_mion_routes.mionRoutes;
+//# sourceMappingURL=index.cjs.map

package/.dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/cjs/index.d.ts

@@ -0,0 +1,19 @@
+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';
+export * from './src/routes/errors.routes.ts';
+export * from './src/routes/mion.routes.ts';

package/.dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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

@@ -0,0 +1,125 @@
+"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
+  };
+}
+function clearContextPool() {
+  contextPool = [];
+}
+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);
+  }
+}
+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;
+}
+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 };
+}
+exports.acquireCallContext = acquireCallContext;
+exports.clearContextPool = clearContextPool;
+exports.createCallContext = createCallContext;
+exports.getContextPoolStats = getContextPoolStats;
+exports.releaseCallContext = releaseCallContext;
+//# sourceMappingURL=callContext.cjs.map

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

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

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

@@ -0,0 +1,10 @@
+import { CallContext, MionHeaders, RawRequestBody } from './types/context.ts';
+import { RouterOptions } from './types/general.ts';
+import { SerializerCode } from '@mionjs/core';
+export declare function getContextPoolStats(): {
+    poolSize: number;
+};
+export declare function clearContextPool(): void;
+export declare function createCallContext(path: string, opts: RouterOptions, reqRawBody: RawRequestBody, rawRequest: unknown, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqBodyType?: SerializerCode, urlQuery?: string): CallContext;
+export declare function acquireCallContext(usePooling: boolean, path: string, opts: RouterOptions, reqRawBody: RawRequestBody, rawRequest: unknown, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqBodyType?: SerializerCode, urlQuery?: string): CallContext;
+export declare function releaseCallContext(ctx: CallContext, maxPoolSize: number): void;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const IS_TEST_ENV = core.getENV("JEST_WORKER_ID") !== void 0 || core.getENV("NODE_ENV") === "test";
+const ROUTE_DEFAULT_PARAMS = ["context"];
+const HEADER_HOOK_DEFAULT_PARAMS = ["context", "headers"];
+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: void 0,
+  /** 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
+};
+const MAX_ROUTE_NESTING = 10;
+const NOT_FOUND_HOOK_NAME = "_miΦn404NΦtfΦundHΦΦk_";
+const NOT_FOUND_PATH = `${core.PATH_SEPARATOR}${core.MION_ROUTES.notFound}`;
+const WORKFLOW_KEY = `mion-routes-flow`;
+const WORKFLOW_PATH = `${core.PATH_SEPARATOR}${WORKFLOW_KEY}`;
+exports.DEFAULT_ROUTE_OPTIONS = DEFAULT_ROUTE_OPTIONS;
+exports.HEADER_HOOK_DEFAULT_PARAMS = HEADER_HOOK_DEFAULT_PARAMS;
+exports.IS_TEST_ENV = IS_TEST_ENV;
+exports.MAX_ROUTE_NESTING = MAX_ROUTE_NESTING;
+exports.NOT_FOUND_HOOK_NAME = NOT_FOUND_HOOK_NAME;
+exports.NOT_FOUND_PATH = NOT_FOUND_PATH;
+exports.ROUTE_DEFAULT_PARAMS = ROUTE_DEFAULT_PARAMS;
+exports.WORKFLOW_KEY = WORKFLOW_KEY;
+exports.WORKFLOW_PATH = WORKFLOW_PATH;
+//# sourceMappingURL=constants.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.cjs","sources":["../../../src/constants.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {RouterOptions} from './types/general.ts';\nimport {getENV, MION_ROUTES, PATH_SEPARATOR} from '@mionjs/core';\n\nexport const IS_TEST_ENV = getENV('JEST_WORKER_ID') !== undefined || getENV('NODE_ENV') === 'test';\n\nexport const ROUTE_DEFAULT_PARAMS = ['context'];\nexport const HEADER_HOOK_DEFAULT_PARAMS = ['context', 'headers'];\n\nexport const DEFAULT_ROUTE_OPTIONS = {\n    /** Prefix for all routes, i.e: api/v1. Path separator is added between the prefix and the route */\n    basePath: '',\n    /** Suffix for all routes, i.e: .json. No path separator is added between the route and the suffix */\n    suffix: '',\n    /** Function that transforms the path before finding a route */\n    pathTransform: undefined,\n    /** Default serializer mode - json as default native serializer, and minimum overhead to transform just required fields */\n    serializer: 'json',\n    /** Default run type compiling options for routes and middleFns, can't be configured by the user as would break functionality  */\n    runTypeOptions: {},\n    /** set to true to generate router spec for clients.  */\n    getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === 'true',\n    /** Set true to automatically generate and id for every error.  */\n    autoGenerateErrorId: false,\n    /** client routes are initialized by default */\n    skipClientRoutes: IS_TEST_ENV,\n    /** AOT mode is disabled by default */\n    aot: false,\n    /** Context pooling size == 100 by default */\n    maxContextPoolSize: 100,\n    /** RoutesFlow cache size == 100 by default */\n    maxRoutesFlowsCacheSize: 100,\n} as Readonly<RouterOptions>;\n\nexport const MAX_ROUTE_NESTING = 10;\nexport const NOT_FOUND_HOOK_NAME = '_miΦn404NΦtfΦundHΦΦk_';\nexport const NOT_FOUND_PATH = `${PATH_SEPARATOR}${MION_ROUTES.notFound}`;\nexport const WORKFLOW_KEY = `mion-routes-flow`;\nexport const WORKFLOW_PATH = `${PATH_SEPARATOR}${WORKFLOW_KEY}`;\n"],"names":["getENV","PATH_SEPARATOR","MION_ROUTES"],"mappings":";;;AAUO,MAAM,cAAcA,KAAAA,OAAO,gBAAgB,MAAM,UAAaA,KAAAA,OAAO,UAAU,MAAM;AAErF,MAAM,uBAAuB,CAAC,SAAS;AACvC,MAAM,6BAA6B,CAAC,WAAW,SAAS;AAExD,MAAM,wBAAwB;AAAA;AAAA,EAEjC,UAAU;AAAA;AAAA,EAEV,QAAQ;AAAA;AAAA,EAER,eAAe;AAAA;AAAA,EAEf,YAAY;AAAA;AAAA,EAEZ,gBAAgB,CAAA;AAAA;AAAA,EAEhB,qBAAqB,QAAQ,IAAI,yBAAyB;AAAA;AAAA,EAE1D,qBAAqB;AAAA;AAAA,EAErB,kBAAkB;AAAA;AAAA,EAElB,KAAK;AAAA;AAAA,EAEL,oBAAoB;AAAA;AAAA,EAEpB,yBAAyB;;AAGtB,MAAM,oBAAoB;AAC1B,MAAM,sBAAsB;AAC5B,MAAM,iBAAiB,GAAGC,KAAAA,cAAc,GAAGC,KAAAA,YAAY,QAAQ;AAC/D,MAAM,eAAe;AACrB,MAAM,gBAAgB,GAAGD,mBAAc,GAAG,YAAY;;;;;;;;;;"}

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

@@ -0,0 +1,10 @@
+import { RouterOptions } from './types/general.ts';
+export declare const IS_TEST_ENV: boolean;
+export declare const ROUTE_DEFAULT_PARAMS: string[];
+export declare const HEADER_HOOK_DEFAULT_PARAMS: string[];
+export declare const DEFAULT_ROUTE_OPTIONS: Readonly<RouterOptions>;
+export declare const MAX_ROUTE_NESTING = 10;
+export declare const NOT_FOUND_HOOK_NAME = "_mi\u03A6n404N\u03A6tf\u03A6undH\u03A6\u03A6k_";
+export declare const NOT_FOUND_PATH: string;
+export declare const WORKFLOW_KEY = "mion-routes-flow";
+export declare const WORKFLOW_PATH = "/mion-routes-flow";

package/.dist/cjs/src/defaultRoutes.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const router = require("@mionjs/router");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const routes = {
+  // Only required as initMionRouter needs at least one route/middleFn
+  "mion@mionEmptyMiddleFn": router.middleFn(__assignType(() => void 0, ["", "P$/!"]))
+};
+const defaultApi = router.initMionRouter(routes, { skipClientRoutes: false });
+const __ΩDefaultApi = [() => defaultApi, "DefaultApi", 'i!w"y'];
+exports.__ΩDefaultApi = __ΩDefaultApi;
+exports.defaultApi = defaultApi;
+//# sourceMappingURL=defaultRoutes.cjs.map

package/.dist/cjs/src/defaultRoutes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultRoutes.cjs","sources":["../../../src/defaultRoutes.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\n/**\n * Default routes script for AOT cache generation.\n *\n * This script initializes the mion router with only the built-in internal routes\n * (error routes, metadata routes, etc.). It is used by the Vite plugin as a fallback\n * when no user-provided startServerScript is configured.\n *\n * When run with MION_COMPILE=true, the router's emitAOTCaches() will automatically\n * collect and send the serialized caches for these internal routes via IPC.\n *\n * Internal routes included:\n * - @thrownErrors: Error serialization route\n * - mion@notFound: Not-found handler\n * - mion@platformError: Platform error handler\n * - mion@methodsMetadataById: Remote methods metadata by ID\n * - mion@methodsMetadataByPath: Remote methods metadata by path\n */\n\nimport {middleFn, initMionRouter} from '@mionjs/router';\nimport type {Routes} from '@mionjs/router';\n\nconst routes = {\n    // Only required as initMionRouter needs at least one route/middleFn\n    'mion@mionEmptyMiddleFn': middleFn((): void => undefined),\n} satisfies Routes;\n\n// Initialize the router — this registers all internal routes and emits AOT caches\n// skipClientRoutes must be false to ensure metadata routes are included in AOT caches\nexport const defaultApi = initMionRouter(routes, {skipClientRoutes: false});\nexport type DefaultApi = typeof defaultApi;\n"],"names":["middleFn","initMionRouter"],"mappings":";;;;;;;AA4BA,MAAM,SAAS;AAAA;AAAA,EAEX,0BAA0BA,OAAAA,SAAQ,aAAC,MAAY,QAAS,CAAA,IAAA,MAAA,CAAA,CAAA;;AAKrD,MAAM,aAAaC,OAAAA,eAAe,QAAQ,EAAC,kBAAkB,OAAM;;;;"}

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

@@ -0,0 +1,3 @@
+export declare const defaultApi: any;
+export type DefaultApi = typeof defaultApi;
+export declare type __ΩDefaultApi = any[];

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_router = require("./router.cjs");
+const core = require("@mionjs/core");
+const src_lib_dispatchError = require("./lib/dispatchError.cjs");
+const src_callContext = require("./callContext.cjs");
+async function dispatchRoute(path, reqRawBody, reqHeaders, respHeaders, rawRequest, rawResponse, reqBodyType, urlQuery) {
+  const opts = src_router.getRouterOptions();
+  const usePooling = opts.maxContextPoolSize > 0;
+  const context = src_callContext.acquireCallContext(
+    usePooling,
+    path,
+    opts,
+    reqRawBody,
+    rawRequest,
+    reqHeaders,
+    respHeaders,
+    reqBodyType,
+    urlQuery
+  );
+  try {
+    await runExecutionChain(context, rawRequest, rawResponse, opts);
+    return context.response;
+  } catch (err) {
+    return Promise.reject(err);
+  } finally {
+    if (usePooling) {
+      src_callContext.releaseCallContext(context, opts.maxContextPoolSize);
+    }
+  }
+}
+async function runExecutionChain(context, rawRequest, rawResponse, opts) {
+  const { response, request } = context;
+  const executionList = context.executionChain.methods;
+  response.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);
+      const result = await methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+      if (result === void 0 || !executable.hasReturnData) continue;
+      if (executable.headersReturn && result instanceof core.HeadersSubset) {
+        const headersMap = result.headers;
+        for (const name in headersMap) {
+          const value = headersMap[name];
+          if (value !== void 0 && value !== null) {
+            response.headers.set(name, value);
+          }
+        }
+        continue;
+      }
+      response.body[executable.id] = result;
+    } catch (err) {
+      src_lib_dispatchError.onExecutableError(context, executable, err);
+    }
+  }
+  return context.response;
+}
+async function runRawMiddleFn(context, executable, req, resp, opts, rawRequest, rawResponse) {
+  const result = await executable.handler(context, rawRequest, rawResponse, opts);
+  return result;
+}
+async function runHeadersMiddleFn(context, executable, request) {
+  const headerNames = executable.headersParam.headerNames;
+  const params = deserializeBodyParamsOrThrow(request, executable);
+  const headersMap = {};
+  headerNames.forEach((name) => {
+    const value = request.headers.get(name);
+    if (value) headersMap[name] = value;
+  });
+  const headersSubset = new core.HeadersSubset(headersMap);
+  validateHeaderParamsOrThrow(headersSubset, executable);
+  if (executable.options.validateParams) validateParametersOrThrow(params, executable);
+  const result = await executable.handler(context, headersSubset, ...params);
+  return result;
+}
+async function runRouteOrMiddleFn(context, executable, request) {
+  const params = deserializeBodyParamsOrThrow(request, executable);
+  if (executable.options.validateParams) validateParametersOrThrow(params, executable);
+  const result = await executable.handler(context, ...params);
+  return result;
+}
+function getMethodCaller(executable) {
+  if (executable.type === core.HandlerType.rawMiddleFn) {
+    executable.methodCaller = runRawMiddleFn;
+  } else if (executable.type === core.HandlerType.headersMiddleFn) {
+    executable.methodCaller = runHeadersMiddleFn;
+  } else {
+    executable.methodCaller = runRouteOrMiddleFn;
+  }
+  return executable.methodCaller;
+}
+function deserializeBodyParamsOrThrow(request, executable) {
+  const params = request.body[executable.id] || [];
+  if (request.bodyType === core.SerializerModes.binary) return params;
+  if (executable.paramsJitFns.restoreFromJson.isNoop) return params;
+  try {
+    request.body[executable.id] = executable.paramsJitFns.restoreFromJson.fn(params);
+    return request.body[executable.id];
+  } catch (e) {
+    throw new core.RpcError({
+      statusCode: core.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, executable) {
+  if (executable.paramsJitFns.isType.isNoop) return;
+  if (!executable.paramsJitFns.isType.fn(params)) {
+    const validationError = new core.RpcError({
+      statusCode: core.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, executable) {
+  if (!executable.headersParam.jitFns.isType.fn(headers)) {
+    const validationError = new core.RpcError({
+      statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+      type: "validation-error",
+      publicMessage: `Invalid params in '${executable.id}', validation failed.`,
+      errorData: {
+        typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers)
+      }
+    });
+    throw validationError;
+  }
+}
+exports.dispatchRoute = dispatchRoute;
+//# sourceMappingURL=dispatch.cjs.map

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

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

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

@@ -0,0 +1,3 @@
+import { MionResponse, MionHeaders, RawRequestBody } from './types/context.ts';
+import { SerializerCode } from '@mionjs/core';
+export declare function dispatchRoute<Req, Resp>(path: string, reqRawBody: RawRequestBody, reqHeaders: MionHeaders, respHeaders: MionHeaders, rawRequest: Req, rawResponse?: Resp, reqBodyType?: SerializerCode, urlQuery?: string): Promise<MionResponse>;

package/.dist/cjs/src/lib/aotCacheLoader.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const caches = require("virtual:mion-aot/caches");
+const core = require("@mionjs/core");
+const src_lib_methodsCache = require("./methodsCache.cjs");
+function loadAOTCaches() {
+  core.addAOTCaches(caches.jitFnsCache, caches.pureFnsCache);
+  core.addRoutesToCache(caches.routerCache);
+  src_lib_methodsCache.loadCompiledMethods(caches.routerCache);
+}
+loadAOTCaches.__type = ["loadAOTCaches", "P$/!"];
+exports.loadAOTCaches = loadAOTCaches;
+//# sourceMappingURL=aotCacheLoader.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aotCacheLoader.cjs","sources":["../../../../src/lib/aotCacheLoader.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 {jitFnsCache, pureFnsCache, routerCache} from 'virtual:mion-aot/caches';\nimport {addAOTCaches, addRoutesToCache} from '@mionjs/core';\nimport {loadCompiledMethods} from './methodsCache.ts';\n\n/** Loads pre-compiled AOT caches from virtual modules and registers them in the global caches. */\nexport function loadAOTCaches(): void {\n    addAOTCaches(jitFnsCache, pureFnsCache);\n    addRoutesToCache(routerCache);\n    loadCompiledMethods(routerCache);\n}\n"],"names":["addAOTCaches","jitFnsCache","pureFnsCache","addRoutesToCache","routerCache","loadCompiledMethods"],"mappings":";;;;;SAYgB,gBAAa;AACzBA,OAAAA,aAAaC,OAAAA,aAAaC,mBAAY;AACtCC,OAAAA,iBAAiBC,OAAAA,WAAW;AAC5BC,uBAAAA,oBAAoBD,OAAAA,WAAW;AACnC;;;"}

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

@@ -0,0 +1 @@
+export declare function loadAOTCaches(): void;