@mionjs/router 0.8.0-alpha.0

package/.dist/esm/index.js

@@ -0,0 +1,145 @@
+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, getRouteEntries, getRouteExecutable, getRouteExecutableFromPath, getRouteExecutionChain, getRouterOptions, getTotalExecutables, initMionRouter, initRouter, isPrivateDefinition, isPrivateExecutable, registerRoutes, resetRouter, 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 { 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,
+  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,
+  shouldFullGenerateSpec,
+  startMiddleFns
+};
+//# sourceMappingURL=index.js.map

package/.dist/esm/index.js.map

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

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

@@ -0,0 +1,125 @@
+import { WORKFLOW_PATH } from "./constants.js";
+import { getRouteExecutionChain } from "./router.js";
+import { StatusCodes, SerializerModes, getRoutePath, MION_ROUTES, RpcError } from "@mionjs/core";
+import { getRoutesFlowExecutionChain } from "./routesFlow.js";
+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: StatusCodes.OK,
+      hasErrors: false,
+      headers: respHeaders,
+      body: {},
+      rawBody: "",
+      serializer: 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 = StatusCodes.OK;
+    resp.hasErrors = false;
+    resp.headers = respHeaders;
+    resp.body = {};
+    resp.rawBody = "";
+    resp.serializer = 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: StatusCodes.OK,
+      hasErrors: false,
+      headers: null,
+      // Will be set when context is acquired
+      body: null,
+      // Will be set when context is acquired
+      rawBody: "",
+      serializer: 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 SerializerModes.stringifyJson;
+  if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array) return SerializerModes.binary;
+  return SerializerModes.json;
+}
+function getExecutionChain(originalPath, transformedPath, urlQuery, rawRequest, opts) {
+  const hasPrefix = !!opts.basePath;
+  const isRoutesFlowPath = hasPrefix ? originalPath.endsWith(WORKFLOW_PATH) : originalPath === WORKFLOW_PATH;
+  if (isRoutesFlowPath) return getRoutesFlowExecutionChain(rawRequest, opts, urlQuery);
+  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 };
+}
+export {
+  acquireCallContext,
+  clearContextPool,
+  createCallContext,
+  getContextPoolStats,
+  releaseCallContext
+};
+//# sourceMappingURL=callContext.js.map

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

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

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

@@ -0,0 +1,45 @@
+import { getENV, PATH_SEPARATOR, MION_ROUTES } from "@mionjs/core";
+const IS_TEST_ENV = getENV("JEST_WORKER_ID") !== void 0 || 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 = `${PATH_SEPARATOR}${MION_ROUTES.notFound}`;
+const WORKFLOW_KEY = `mion-routes-flow`;
+const WORKFLOW_PATH = `${PATH_SEPARATOR}${WORKFLOW_KEY}`;
+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
+};
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","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":[],"mappings":";AAUO,MAAM,cAAc,OAAO,gBAAgB,MAAM,UAAa,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,GAAG,cAAc,GAAG,YAAY,QAAQ;AAC/D,MAAM,eAAe;AACrB,MAAM,gBAAgB,GAAG,cAAc,GAAG,YAAY;"}

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

@@ -0,0 +1,16 @@
+import { middleFn, initMionRouter } from "@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": middleFn(__assignType(() => void 0, ["", "P$/!"]))
+};
+const defaultApi = initMionRouter(routes, { skipClientRoutes: false });
+const __ΩDefaultApi = [() => defaultApi, "DefaultApi", 'i!w"y'];
+export {
+  __ΩDefaultApi,
+  defaultApi
+};
+//# sourceMappingURL=defaultRoutes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultRoutes.js","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":[],"mappings":";;;;;AA4BA,MAAM,SAAS;AAAA;AAAA,EAEX,0BAA0B,SAAQ,aAAC,MAAY,QAAS,CAAA,IAAA,MAAA,CAAA,CAAA;;AAKrD,MAAM,aAAa,eAAe,QAAQ,EAAC,kBAAkB,OAAM;;"}

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

@@ -0,0 +1,141 @@
+import { getRouterOptions } from "./router.js";
+import { HeadersSubset, HandlerType, SerializerModes, RpcError, StatusCodes } from "@mionjs/core";
+import { onExecutableError } from "./lib/dispatchError.js";
+import { acquireCallContext, releaseCallContext } from "./callContext.js";
+async function dispatchRoute(path, reqRawBody, reqHeaders, respHeaders, rawRequest, rawResponse, reqBodyType, urlQuery) {
+  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) {
+    return Promise.reject(err);
+  } finally {
+    if (usePooling) {
+      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 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) {
+      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 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 === HandlerType.rawMiddleFn) {
+    executable.methodCaller = runRawMiddleFn;
+  } else if (executable.type === 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 === 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 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, executable) {
+  if (executable.paramsJitFns.isType.isNoop) return;
+  if (!executable.paramsJitFns.isType.fn(params)) {
+    const 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, executable) {
+  if (!executable.headersParam.jitFns.isType.fn(headers)) {
+    const 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;
+  }
+}
+export {
+  dispatchRoute
+};
+//# sourceMappingURL=dispatch.js.map

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

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

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

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

package/.dist/esm/src/lib/aotCacheLoader.js

@@ -0,0 +1,13 @@
+import { jitFnsCache, pureFnsCache, routerCache } from "virtual:mion-aot/caches";
+import { addAOTCaches, addRoutesToCache } from "@mionjs/core";
+import { loadCompiledMethods } from "./methodsCache.js";
+function loadAOTCaches() {
+  addAOTCaches(jitFnsCache, pureFnsCache);
+  addRoutesToCache(routerCache);
+  loadCompiledMethods(routerCache);
+}
+loadAOTCaches.__type = ["loadAOTCaches", "P$/!"];
+export {
+  loadAOTCaches
+};
+//# sourceMappingURL=aotCacheLoader.js.map

package/.dist/esm/src/lib/aotCacheLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aotCacheLoader.js","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":[],"mappings":";;;SAYgB,gBAAa;AACzB,eAAa,aAAa,YAAY;AACtC,mBAAiB,WAAW;AAC5B,sBAAoB,WAAW;AACnC;;"}

package/.dist/esm/src/lib/aotEmitter.d.ts

@@ -0,0 +1,17 @@
+import { JitFunctionsCache, PureFunctionsCache, MethodsCache } from '@mionjs/core';
+export interface AOTCacheMessage {
+    type: 'mion-aot-caches';
+    jitFnsCode: string;
+    pureFnsCode: string;
+    routerCacheCode: string;
+}
+export interface SerializedCaches {
+    jitFnsCode: string;
+    pureFnsCode: string;
+    routerCacheCode: string;
+}
+export declare function getSerializedCaches(): Promise<SerializedCaches>;
+export declare function emitAOTCaches(): Promise<void>;
+export declare function serializeCachesToCode(jitFnsCache: JitFunctionsCache, pureFnsCache: PureFunctionsCache, routerCache: MethodsCache): Promise<SerializedCaches>;
+export declare type __ΩAOTCacheMessage = any[];
+export declare type __ΩSerializedCaches = any[];