@mionjs/router 0.8.4-alpha.0 → 0.8.6

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

@@ -1,8 +1,9 @@
 import { __ΩHandler as ___Handler } from "../types/handlers.js";
 import { __ΩRouterOptions as ___RouterOptions } from "../types/general.js";
-import { DEFAULT_ROUTE_OPTIONS, HEADER_HOOK_DEFAULT_PARAMS, ROUTE_DEFAULT_PARAMS } from "../constants.js";
-import { getJitFunctionsFromHash, EMPTY_HASH, getNoopJitFns, HeadersSubset } from "@mionjs/core";
+import { HEADER_HOOK_DEFAULT_PARAMS, ROUTE_DEFAULT_PARAMS, DEFAULT_ROUTE_OPTIONS } from "../constants.js";
+import { HandlerType, EMPTY_HASH, getJitFunctionsFromHash, getNoopJitFns, HeadersSubset } from "@mionjs/core";
 import { getPersistedMethodMetadata } from "./methodsCache.js";
+import { __ΩRouteOptions as ___RouteOptions, __ΩMiddleFnOptions as ___MiddleFnOptions, __ΩHeadersMiddleFnOptions as ___HeadersMiddleFnOptions, __ΩMiddleFnMethod as ___MiddleFnMethod, __ΩHeadersMethod as ___HeadersMethod } from "../types/remoteMethods.js";
 const __ΩOmit = ["T", "K", () => __ΩPick, () => __ΩExclude, "Omit", 'b!b"e!!e!!ge!"o$#o##w%y'];
 const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
 const __ΩExclude = ["T", "U", "Exclude", 'l6!Re$!RPe#!e$"qk#%QRb!b"Pde"!p)w#y'];
@@ -102,16 +103,16 @@ function extractReflectionFromCached(cached) {
   return reflectionItems;
 }
 extractReflectionFromCached.__type = [() => __ΩCachedMethodMetadata, "cached", () => __ΩMethodReflect, "extractReflectionFromCached", 'Pn!2"n#/$'];
-async function getHandlerReflection(handler, routeId, routerOptions, isHeadersMiddleFn = false, methodStrictTypes) {
+async function getHandlerReflection(handler, routeId, routerOptions, handlerOptions = {}, isHeadersMiddleFn = false, methodStrictTypes) {
   const cached = getPersistedMethodMetadata(routeId);
   if (cached)
     return extractReflectionFromCached(cached);
   if (routerOptions.aot)
     throw new AOTCacheError(routeId, isHeadersMiddleFn ? "middleFn" : "route");
   const rt = await loadRunTypesModule();
-  return generateHandlerReflection(handler, routeId, routerOptions, isHeadersMiddleFn, rt, methodStrictTypes);
+  return generateHandlerReflection(handler, routeId, routerOptions, handlerOptions, isHeadersMiddleFn, rt, methodStrictTypes);
 }
-getHandlerReflection.__type = [() => ___Handler, "handler", "routeId", () => ___RouterOptions, "routerOptions", "isHeadersMiddleFn", () => false, "methodStrictTypes", () => __ΩMethodReflect, "getHandlerReflection", "Pn!2\"&2#n$2%)2&>')2(8n)`/*"];
+getHandlerReflection.__type = [() => ___Handler, "handler", "routeId", () => ___RouterOptions, "routerOptions", () => ___RouteOptions, () => ___MiddleFnOptions, () => ___HeadersMiddleFnOptions, "handlerOptions", () => ({}), "isHeadersMiddleFn", () => false, "methodStrictTypes", () => __ΩMethodReflect, "getHandlerReflection", "Pn!2\"&2#n$2%Pn&n'n(J2)>*)2+>,)2-8n.`//"];
 async function getRawMethodReflection(handler, routeId, routerOptions) {
   const cached = getPersistedMethodMetadata(routeId);
   if (cached)
@@ -122,9 +123,10 @@ async function getRawMethodReflection(handler, routeId, routerOptions) {
   return generateRawMethodReflection(handler, routeId, rt);
 }
 getRawMethodReflection.__type = [() => ___Handler, "handler", "routeId", () => ___RouterOptions, "routerOptions", () => __ΩMethodReflect, "getRawMethodReflection", "Pn!2\"&2#n$2%n&`/'"];
-function generateHandlerReflection(handler, routeId, routerOptions, isHeadersMiddleFn, rt, methodStrictTypes) {
+function generateHandlerReflection(handler, routeId, routerOptions, handlerOptions, isHeadersMiddleFn, rt, methodStrictTypes) {
   const reflectionItems = {};
   let handlerRunType;
+  const needsBinary = (handlerOptions?.serializer ?? routerOptions.serializer) === "binary";
   const effectiveStrictTypes = methodStrictTypes ?? routerOptions.strictTypes;
   const runTypeOptions = {
     ...routerOptions?.runTypeOptions || DEFAULT_ROUTE_OPTIONS.runTypeOptions,
@@ -143,7 +145,7 @@ function generateHandlerReflection(handler, routeId, routerOptions, isHeadersMid
       reflectionItems.paramsJitHash = EMPTY_HASH;
       reflectionItems.paramsJitFns = getNoopJitFns();
     } else {
-      reflectionItems.paramsJitFns = getFunctionJitFns(handler, paramsOpts, rt, false);
+      reflectionItems.paramsJitFns = getFunctionJitFns(handler, paramsOpts, rt, false, needsBinary);
       reflectionItems.paramsJitHash = handlerRunType.getParameters().getJitHash(paramsOpts);
     }
   } catch (error) {
@@ -157,7 +159,7 @@ function generateHandlerReflection(handler, routeId, routerOptions, isHeadersMid
         ...runTypeOptions,
         paramsSlice: void 0
       };
-      const jitFns = getTypeJitFunctions(headersRunType, opts, rt);
+      const jitFns = getTypeJitFunctions(headersRunType, opts, rt, false);
       const jitHash = headersRunType.getJitHash(opts);
       reflectionItems.headersParam = { headerNames, jitFns, jitHash };
     } catch (error) {
@@ -168,7 +170,7 @@ function generateHandlerReflection(handler, routeId, routerOptions, isHeadersMid
   if (returnHeadersRunType) {
     const opts = {};
     const headerNames = getHeaderNames(returnHeadersRunType, routeId, rt);
-    const jitFns = getFunctionJitFns(handler, opts, rt, true);
+    const jitFns = getFunctionJitFns(handler, opts, rt, true, false);
     const jitHash = returnHeadersRunType.getJitHash(opts);
     reflectionItems.headersReturn = { headerNames, jitFns, jitHash };
   }
@@ -179,8 +181,8 @@ function generateHandlerReflection(handler, routeId, routerOptions, isHeadersMid
       reflectionItems.returnJitFns = getNoopJitFns();
       reflectionItems.returnJitHash = EMPTY_HASH;
     } else {
-      reflectionItems.returnJitFns = getFunctionJitFns(handler, returnOpts, rt, true);
-      reflectionItems.returnJitHash = handlerRunType.getReturnType().getJitHash(returnOpts);
+      reflectionItems.returnJitFns = getFunctionJitFns(handler, returnOpts, rt, true, needsBinary);
+      reflectionItems.returnJitHash = handlerRunType.getResolvedReturnType().getJitHash(returnOpts);
     }
   } catch (error) {
     throw new Error(`Can not get Jit Functions for Return of route/middleFn "${routeId}." Error: ${error?.message}`);
@@ -188,7 +190,7 @@ function generateHandlerReflection(handler, routeId, routerOptions, isHeadersMid
   reflectionItems.isAsync = handlerRunType.isAsync();
   return reflectionItems;
 }
-generateHandlerReflection.__type = [() => ___Handler, "handler", "routeId", () => ___RouterOptions, "routerOptions", "isHeadersMiddleFn", () => __ΩRunTypesFunctions, "rt", "methodStrictTypes", () => __ΩMethodReflect, "generateHandlerReflection", `Pn!2"&2#n$2%)2&n'2()2)8n*/+`];
+generateHandlerReflection.__type = [() => ___Handler, "handler", "routeId", () => ___RouterOptions, "routerOptions", () => ___RouteOptions, () => ___MiddleFnOptions, () => ___HeadersMiddleFnOptions, "handlerOptions", "isHeadersMiddleFn", () => __ΩRunTypesFunctions, "rt", "methodStrictTypes", () => __ΩMethodReflect, "generateHandlerReflection", `Pn!2"&2#n$2%Pn&n'n(J2))2*n+2,)2-8n.//`];
 function generateRawMethodReflection(handler, routeId, rt) {
   let handlerRunType;
   try {
@@ -281,21 +283,23 @@ function getFakeCompiler(routerOptions) {
   return { opts: routerOptions };
 }
 getFakeCompiler.__type = [() => ___RouterOptions, "routerOptions", "JitFnCompiler", "getFakeCompiler", 'Pn!2""w#/$'];
-function getTypeJitFunctions(runType, opts, rtModule) {
+function getTypeJitFunctions(runType, opts, rtModule, needsBinary = false) {
   const jitFns = {
     isType: runType.createJitCompiledFunction(rtModule.JitFunctions.isType.id, void 0, opts),
     typeErrors: runType.createJitCompiledFunction(rtModule.JitFunctions.typeErrors.id, void 0, opts),
     prepareForJson: runType.createJitCompiledFunction(rtModule.JitFunctions.prepareForJson.id, void 0, opts),
     restoreFromJson: runType.createJitCompiledFunction(rtModule.JitFunctions.restoreFromJson.id, void 0, opts),
     stringifyJson: runType.createJitCompiledFunction(rtModule.JitFunctions.stringifyJson.id, void 0, opts),
-    toBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.toBinary.id, void 0, opts),
-    fromBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.fromBinary.id, void 0, opts)
+    ...needsBinary ? {
+      toBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.toBinary.id, void 0, opts),
+      fromBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.fromBinary.id, void 0, opts)
+    } : {}
   };
   return jitFns;
 }
-getTypeJitFunctions.__type = ["BaseRunType", "runType", "RunTypeOptions", "opts", () => __ΩRunTypesFunctions, "rtModule", "JitCompiledFunctions", "getTypeJitFunctions", `P"w!2"P"w#-J2$n%2&"w'/(`];
+getTypeJitFunctions.__type = ["BaseRunType", "runType", "RunTypeOptions", "opts", () => __ΩRunTypesFunctions, "rtModule", "needsBinary", () => false, "JitCompiledFunctions", "getTypeJitFunctions", `P"w!2"P"w#-J2$n%2&)2'>("w)/*`];
 const functionRunTypeCache = (WeakMap.Ω = [["AnyFn", '"w!'], ["FunctionRunType", '"w!']], /* @__PURE__ */ new WeakMap());
-function getFunctionJitFns(fn, opts, rtModule, isReturn) {
+function getFunctionJitFns(fn, opts, rtModule, isReturn, needsBinary = false) {
   let runType = functionRunTypeCache.get(fn);
   if (!runType) {
     runType = rtModule.reflectFunction(fn);
@@ -308,14 +312,38 @@ function getFunctionJitFns(fn, opts, rtModule, isReturn) {
     prepareForJson: createFn(rtModule.JitFunctions.prepareForJson, opts),
     restoreFromJson: createFn(rtModule.JitFunctions.restoreFromJson, opts),
     stringifyJson: createFn(rtModule.JitFunctions.stringifyJson, opts),
-    toBinary: createFn(rtModule.JitFunctions.toBinary, opts),
-    fromBinary: createFn(rtModule.JitFunctions.fromBinary, opts)
+    ...needsBinary ? {
+      toBinary: createFn(rtModule.JitFunctions.toBinary, opts),
+      fromBinary: createFn(rtModule.JitFunctions.fromBinary, opts)
+    } : {}
   };
   return jitFunctions;
 }
-getFunctionJitFns.__type = ["fn", "RunTypeOptions", "opts", () => __ΩRunTypesFunctions, "rtModule", "isReturn", "JitCompiledFunctions", "getFunctionJitFns", `P"2!P"w"-J2#n$2%)2&"w'/(`];
+getFunctionJitFns.__type = ["fn", "RunTypeOptions", "opts", () => __ΩRunTypesFunctions, "rtModule", "isReturn", "needsBinary", () => false, "JitCompiledFunctions", "getFunctionJitFns", `P"2!P"w"-J2#n$2%)2&)2'>("w)/*`];
+async function ensureBinaryJitFns(method) {
+  if (method.paramsJitFns.toBinary && method.returnJitFns.toBinary)
+    return;
+  const rt = await loadRunTypesModule();
+  const isHeader = method.type === HandlerType.headersMiddleFn;
+  const paramsSlice = isHeader ? { start: HEADER_HOOK_DEFAULT_PARAMS.length } : { start: ROUTE_DEFAULT_PARAMS.length };
+  const opts = { paramsSlice };
+  if (!method.paramsJitFns.toBinary && method.paramsJitHash !== EMPTY_HASH) {
+    const runType = rt.reflectFunction(method.handler);
+    const createFn = runType.createJitCompiledParamsFunction.bind(runType);
+    method.paramsJitFns.toBinary = createFn(rt.JitFunctions.toBinary, opts);
+    method.paramsJitFns.fromBinary = createFn(rt.JitFunctions.fromBinary, opts);
+  }
+  if (!method.returnJitFns.toBinary && method.returnJitHash !== EMPTY_HASH && method.hasReturnData) {
+    const runType = rt.reflectFunction(method.handler);
+    const createFn = runType.createJitCompiledReturnFunction.bind(runType);
+    method.returnJitFns.toBinary = createFn(rt.JitFunctions.toBinary);
+    method.returnJitFns.fromBinary = createFn(rt.JitFunctions.fromBinary);
+  }
+}
+ensureBinaryJitFns.__type = [() => ___MiddleFnMethod, () => ___HeadersMethod, "method", "ensureBinaryJitFns", 'PPn!n"J2#$`/$'];
 export {
   AOTCacheError,
+  ensureBinaryJitFns,
   getHandlerReflection,
   getRawMethodReflection,
   resetReflectionCaches,

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

@@ -1 +1 @@
-{"version":3,"file":"reflection.js","sources":["../../../../src/lib/reflection.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {MethodWithJitFns, AnyFn, JitCompiledFunctions, MethodMetadata} from '@mionjs/core';\n// Type-only imports from run-types - these don't load the module at runtime\nimport type {FunctionRunType, BaseRunType, MemberRunType, RunTypeOptions, JitFnCompiler} from '@mionjs/run-types';\nimport {Handler} from '../types/handlers.ts';\nimport {RouterOptions} from '../types/general.ts';\nimport {DEFAULT_ROUTE_OPTIONS, HEADER_HOOK_DEFAULT_PARAMS, ROUTE_DEFAULT_PARAMS} from '../constants.ts';\nimport {EMPTY_HASH, HeadersSubset, getJitFunctionsFromHash, getNoopJitFns} from '@mionjs/core';\nimport {getPersistedMethodMetadata} from './methodsCache.ts';\n\n// ############ This file is the only one importing '@mionjs/run-types' within the router ########\n// In AOT mode, run-types is NOT loaded - all reflection data comes from the AOT cache\n\ntype MethodReflect = Omit<MethodWithJitFns, 'id' | 'type' | 'nestLevel' | 'pointer' | 'options'>;\n\n// ############ AOT Cache Error ############\n\n/**\n * Error thrown when AOT mode is enabled but required data is missing from the AOT cache.\n * This indicates that the AOT caches need to be regenerated using 'mion-build-aot' command.\n */\nexport class AOTCacheError extends Error {\n    constructor(routeId: string, type: 'route' | 'middleFn' | 'rawMiddleFn' = 'route') {\n        const typeLabel = type === 'rawMiddleFn' ? 'Raw middleFn' : type === 'middleFn' ? 'MiddleFn' : 'Route/middleFn';\n        super(`${typeLabel} \"${routeId}\" not found in AOT cache.\\n` + `Regenerate AOT caches using 'mion-build-aot' command.`);\n        this.name = 'AOTCacheError';\n    }\n}\n\n// ############ Run-Types Module Loading ############\ntype RunTypesModule = typeof import('@mionjs/run-types');\n// Type definition for the dynamically imported run-types module\ninterface RunTypesFunctions {\n    JitFunctions: RunTypesModule['JitFunctions'];\n    reflectFunction: RunTypesModule['reflectFunction'];\n    isUnionRunType: RunTypesModule['isUnionRunType'];\n    isClassRunType: RunTypesModule['isClassRunType'];\n    isLiteralRunType: RunTypesModule['isLiteralRunType'];\n    isNeverRunType: RunTypesModule['isNeverRunType'];\n}\n\n// Cached run-types module - loaded once and reused\nlet runTypesModule: RunTypesFunctions | null = null;\nlet runTypesLoadPromise: Promise<RunTypesFunctions> | null = null;\n\n/** Dynamically loads the @mionjs/run-types module. The module is cached after first load. */\nasync function loadRunTypesModule(): Promise<RunTypesFunctions> {\n    // Return cached module if already loaded\n    if (runTypesModule) return runTypesModule;\n\n    // Return existing promise if load is in progress\n    if (runTypesLoadPromise) return runTypesLoadPromise;\n\n    // Start loading the module\n    runTypesLoadPromise = import('@mionjs/run-types').then((module) => {\n        runTypesModule = {\n            JitFunctions: module.JitFunctions,\n            reflectFunction: module.reflectFunction,\n            isUnionRunType: module.isUnionRunType,\n            isClassRunType: module.isClassRunType,\n            isLiteralRunType: module.isLiteralRunType,\n            isNeverRunType: module.isNeverRunType,\n        };\n        return runTypesModule;\n    });\n\n    return runTypesLoadPromise;\n}\n\n/** Resets the run-types module cache. Useful for testing purposes only. */\nexport function resetRunTypesCache(): void {\n    runTypesModule = null;\n    runTypesLoadPromise = null;\n}\n\n/** Resets all reflection caches. Useful for testing purposes only. */\nexport function resetReflectionCaches(): void {\n    rawMiddleFnReflectionCache.clear();\n    // Note: functionRunTypeCache uses WeakMap so it doesn't need explicit clearing\n    // Note: _cachedReflection on MethodMetadata objects will be cleared when persistedMethods is reset\n}\n\n// ############ Raw MiddleFn Reflection Helper ############\n\n// Cache for common raw middleFn reflections\nconst rawMiddleFnReflectionCache = new Map<string, MethodReflect>();\n\n/**\n * Creates a MethodReflect for raw middleFns.\n * Raw middleFns don't need JIT functions - they always use NoopJitFns.\n * Results are cached to avoid creating duplicate objects.\n */\nfunction createRawMiddleFnReflection(isAsync: boolean, hasReturnData: boolean = false, paramNames: string[] = []): MethodReflect {\n    // Create cache key from parameters\n    const cacheKey = `${isAsync}_${hasReturnData}_${paramNames.join(',')}`;\n\n    const cached = rawMiddleFnReflectionCache.get(cacheKey);\n    if (cached) return cached;\n\n    const reflection: MethodReflect = {\n        paramNames,\n        paramsJitFns: getNoopJitFns(),\n        returnJitFns: getNoopJitFns(),\n        paramsJitHash: EMPTY_HASH,\n        returnJitHash: EMPTY_HASH,\n        hasReturnData,\n        isAsync,\n    };\n\n    rawMiddleFnReflectionCache.set(cacheKey, reflection);\n    return reflection;\n}\n\n// ############ AOT Cache Extraction ############\n\n// Extend MethodMetadata type to include cached reflection\ntype CachedMethodMetadata = MethodMetadata & {\n    _cachedReflection?: MethodReflect;\n};\n\n/**\n * Extracts reflection data from a cached method.\n * Used in AOT mode to restore method reflection without loading run-types.\n * Results are cached on the metadata object to avoid creating duplicate objects.\n */\nfunction extractReflectionFromCached(cached: CachedMethodMetadata): MethodReflect {\n    // Return cached reflection if available\n    if (cached._cachedReflection) return cached._cachedReflection;\n\n    const reflectionItems: MethodReflect = {\n        paramNames: cached.paramNames || [],\n        paramsJitFns: getJitFunctionsFromHash(cached.paramsJitHash),\n        returnJitFns: getJitFunctionsFromHash(cached.returnJitHash),\n        paramsJitHash: cached.paramsJitHash,\n        returnJitHash: cached.returnJitHash,\n        hasReturnData: cached.hasReturnData,\n        isAsync: cached.isAsync,\n    };\n\n    // Restore headers param if present\n    if (cached.headersParam) {\n        reflectionItems.headersParam = {\n            headerNames: cached.headersParam.headerNames,\n            jitFns: getJitFunctionsFromHash(cached.headersParam.jitHash) as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>,\n            jitHash: cached.headersParam.jitHash,\n        };\n    }\n\n    // Restore headers return if present\n    if (cached.headersReturn) {\n        reflectionItems.headersReturn = {\n            headerNames: cached.headersReturn.headerNames,\n            jitFns: getJitFunctionsFromHash(cached.headersReturn.jitHash) as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>,\n            jitHash: cached.headersReturn.jitHash,\n        };\n    }\n\n    // Cache for future calls\n    cached._cachedReflection = reflectionItems;\n    return reflectionItems;\n}\n\n// ############ Main Reflection Functions ############\n\n/**\n * Gets reflection data for a handler (route or middleFn).\n * In AOT mode, returns cached data without loading run-types.\n * In non-AOT mode, dynamically loads run-types and generates reflection.\n * Throws AOTCacheError if AOT mode is enabled and route is not in cache.\n */\nexport async function getHandlerReflection(\n    handler: Handler,\n    routeId: string,\n    routerOptions: RouterOptions,\n    isHeadersMiddleFn: boolean = false,\n    methodStrictTypes?: boolean\n): Promise<MethodReflect> {\n    // Check AOT cache first\n    const cached = getPersistedMethodMetadata(routeId);\n    if (cached) return extractReflectionFromCached(cached);\n    if (routerOptions.aot) throw new AOTCacheError(routeId, isHeadersMiddleFn ? 'middleFn' : 'route');\n    // Non-AOT mode: dynamically load run-types and generate reflection\n    const rt = await loadRunTypesModule();\n    return generateHandlerReflection(handler, routeId, routerOptions, isHeadersMiddleFn, rt, methodStrictTypes);\n}\n\n/**\n * Gets reflection data for a raw middleFn.\n * Raw middleFns don't use full reflection - they don't need JIT functions.\n * Raw middleFns don't NEED to be in the AOT cache, but if they are, we can use\n * the cached data (especially the isAsync flag).\n * In AOT mode, this function does NOT load run-types.\n */\nexport async function getRawMethodReflection(\n    handler: Handler,\n    routeId: string,\n    routerOptions: RouterOptions\n): Promise<MethodReflect> {\n    // Check if raw middleFn is in cache - if so, use cached data (especially isAsync)\n    const cached = getPersistedMethodMetadata(routeId);\n    if (cached) return createRawMiddleFnReflection(cached.isAsync, cached.hasReturnData, cached.paramNames || []);\n    // Raw middleFns don't need JIT functions, so we don't need to load run-types in AOT mode\n    if (routerOptions.aot) return createRawMiddleFnReflection(true);\n    // Non-AOT mode: dynamically load run-types to properly detect if handler is async\n    const rt = await loadRunTypesModule();\n    return generateRawMethodReflection(handler, routeId, rt);\n}\n\n// ############ Reflection Generation (requires run-types) ############\n\n/**\n * Generates reflection data for a handler using run-types.\n * This function is only called in non-AOT mode.\n */\nfunction generateHandlerReflection(\n    handler: Handler,\n    routeId: string,\n    routerOptions: RouterOptions,\n    isHeadersMiddleFn: boolean,\n    rt: RunTypesFunctions,\n    methodStrictTypes?: boolean\n): MethodReflect {\n    const reflectionItems: Partial<MethodReflect> = {};\n    let handlerRunType: FunctionRunType;\n    const effectiveStrictTypes = methodStrictTypes ?? routerOptions.strictTypes;\n    const runTypeOptions: RunTypeOptions = {\n        ...(routerOptions?.runTypeOptions || DEFAULT_ROUTE_OPTIONS.runTypeOptions),\n        ...(effectiveStrictTypes !== undefined ? {strictTypes: effectiveStrictTypes} : {}),\n    };\n    try {\n        handlerRunType = rt.reflectFunction(handler);\n    } catch (error: any) {\n        throw new Error(`Can not get RunType of handler for route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n    const paramsSlice = isHeadersMiddleFn ? {start: HEADER_HOOK_DEFAULT_PARAMS.length} : {start: ROUTE_DEFAULT_PARAMS.length};\n    const paramsOpts: RunTypeOptions = {...runTypeOptions, paramsSlice};\n\n    try {\n        reflectionItems.paramNames = handlerRunType.getParameterNames(paramsOpts);\n        // Skip JIT generation if handler has no params (optimization for AOT cache size)\n        if (reflectionItems.paramNames.length === 0) {\n            reflectionItems.paramsJitHash = EMPTY_HASH;\n            reflectionItems.paramsJitFns = getNoopJitFns();\n        } else {\n            reflectionItems.paramsJitFns = getFunctionJitFns(handler, paramsOpts, rt, false);\n            reflectionItems.paramsJitHash = handlerRunType.getParameters().getJitHash(paramsOpts);\n        }\n    } catch (error: any) {\n        throw new Error(`Can not compile Jit Functions for Parameters of route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n\n    if (isHeadersMiddleFn) {\n        const headersRunType = getParamsHeadersRunType(handlerRunType, routeId, routerOptions, rt);\n        const headerNames: string[] = getHeaderNames(headersRunType, routeId, rt);\n\n        try {\n            const opts: RunTypeOptions = {\n                ...runTypeOptions,\n                paramsSlice: undefined,\n            };\n\n            const jitFns: JitCompiledFunctions = getTypeJitFunctions(headersRunType, opts, rt);\n            const jitHash = headersRunType.getJitHash(opts);\n            reflectionItems.headersParam = {headerNames, jitFns, jitHash};\n        } catch (error: any) {\n            throw new Error(\n                `Can not compile Jit Functions for Headers of Headers MiddleFn \"${routeId}.\" Error: ${error?.message}`\n            );\n        }\n    }\n\n    const returnHeadersRunType = getReturnHeadersRunType(handlerRunType, rt);\n    if (returnHeadersRunType) {\n        const opts: RunTypeOptions = {};\n        const headerNames: string[] = getHeaderNames(returnHeadersRunType, routeId, rt);\n        const jitFns: JitCompiledFunctions = getFunctionJitFns(handler, opts, rt, true);\n        const jitHash: string = returnHeadersRunType.getJitHash(opts);\n        reflectionItems.headersReturn = {headerNames, jitFns, jitHash};\n    }\n\n    const returnOpts: RunTypeOptions = runTypeOptions;\n    // If the return type is HeadersSubset or if it's a headersFn with array return, don't treat it as return data\n    reflectionItems.hasReturnData = handlerRunType.hasReturnData();\n\n    try {\n        // Skip JIT generation if handler has void return (optimization for AOT cache size)\n        if (!reflectionItems.hasReturnData) {\n            reflectionItems.returnJitFns = getNoopJitFns();\n            reflectionItems.returnJitHash = EMPTY_HASH;\n        } else {\n            // returnJitFns contains all run type functionality for the return value, it compiles when the property is first accessed\n            reflectionItems.returnJitFns = getFunctionJitFns(handler, returnOpts, rt, true);\n            reflectionItems.returnJitHash = handlerRunType.getReturnType().getJitHash(returnOpts);\n        }\n    } catch (error: any) {\n        throw new Error(`Can not get Jit Functions for Return of route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n\n    reflectionItems.isAsync = handlerRunType.isAsync();\n\n    return reflectionItems as MethodReflect;\n}\n\n/**\n * Generates reflection data for a raw middleFn using run-types.\n * This function is only called in non-AOT mode.\n */\nfunction generateRawMethodReflection(handler: Handler, routeId: string, rt: RunTypesFunctions): MethodReflect {\n    let handlerRunType: FunctionRunType;\n    try {\n        handlerRunType = rt.reflectFunction(handler);\n    } catch (error: any) {\n        throw new Error(`Can not get RunType of handler for route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n    const isAsync = handlerRunType?.isAsync() || true;\n    return createRawMiddleFnReflection(isAsync);\n}\n\n// ############ Helper Functions (require run-types module) ############\n\nfunction getParamsHeadersRunType(\n    handlerRunType: FunctionRunType,\n    routeId: string,\n    routerOptions: RouterOptions,\n    rt: RunTypesFunctions\n): BaseRunType {\n    const paramRunTypes = handlerRunType.getParameters().getParamRunTypes(getFakeCompiler(routerOptions));\n    const headersSubset = (paramRunTypes[1] as MemberRunType<any>)?.getMemberType?.(); // HeadersSubset is always index 1 after context\n\n    if (!isHeaderSubSetRunType(headersSubset, rt)) {\n        throw new Error(`Headers MiddleFn '${routeId}' second parameter must be a HeadersSubset.`);\n    }\n    return headersSubset;\n}\n\nfunction getReturnHeadersRunType(handlerRunType: FunctionRunType, rt: RunTypesFunctions): BaseRunType | undefined {\n    const returnRunType = handlerRunType.getReturnType();\n    if (rt.isUnionRunType(returnRunType)) {\n        const headersSubset = returnRunType.getChildRunTypes().find((child) => isHeaderSubSetRunType(child, rt));\n        if (!headersSubset) return undefined;\n        return headersSubset;\n    }\n    if (!isHeaderSubSetRunType(returnRunType, rt)) return undefined;\n    return returnRunType;\n}\n\nfunction isHeaderSubSetRunType(runType: BaseRunType | undefined, rt: RunTypesFunctions): runType is BaseRunType {\n    if (!runType) return false;\n    return rt.isClassRunType(runType, HeadersSubset);\n}\n\nfunction getHeaderNames(runType: BaseRunType, routeId: string, rt: RunTypesFunctions): string[] {\n    // HeadersSubset is a generic class: HeadersSubset<Required, Optional>\n    // We need to extract the literal string values from the Required and Optional type arguments\n    // Use 'typeArguments' (not 'arguments') to get both Required and Optional with their defaults\n    const typeArguments = (runType.src as any).typeArguments;\n    if (!typeArguments || typeArguments.length === 0) {\n        throw new Error(`HeadersSubset must have type arguments in route/middleFn ${routeId}`);\n    }\n    const headerNames: string[] = [];\n    // Extract header names from Required type argument (first argument)\n    const requiredArg = typeArguments[0];\n    if (requiredArg) {\n        const requiredNames = extractLiteralStringsFromType(requiredArg._rt, rt);\n        headerNames.push(...requiredNames);\n    }\n    // Extract header names from Optional type argument (second argument, if present)\n    if (typeArguments.length > 1) {\n        const optionalArg = typeArguments[1];\n        if (optionalArg) {\n            const optionalNames = extractLiteralStringsFromType(optionalArg._rt, rt);\n            headerNames.push(...optionalNames);\n        }\n    }\n    if (headerNames.length === 0) throw new Error(`Header names array cannot be empty in route/middleFn ${routeId}`);\n    return headerNames;\n}\n\n/**\n * Internal recursive function to extract literal string values from a type.\n * Handles single literal strings and union types (including nested unions).\n */\nfunction extractLiteralStringsFromTypeRecursive(runType: BaseRunType, rt: RunTypesFunctions): string[] {\n    // Handle single literal string\n    if (rt.isLiteralRunType(runType)) {\n        const literal = (runType as any).getLiteralValue();\n        if (typeof literal === 'string') {\n            return [literal];\n        }\n        return [];\n    }\n\n    // Handle union of literal strings (recursively for nested unions)\n    if (rt.isUnionRunType(runType)) {\n        const children = runType.getChildRunTypes();\n        const literals: string[] = [];\n        for (const child of children) {\n            // Recursively extract from each child (handles nested unions)\n            const childLiterals = extractLiteralStringsFromTypeRecursive(child, rt);\n            literals.push(...childLiterals);\n        }\n        return literals;\n    }\n\n    return [];\n}\n\n/**\n * Extracts literal string values from a type.\n * Handles 'never' type only at the root level, then delegates to recursive extraction.\n */\nfunction extractLiteralStringsFromType(runType: BaseRunType, rt: RunTypesFunctions): string[] {\n    // Handle 'never' type at root level only (no headers)\n    if (rt.isNeverRunType(runType)) return [];\n    return extractLiteralStringsFromTypeRecursive(runType, rt);\n}\n\n// Create a fake compiler object with just the opts property needed by getParamRunTypes.\n// getParamRunTypes() requires a JitFnCompiler but we only need the opts property to slice parameters.\n// This is a workaround to avoid updating getParamRunTypes() signature\nfunction getFakeCompiler(routerOptions: RouterOptions): JitFnCompiler {\n    return {opts: routerOptions} as any as JitFnCompiler;\n}\n\nfunction getTypeJitFunctions(\n    runType: BaseRunType,\n    opts: RunTypeOptions | undefined,\n    rtModule: RunTypesFunctions\n): JitCompiledFunctions {\n    const jitFns: JitCompiledFunctions = {\n        isType: runType.createJitCompiledFunction(rtModule.JitFunctions.isType.id, undefined, opts),\n        typeErrors: runType.createJitCompiledFunction(rtModule.JitFunctions.typeErrors.id, undefined, opts),\n        prepareForJson: runType.createJitCompiledFunction(rtModule.JitFunctions.prepareForJson.id, undefined, opts),\n        restoreFromJson: runType.createJitCompiledFunction(rtModule.JitFunctions.restoreFromJson.id, undefined, opts),\n        stringifyJson: runType.createJitCompiledFunction(rtModule.JitFunctions.stringifyJson.id, undefined, opts),\n        toBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.toBinary.id, undefined, opts),\n        fromBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.fromBinary.id, undefined, opts),\n    };\n    return jitFns;\n}\n\n// Cache for function RunTypes to avoid duplicate reflectFunction calls\nconst functionRunTypeCache = new WeakMap<AnyFn, FunctionRunType>();\n\nfunction getFunctionJitFns<Fn extends AnyFn>(\n    fn: Fn,\n    opts: RunTypeOptions | undefined,\n    rtModule: RunTypesFunctions,\n    isReturn: boolean\n): JitCompiledFunctions {\n    // Check cache first\n    let runType = functionRunTypeCache.get(fn);\n    if (!runType) {\n        runType = rtModule.reflectFunction(fn);\n        functionRunTypeCache.set(fn, runType);\n    }\n\n    const createFn = isReturn\n        ? runType.createJitCompiledReturnFunction.bind(runType)\n        : runType.createJitCompiledParamsFunction.bind(runType);\n    const jitFunctions: JitCompiledFunctions = {\n        isType: createFn(rtModule.JitFunctions.isType, opts),\n        typeErrors: createFn(rtModule.JitFunctions.typeErrors, opts),\n        prepareForJson: createFn(rtModule.JitFunctions.prepareForJson, opts),\n        restoreFromJson: createFn(rtModule.JitFunctions.restoreFromJson, opts),\n        stringifyJson: createFn(rtModule.JitFunctions.stringifyJson, opts),\n        toBinary: createFn(rtModule.JitFunctions.toBinary, opts),\n        fromBinary: createFn(rtModule.JitFunctions.fromBinary, opts),\n    };\n    return jitFunctions;\n}\n\n// ############ Null JIT Functions ############\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"reflection.js","sources":["../../../../src/lib/reflection.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {MethodWithJitFns, AnyFn, JitCompiledFunctions, MethodMetadata} from '@mionjs/core';\n// Type-only imports from run-types - these don't load the module at runtime\nimport type {FunctionRunType, BaseRunType, MemberRunType, RunTypeOptions, JitFnCompiler} from '@mionjs/run-types';\nimport {Handler} from '../types/handlers.ts';\nimport {RouterOptions} from '../types/general.ts';\nimport {DEFAULT_ROUTE_OPTIONS, HEADER_HOOK_DEFAULT_PARAMS, ROUTE_DEFAULT_PARAMS} from '../constants.ts';\nimport {EMPTY_HASH, HeadersSubset, getJitFunctionsFromHash, getNoopJitFns, HandlerType} from '@mionjs/core';\nimport {getPersistedMethodMetadata} from './methodsCache.ts';\nimport {RouteOptions, MiddleFnOptions, HeadersMiddleFnOptions, MiddleFnMethod, HeadersMethod} from '../types/remoteMethods.ts';\n\n// ############ This file is the only one importing '@mionjs/run-types' within the router ########\n// In AOT mode, run-types is NOT loaded - all reflection data comes from the AOT cache\n\ntype MethodReflect = Omit<MethodWithJitFns, 'id' | 'type' | 'nestLevel' | 'pointer' | 'options'>;\n\n// ############ AOT Cache Error ############\n\n/**\n * Error thrown when AOT mode is enabled but required data is missing from the AOT cache.\n * This indicates that the AOT caches need to be regenerated using 'mion-build-aot' command.\n */\nexport class AOTCacheError extends Error {\n    constructor(routeId: string, type: 'route' | 'middleFn' | 'rawMiddleFn' = 'route') {\n        const typeLabel = type === 'rawMiddleFn' ? 'Raw middleFn' : type === 'middleFn' ? 'MiddleFn' : 'Route/middleFn';\n        super(`${typeLabel} \"${routeId}\" not found in AOT cache.\\n` + `Regenerate AOT caches using 'mion-build-aot' command.`);\n        this.name = 'AOTCacheError';\n    }\n}\n\n// ############ Run-Types Module Loading ############\ntype RunTypesModule = typeof import('@mionjs/run-types');\n// Type definition for the dynamically imported run-types module\ninterface RunTypesFunctions {\n    JitFunctions: RunTypesModule['JitFunctions'];\n    reflectFunction: RunTypesModule['reflectFunction'];\n    isUnionRunType: RunTypesModule['isUnionRunType'];\n    isClassRunType: RunTypesModule['isClassRunType'];\n    isLiteralRunType: RunTypesModule['isLiteralRunType'];\n    isNeverRunType: RunTypesModule['isNeverRunType'];\n}\n\n// Cached run-types module - loaded once and reused\nlet runTypesModule: RunTypesFunctions | null = null;\nlet runTypesLoadPromise: Promise<RunTypesFunctions> | null = null;\n\n/** Dynamically loads the @mionjs/run-types module. The module is cached after first load. */\nasync function loadRunTypesModule(): Promise<RunTypesFunctions> {\n    // Return cached module if already loaded\n    if (runTypesModule) return runTypesModule;\n\n    // Return existing promise if load is in progress\n    if (runTypesLoadPromise) return runTypesLoadPromise;\n\n    // Start loading the module\n    runTypesLoadPromise = import('@mionjs/run-types').then((module) => {\n        runTypesModule = {\n            JitFunctions: module.JitFunctions,\n            reflectFunction: module.reflectFunction,\n            isUnionRunType: module.isUnionRunType,\n            isClassRunType: module.isClassRunType,\n            isLiteralRunType: module.isLiteralRunType,\n            isNeverRunType: module.isNeverRunType,\n        };\n        return runTypesModule;\n    });\n\n    return runTypesLoadPromise;\n}\n\n/** Resets the run-types module cache. Useful for testing purposes only. */\nexport function resetRunTypesCache(): void {\n    runTypesModule = null;\n    runTypesLoadPromise = null;\n}\n\n/** Resets all reflection caches. Useful for testing purposes only. */\nexport function resetReflectionCaches(): void {\n    rawMiddleFnReflectionCache.clear();\n    // Note: functionRunTypeCache uses WeakMap so it doesn't need explicit clearing\n    // Note: _cachedReflection on MethodMetadata objects will be cleared when persistedMethods is reset\n}\n\n// ############ Raw MiddleFn Reflection Helper ############\n\n// Cache for common raw middleFn reflections\nconst rawMiddleFnReflectionCache = new Map<string, MethodReflect>();\n\n/**\n * Creates a MethodReflect for raw middleFns.\n * Raw middleFns don't need JIT functions - they always use NoopJitFns.\n * Results are cached to avoid creating duplicate objects.\n */\nfunction createRawMiddleFnReflection(isAsync: boolean, hasReturnData: boolean = false, paramNames: string[] = []): MethodReflect {\n    // Create cache key from parameters\n    const cacheKey = `${isAsync}_${hasReturnData}_${paramNames.join(',')}`;\n\n    const cached = rawMiddleFnReflectionCache.get(cacheKey);\n    if (cached) return cached;\n\n    const reflection: MethodReflect = {\n        paramNames,\n        paramsJitFns: getNoopJitFns(),\n        returnJitFns: getNoopJitFns(),\n        paramsJitHash: EMPTY_HASH,\n        returnJitHash: EMPTY_HASH,\n        hasReturnData,\n        isAsync,\n    };\n\n    rawMiddleFnReflectionCache.set(cacheKey, reflection);\n    return reflection;\n}\n\n// ############ AOT Cache Extraction ############\n\n// Extend MethodMetadata type to include cached reflection\ntype CachedMethodMetadata = MethodMetadata & {\n    _cachedReflection?: MethodReflect;\n};\n\n/**\n * Extracts reflection data from a cached method.\n * Used in AOT mode to restore method reflection without loading run-types.\n * Results are cached on the metadata object to avoid creating duplicate objects.\n */\nfunction extractReflectionFromCached(cached: CachedMethodMetadata): MethodReflect {\n    // Return cached reflection if available\n    if (cached._cachedReflection) return cached._cachedReflection;\n\n    const reflectionItems: MethodReflect = {\n        paramNames: cached.paramNames || [],\n        paramsJitFns: getJitFunctionsFromHash(cached.paramsJitHash),\n        returnJitFns: getJitFunctionsFromHash(cached.returnJitHash),\n        paramsJitHash: cached.paramsJitHash,\n        returnJitHash: cached.returnJitHash,\n        hasReturnData: cached.hasReturnData,\n        isAsync: cached.isAsync,\n    };\n\n    // Restore headers param if present\n    if (cached.headersParam) {\n        reflectionItems.headersParam = {\n            headerNames: cached.headersParam.headerNames,\n            jitFns: getJitFunctionsFromHash(cached.headersParam.jitHash) as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>,\n            jitHash: cached.headersParam.jitHash,\n        };\n    }\n\n    // Restore headers return if present\n    if (cached.headersReturn) {\n        reflectionItems.headersReturn = {\n            headerNames: cached.headersReturn.headerNames,\n            jitFns: getJitFunctionsFromHash(cached.headersReturn.jitHash) as Pick<JitCompiledFunctions, 'isType' | 'typeErrors'>,\n            jitHash: cached.headersReturn.jitHash,\n        };\n    }\n\n    // Cache for future calls\n    cached._cachedReflection = reflectionItems;\n    return reflectionItems;\n}\n\n// ############ Main Reflection Functions ############\n\n/**\n * Gets reflection data for a handler (route or middleFn).\n * In AOT mode, returns cached data without loading run-types.\n * In non-AOT mode, dynamically loads run-types and generates reflection.\n * Throws AOTCacheError if AOT mode is enabled and route is not in cache.\n */\nexport async function getHandlerReflection(\n    handler: Handler,\n    routeId: string,\n    routerOptions: RouterOptions,\n    handlerOptions: RouteOptions | MiddleFnOptions | HeadersMiddleFnOptions = {},\n    isHeadersMiddleFn: boolean = false,\n    methodStrictTypes?: boolean\n): Promise<MethodReflect> {\n    // Check AOT cache first\n    const cached = getPersistedMethodMetadata(routeId);\n    if (cached) return extractReflectionFromCached(cached);\n    if (routerOptions.aot) throw new AOTCacheError(routeId, isHeadersMiddleFn ? 'middleFn' : 'route');\n    // Non-AOT mode: dynamically load run-types and generate reflection\n    const rt = await loadRunTypesModule();\n    return generateHandlerReflection(handler, routeId, routerOptions, handlerOptions, isHeadersMiddleFn, rt, methodStrictTypes);\n}\n\n/**\n * Gets reflection data for a raw middleFn.\n * Raw middleFns don't use full reflection - they don't need JIT functions.\n * Raw middleFns don't NEED to be in the AOT cache, but if they are, we can use\n * the cached data (especially the isAsync flag).\n * In AOT mode, this function does NOT load run-types.\n */\nexport async function getRawMethodReflection(\n    handler: Handler,\n    routeId: string,\n    routerOptions: RouterOptions\n): Promise<MethodReflect> {\n    // Check if raw middleFn is in cache - if so, use cached data (especially isAsync)\n    const cached = getPersistedMethodMetadata(routeId);\n    if (cached) return createRawMiddleFnReflection(cached.isAsync, cached.hasReturnData, cached.paramNames || []);\n    // Raw middleFns don't need JIT functions, so we don't need to load run-types in AOT mode\n    if (routerOptions.aot) return createRawMiddleFnReflection(true);\n    // Non-AOT mode: dynamically load run-types to properly detect if handler is async\n    const rt = await loadRunTypesModule();\n    return generateRawMethodReflection(handler, routeId, rt);\n}\n\n// ############ Reflection Generation (requires run-types) ############\n\n/**\n * Generates reflection data for a handler using run-types.\n * This function is only called in non-AOT mode.\n */\nfunction generateHandlerReflection(\n    handler: Handler,\n    routeId: string,\n    routerOptions: RouterOptions,\n    handlerOptions: RouteOptions | MiddleFnOptions | HeadersMiddleFnOptions,\n    isHeadersMiddleFn: boolean,\n    rt: RunTypesFunctions,\n    methodStrictTypes?: boolean\n): MethodReflect {\n    const reflectionItems: Partial<MethodReflect> = {};\n    let handlerRunType: FunctionRunType;\n    const needsBinary = ((handlerOptions as RouteOptions)?.serializer ?? routerOptions.serializer) === 'binary';\n    const effectiveStrictTypes = methodStrictTypes ?? routerOptions.strictTypes;\n    const runTypeOptions: RunTypeOptions = {\n        ...(routerOptions?.runTypeOptions || DEFAULT_ROUTE_OPTIONS.runTypeOptions),\n        ...(effectiveStrictTypes !== undefined ? {strictTypes: effectiveStrictTypes} : {}),\n    };\n    try {\n        handlerRunType = rt.reflectFunction(handler);\n    } catch (error: any) {\n        throw new Error(`Can not get RunType of handler for route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n    const paramsSlice = isHeadersMiddleFn ? {start: HEADER_HOOK_DEFAULT_PARAMS.length} : {start: ROUTE_DEFAULT_PARAMS.length};\n    const paramsOpts: RunTypeOptions = {...runTypeOptions, paramsSlice};\n\n    try {\n        reflectionItems.paramNames = handlerRunType.getParameterNames(paramsOpts);\n        // Skip JIT generation if handler has no params (optimization for AOT cache size)\n        if (reflectionItems.paramNames.length === 0) {\n            reflectionItems.paramsJitHash = EMPTY_HASH;\n            reflectionItems.paramsJitFns = getNoopJitFns();\n        } else {\n            reflectionItems.paramsJitFns = getFunctionJitFns(handler, paramsOpts, rt, false, needsBinary);\n            reflectionItems.paramsJitHash = handlerRunType.getParameters().getJitHash(paramsOpts);\n        }\n    } catch (error: any) {\n        throw new Error(`Can not compile Jit Functions for Parameters of route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n\n    if (isHeadersMiddleFn) {\n        const headersRunType = getParamsHeadersRunType(handlerRunType, routeId, routerOptions, rt);\n        const headerNames: string[] = getHeaderNames(headersRunType, routeId, rt);\n\n        try {\n            const opts: RunTypeOptions = {\n                ...runTypeOptions,\n                paramsSlice: undefined,\n            };\n\n            const jitFns: JitCompiledFunctions = getTypeJitFunctions(headersRunType, opts, rt, false);\n            const jitHash = headersRunType.getJitHash(opts);\n            reflectionItems.headersParam = {headerNames, jitFns, jitHash};\n        } catch (error: any) {\n            throw new Error(\n                `Can not compile Jit Functions for Headers of Headers MiddleFn \"${routeId}.\" Error: ${error?.message}`\n            );\n        }\n    }\n\n    const returnHeadersRunType = getReturnHeadersRunType(handlerRunType, rt);\n    if (returnHeadersRunType) {\n        const opts: RunTypeOptions = {};\n        const headerNames: string[] = getHeaderNames(returnHeadersRunType, routeId, rt);\n        const jitFns: JitCompiledFunctions = getFunctionJitFns(handler, opts, rt, true, false);\n        const jitHash: string = returnHeadersRunType.getJitHash(opts);\n        reflectionItems.headersReturn = {headerNames, jitFns, jitHash};\n    }\n\n    const returnOpts: RunTypeOptions = runTypeOptions;\n    // If the return type is HeadersSubset or if it's a headersFn with array return, don't treat it as return data\n    reflectionItems.hasReturnData = handlerRunType.hasReturnData();\n\n    try {\n        // Skip JIT generation if handler has void return (optimization for AOT cache size)\n        if (!reflectionItems.hasReturnData) {\n            reflectionItems.returnJitFns = getNoopJitFns();\n            reflectionItems.returnJitHash = EMPTY_HASH;\n        } else {\n            // returnJitFns contains all run type functionality for the return value, it compiles when the property is first accessed\n            reflectionItems.returnJitFns = getFunctionJitFns(handler, returnOpts, rt, true, needsBinary);\n            reflectionItems.returnJitHash = handlerRunType.getResolvedReturnType().getJitHash(returnOpts);\n        }\n    } catch (error: any) {\n        throw new Error(`Can not get Jit Functions for Return of route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n\n    reflectionItems.isAsync = handlerRunType.isAsync();\n\n    return reflectionItems as MethodReflect;\n}\n\n/**\n * Generates reflection data for a raw middleFn using run-types.\n * This function is only called in non-AOT mode.\n */\nfunction generateRawMethodReflection(handler: Handler, routeId: string, rt: RunTypesFunctions): MethodReflect {\n    let handlerRunType: FunctionRunType;\n    try {\n        handlerRunType = rt.reflectFunction(handler);\n    } catch (error: any) {\n        throw new Error(`Can not get RunType of handler for route/middleFn \"${routeId}.\" Error: ${error?.message}`);\n    }\n    const isAsync = handlerRunType?.isAsync() || true;\n    return createRawMiddleFnReflection(isAsync);\n}\n\n// ############ Helper Functions (require run-types module) ############\n\nfunction getParamsHeadersRunType(\n    handlerRunType: FunctionRunType,\n    routeId: string,\n    routerOptions: RouterOptions,\n    rt: RunTypesFunctions\n): BaseRunType {\n    const paramRunTypes = handlerRunType.getParameters().getParamRunTypes(getFakeCompiler(routerOptions));\n    const headersSubset = (paramRunTypes[1] as MemberRunType<any>)?.getMemberType?.(); // HeadersSubset is always index 1 after context\n\n    if (!isHeaderSubSetRunType(headersSubset, rt)) {\n        throw new Error(`Headers MiddleFn '${routeId}' second parameter must be a HeadersSubset.`);\n    }\n    return headersSubset;\n}\n\nfunction getReturnHeadersRunType(handlerRunType: FunctionRunType, rt: RunTypesFunctions): BaseRunType | undefined {\n    const returnRunType = handlerRunType.getReturnType();\n    if (rt.isUnionRunType(returnRunType)) {\n        const headersSubset = returnRunType.getChildRunTypes().find((child) => isHeaderSubSetRunType(child, rt));\n        if (!headersSubset) return undefined;\n        return headersSubset;\n    }\n    if (!isHeaderSubSetRunType(returnRunType, rt)) return undefined;\n    return returnRunType;\n}\n\nfunction isHeaderSubSetRunType(runType: BaseRunType | undefined, rt: RunTypesFunctions): runType is BaseRunType {\n    if (!runType) return false;\n    return rt.isClassRunType(runType, HeadersSubset);\n}\n\nfunction getHeaderNames(runType: BaseRunType, routeId: string, rt: RunTypesFunctions): string[] {\n    // HeadersSubset is a generic class: HeadersSubset<Required, Optional>\n    // We need to extract the literal string values from the Required and Optional type arguments\n    // Use 'typeArguments' (not 'arguments') to get both Required and Optional with their defaults\n    const typeArguments = (runType.src as any).typeArguments;\n    if (!typeArguments || typeArguments.length === 0) {\n        throw new Error(`HeadersSubset must have type arguments in route/middleFn ${routeId}`);\n    }\n    const headerNames: string[] = [];\n    // Extract header names from Required type argument (first argument)\n    const requiredArg = typeArguments[0];\n    if (requiredArg) {\n        const requiredNames = extractLiteralStringsFromType(requiredArg._rt, rt);\n        headerNames.push(...requiredNames);\n    }\n    // Extract header names from Optional type argument (second argument, if present)\n    if (typeArguments.length > 1) {\n        const optionalArg = typeArguments[1];\n        if (optionalArg) {\n            const optionalNames = extractLiteralStringsFromType(optionalArg._rt, rt);\n            headerNames.push(...optionalNames);\n        }\n    }\n    if (headerNames.length === 0) throw new Error(`Header names array cannot be empty in route/middleFn ${routeId}`);\n    return headerNames;\n}\n\n/**\n * Internal recursive function to extract literal string values from a type.\n * Handles single literal strings and union types (including nested unions).\n */\nfunction extractLiteralStringsFromTypeRecursive(runType: BaseRunType, rt: RunTypesFunctions): string[] {\n    // Handle single literal string\n    if (rt.isLiteralRunType(runType)) {\n        const literal = (runType as any).getLiteralValue();\n        if (typeof literal === 'string') {\n            return [literal];\n        }\n        return [];\n    }\n\n    // Handle union of literal strings (recursively for nested unions)\n    if (rt.isUnionRunType(runType)) {\n        const children = runType.getChildRunTypes();\n        const literals: string[] = [];\n        for (const child of children) {\n            // Recursively extract from each child (handles nested unions)\n            const childLiterals = extractLiteralStringsFromTypeRecursive(child, rt);\n            literals.push(...childLiterals);\n        }\n        return literals;\n    }\n\n    return [];\n}\n\n/**\n * Extracts literal string values from a type.\n * Handles 'never' type only at the root level, then delegates to recursive extraction.\n */\nfunction extractLiteralStringsFromType(runType: BaseRunType, rt: RunTypesFunctions): string[] {\n    // Handle 'never' type at root level only (no headers)\n    if (rt.isNeverRunType(runType)) return [];\n    return extractLiteralStringsFromTypeRecursive(runType, rt);\n}\n\n// Create a fake compiler object with just the opts property needed by getParamRunTypes.\n// getParamRunTypes() requires a JitFnCompiler but we only need the opts property to slice parameters.\n// This is a workaround to avoid updating getParamRunTypes() signature\nfunction getFakeCompiler(routerOptions: RouterOptions): JitFnCompiler {\n    return {opts: routerOptions} as any as JitFnCompiler;\n}\n\nfunction getTypeJitFunctions(\n    runType: BaseRunType,\n    opts: RunTypeOptions | undefined,\n    rtModule: RunTypesFunctions,\n    needsBinary: boolean = false\n): JitCompiledFunctions {\n    const jitFns: JitCompiledFunctions = {\n        isType: runType.createJitCompiledFunction(rtModule.JitFunctions.isType.id, undefined, opts),\n        typeErrors: runType.createJitCompiledFunction(rtModule.JitFunctions.typeErrors.id, undefined, opts),\n        prepareForJson: runType.createJitCompiledFunction(rtModule.JitFunctions.prepareForJson.id, undefined, opts),\n        restoreFromJson: runType.createJitCompiledFunction(rtModule.JitFunctions.restoreFromJson.id, undefined, opts),\n        stringifyJson: runType.createJitCompiledFunction(rtModule.JitFunctions.stringifyJson.id, undefined, opts),\n        ...(needsBinary\n            ? {\n                  toBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.toBinary.id, undefined, opts),\n                  fromBinary: runType.createJitCompiledFunction(rtModule.JitFunctions.fromBinary.id, undefined, opts),\n              }\n            : {}),\n    };\n    return jitFns;\n}\n\n// Cache for function RunTypes to avoid duplicate reflectFunction calls\nconst functionRunTypeCache = new WeakMap<AnyFn, FunctionRunType>();\n\nfunction getFunctionJitFns<Fn extends AnyFn>(\n    fn: Fn,\n    opts: RunTypeOptions | undefined,\n    rtModule: RunTypesFunctions,\n    isReturn: boolean,\n    needsBinary: boolean = false\n): JitCompiledFunctions {\n    // Check cache first\n    let runType = functionRunTypeCache.get(fn);\n    if (!runType) {\n        runType = rtModule.reflectFunction(fn);\n        functionRunTypeCache.set(fn, runType);\n    }\n\n    const createFn = isReturn\n        ? runType.createJitCompiledReturnFunction.bind(runType)\n        : runType.createJitCompiledParamsFunction.bind(runType);\n    const jitFunctions: JitCompiledFunctions = {\n        isType: createFn(rtModule.JitFunctions.isType, opts),\n        typeErrors: createFn(rtModule.JitFunctions.typeErrors, opts),\n        prepareForJson: createFn(rtModule.JitFunctions.prepareForJson, opts),\n        restoreFromJson: createFn(rtModule.JitFunctions.restoreFromJson, opts),\n        stringifyJson: createFn(rtModule.JitFunctions.stringifyJson, opts),\n        ...(needsBinary\n            ? {\n                  toBinary: createFn(rtModule.JitFunctions.toBinary, opts),\n                  fromBinary: createFn(rtModule.JitFunctions.fromBinary, opts),\n              }\n            : {}),\n    };\n    return jitFunctions;\n}\n\n// ############ Retroactive Binary JIT Compilation ############\n\n/** Compiles toBinary/fromBinary JIT functions for middleware that was initially compiled without binary support */\nexport async function ensureBinaryJitFns(method: MiddleFnMethod | HeadersMethod): Promise<void> {\n    if (method.paramsJitFns.toBinary && method.returnJitFns.toBinary) return;\n    const rt = await loadRunTypesModule();\n    const isHeader = method.type === HandlerType.headersMiddleFn;\n    const paramsSlice = isHeader ? {start: HEADER_HOOK_DEFAULT_PARAMS.length} : {start: ROUTE_DEFAULT_PARAMS.length};\n    const opts: RunTypeOptions = {paramsSlice};\n\n    if (!method.paramsJitFns.toBinary && method.paramsJitHash !== EMPTY_HASH) {\n        const runType = rt.reflectFunction(method.handler);\n        const createFn = runType.createJitCompiledParamsFunction.bind(runType);\n        method.paramsJitFns.toBinary = createFn(rt.JitFunctions.toBinary, opts);\n        method.paramsJitFns.fromBinary = createFn(rt.JitFunctions.fromBinary, opts);\n    }\n    if (!method.returnJitFns.toBinary && method.returnJitHash !== EMPTY_HASH && method.hasReturnData) {\n        const runType = rt.reflectFunction(method.handler);\n        const createFn = runType.createJitCompiledReturnFunction.bind(runType);\n        method.returnJitFns.toBinary = createFn(rt.JitFunctions.toBinary);\n        method.returnJitFns.fromBinary = createFn(rt.JitFunctions.fromBinary);\n    }\n}\n\n// ############ Null JIT Functions ############\n"],"names":[],"mappings":"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"}

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

@@ -58,9 +58,12 @@ function serializePureDeps(namespacedDepHash, purFnDeps, depth = 0) {
   if (purFnDeps[namespace][fnHash]) return;
   const pureDep = getJitUtils().getCompiledPureFn(namespace, fnHash);
   if (!pureDep) throw new Error(`Pure function ${fnHash} not found in namespace ${namespace}`);
-  const serializedPureDep = { ...pureDep, pureFnDependencies: [...pureDep.pureFnDependencies] };
+  const serializedPureDep = {
+    ...pureDep,
+    pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : void 0
+  };
   purFnDeps[namespace][fnHash] = serializedPureDep;
-  pureDep.pureFnDependencies.forEach((depFnHash) => serializePureDeps(`${namespace}::${depFnHash}`, purFnDeps, depth + 1));
+  pureDep.pureFnDependencies?.forEach((depFnHash) => serializePureDeps(`${namespace}::${depFnHash}`, purFnDeps, depth + 1));
 }
 function serializeJitFn(jitFnHash, deps, purFnDeps, depth = 0) {
   if (depth >= MAX_STACK_DEPTH)
@@ -70,18 +73,31 @@ function serializeJitFn(jitFnHash, deps, purFnDeps, depth = 0) {
   if (deps[jitFnHash]) return;
   const serializedJitFn = getSerializableJitCompiler(jitFn);
   deps[jitFnHash] = serializedJitFn;
-  jitFn.jitDependencies.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));
-  jitFn.pureFnDependencies.forEach((h) => serializePureDeps(h, purFnDeps));
+  jitFn.jitDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));
+  jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));
 }
 function serializeMethodDeps(method, deps, purFnDeps) {
   const { paramsJitHash, returnJitHash } = method;
   if (paramsJitHash !== EMPTY_HASH) {
-    const paramsJitHashes = getJitFnHashes(paramsJitHash);
-    for (const k in paramsJitHashes) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);
+    const paramsJitHashes = getJitFnHashes(paramsJitHash, true);
+    for (const k in paramsJitHashes) {
+      if (getJitUtils().getJIT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);
+    }
   }
   if (returnJitHash !== EMPTY_HASH) {
-    const returnJitHashes = getJitFnHashes(returnJitHash);
-    for (const k in returnJitHashes) serializeJitFn(returnJitHashes[k], deps, purFnDeps);
+    const returnJitHashes = getJitFnHashes(returnJitHash, true);
+    let foundAny = false;
+    for (const k in returnJitHashes) {
+      if (getJitUtils().getJIT(returnJitHashes[k])) {
+        serializeJitFn(returnJitHashes[k], deps, purFnDeps);
+        foundAny = true;
+      }
+    }
+    if (!foundAny) {
+      throw new Error(
+        `Method "${method.id}" declares returnJitHash="${returnJitHash}" but no JIT functions are registered under that hash. This usually means a Promise/Function return type was not unwrapped before computing the hash.`
+      );
+    }
   }
 }
 function getSerializableJitCompiler(comp) {
@@ -93,8 +109,8 @@ function getSerializableJitCompiler(comp) {
     isNoop: comp.isNoop,
     defaultParamValues: structuredClone(comp.defaultParamValues),
     code: comp.code,
-    jitDependencies: [...comp.jitDependencies],
-    pureFnDependencies: [...comp.pureFnDependencies],
+    jitDependencies: comp.jitDependencies ? [...comp.jitDependencies] : void 0,
+    pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : void 0,
     ...comp.paramNames ? { paramNames: [...comp.paramNames] } : {}
   };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"remoteMethods.js","sources":["../../../../src/lib/remoteMethods.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type RouterEntry, type Routes} from '../types/general.ts';\nimport {type RemoteMethod} from '../types/remoteMethods.ts';\nimport type {PublicApi} from '../types/publicMethods.ts';\nimport type {\n    AnyObject,\n    JitCompiledFn,\n    JitCompiledFnData,\n    PureFunctionData,\n    MethodWithOptions,\n    PureFnsDataCache,\n} from '@mionjs/core';\nimport {isRoute, isHeadersMiddleFnDef, isMiddleFnDef} from '../types/guards.ts';\nimport {getMiddleFnExecutable, getRouteExecutable, isPrivateDefinition} from '../router.ts';\nimport {getRouterItemId, MAX_STACK_DEPTH, getJitFnHashes, getJitUtils, EMPTY_HASH} from '@mionjs/core';\n\n// ############# PRIVATE STATE #############\nconst publicMethods: Map<string, MethodWithOptions> = new Map();\n\n// ############# PUBLIC METHODS #############\nexport function resetRemoteMethodsMetadata() {\n    publicMethods.clear();\n}\n\n/**\n * Returns a data structure containing all public information and types of the routes.\n * This data and types can be used to generate router clients, etc...\n */\nexport function getPublicApi<R extends Routes>(routes: R): PublicApi<R> {\n    return recursiveGetSerializableRoutes(routes) as PublicApi<R>;\n}\n\n// ############# PRIVATE METHODS #############\n\nfunction recursiveGetSerializableRoutes<R extends Routes>(\n    routes: R,\n    currentPointer: string[] = [],\n    publicData: AnyObject = {}\n): AnyObject {\n    const entries = Object.entries(routes);\n    entries.forEach(([key, item]: [string, RouterEntry]) => {\n        const itemPointer = [...currentPointer, key];\n        const id = getRouterItemId(itemPointer);\n\n        if (isPrivateDefinition(item, id)) {\n            publicData[key] = null; // middleFns that don't receive or return data are not public\n        } else if (isMiddleFnDef(item) || isHeadersMiddleFnDef(item) || isRoute(item)) {\n            const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);\n            if (!executable)\n                throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);\n            publicData[key] = getSerializableMethod(executable as RemoteMethod);\n        } else {\n            const subRoutes: Routes = routes[key] as Routes;\n            publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);\n        }\n    });\n\n    return publicData;\n}\n\nexport function getSerializableMethod(executable: RemoteMethod): MethodWithOptions {\n    const existing = publicMethods.get(executable.id);\n    if (existing) return existing as MethodWithOptions;\n\n    const newRemoteMethod: MethodWithOptions = {\n        type: executable.type,\n        id: executable.id,\n        nestLevel: executable.nestLevel,\n        isAsync: executable.isAsync,\n        hasReturnData: executable.hasReturnData,\n        paramsJitHash: executable.paramsJitHash,\n        returnJitHash: executable.returnJitHash,\n        pointer: executable.pointer,\n        ...(executable.paramNames ? {paramNames: executable.paramNames} : {}),\n        options: executable.options,\n    };\n    if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;\n    if (executable.middleFnIds) newRemoteMethod.middleFnIds = executable.middleFnIds;\n    publicMethods.set(executable.id, newRemoteMethod);\n    return newRemoteMethod as MethodWithOptions;\n}\n\n/** Serializes pure function dependencies into a namespaced cache structure.\n * @param namespacedDepHash - Pure function dependency in format \"namespace::fnHash\"\n * @param purFnDeps - Namespaced cache to store serialized pure functions\n * @param depth - Current recursion depth for stack overflow protection\n */\nexport function serializePureDeps(namespacedDepHash: string, purFnDeps: PureFnsDataCache, depth = 0) {\n    if (depth >= MAX_STACK_DEPTH)\n        throw new Error(`Max depth reached serializing pure function dependencies, for: ${namespacedDepHash}`);\n    // Parse \"namespace::fnHash\" format\n    const parts = namespacedDepHash.split('::');\n    if (parts.length !== 2)\n        throw new Error(`Invalid pure function dependency format: ${namespacedDepHash}, expected \"namespace::fnHash\"`);\n    const [namespace, fnHash] = parts;\n    // Ensure namespace exists in the cache\n    if (!purFnDeps[namespace]) purFnDeps[namespace] = {};\n    // Check if already serialized (prevent infinite recursion on circular dependencies)\n    if (purFnDeps[namespace][fnHash]) return;\n    const pureDep = getJitUtils().getCompiledPureFn(namespace, fnHash);\n    if (!pureDep) throw new Error(`Pure function ${fnHash} not found in namespace ${namespace}`);\n    const serializedPureDep: PureFunctionData = {...pureDep, pureFnDependencies: [...pureDep.pureFnDependencies]};\n    purFnDeps[namespace][fnHash] = serializedPureDep;\n    // Dependencies within the same namespace are stored as just fnHash, not namespaced\n    pureDep.pureFnDependencies.forEach((depFnHash) => serializePureDeps(`${namespace}::${depFnHash}`, purFnDeps, depth + 1));\n}\n\nexport function serializeJitFn(\n    jitFnHash: string,\n    deps: Record<string, JitCompiledFnData>,\n    purFnDeps: PureFnsDataCache,\n    depth = 0\n) {\n    if (depth >= MAX_STACK_DEPTH)\n        throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${jitFnHash}`);\n    const jitFn = getJitUtils().getJIT(jitFnHash);\n    if (!jitFn) throw new Error(`Jit function ${jitFnHash} not found`);\n    if (deps[jitFnHash]) return; // already serialized and prevent infinite recursion on circular dependencies\n    const serializedJitFn = getSerializableJitCompiler(jitFn);\n    deps[jitFnHash] = serializedJitFn;\n    jitFn.jitDependencies.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));\n    jitFn.pureFnDependencies.forEach((h) => serializePureDeps(h, purFnDeps));\n}\n\nexport function serializeMethodDeps(\n    method: MethodWithOptions,\n    deps: Record<string, JitCompiledFnData>,\n    purFnDeps: PureFnsDataCache\n) {\n    const {paramsJitHash, returnJitHash} = method;\n    // Skip serialization for empty hashes (no params or void return)\n    if (paramsJitHash !== EMPTY_HASH) {\n        const paramsJitHashes = getJitFnHashes(paramsJitHash);\n        for (const k in paramsJitHashes) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);\n    }\n    if (returnJitHash !== EMPTY_HASH) {\n        const returnJitHashes = getJitFnHashes(returnJitHash);\n        for (const k in returnJitHashes) serializeJitFn(returnJitHashes[k], deps, purFnDeps);\n    }\n}\n\nfunction getSerializableJitCompiler(comp: JitCompiledFn): JitCompiledFnData {\n    return {\n        typeName: comp.typeName,\n        fnID: comp.fnID,\n        jitFnHash: comp.jitFnHash,\n        args: structuredClone(comp.args),\n        isNoop: comp.isNoop,\n        defaultParamValues: structuredClone(comp.defaultParamValues),\n        code: comp.code,\n        jitDependencies: [...comp.jitDependencies],\n        pureFnDependencies: [...comp.pureFnDependencies],\n        ...(comp.paramNames ? {paramNames: [...comp.paramNames]} : {}),\n    };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"remoteMethods.js","sources":["../../../../src/lib/remoteMethods.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type RouterEntry, type Routes} from '../types/general.ts';\nimport {type RemoteMethod} from '../types/remoteMethods.ts';\nimport type {PublicApi} from '../types/publicMethods.ts';\nimport type {\n    AnyObject,\n    JitCompiledFn,\n    JitCompiledFnData,\n    PureFunctionData,\n    MethodWithOptions,\n    PureFnsDataCache,\n} from '@mionjs/core';\nimport {isRoute, isHeadersMiddleFnDef, isMiddleFnDef} from '../types/guards.ts';\nimport {getMiddleFnExecutable, getRouteExecutable, isPrivateDefinition} from '../router.ts';\nimport {getRouterItemId, MAX_STACK_DEPTH, getJitFnHashes, getJitUtils, EMPTY_HASH} from '@mionjs/core';\n\n// ############# PRIVATE STATE #############\nconst publicMethods: Map<string, MethodWithOptions> = new Map();\n\n// ############# PUBLIC METHODS #############\nexport function resetRemoteMethodsMetadata() {\n    publicMethods.clear();\n}\n\n/**\n * Returns a data structure containing all public information and types of the routes.\n * This data and types can be used to generate router clients, etc...\n */\nexport function getPublicApi<R extends Routes>(routes: R): PublicApi<R> {\n    return recursiveGetSerializableRoutes(routes) as PublicApi<R>;\n}\n\n// ############# PRIVATE METHODS #############\n\nfunction recursiveGetSerializableRoutes<R extends Routes>(\n    routes: R,\n    currentPointer: string[] = [],\n    publicData: AnyObject = {}\n): AnyObject {\n    const entries = Object.entries(routes);\n    entries.forEach(([key, item]: [string, RouterEntry]) => {\n        const itemPointer = [...currentPointer, key];\n        const id = getRouterItemId(itemPointer);\n\n        if (isPrivateDefinition(item, id)) {\n            publicData[key] = null; // middleFns that don't receive or return data are not public\n        } else if (isMiddleFnDef(item) || isHeadersMiddleFnDef(item) || isRoute(item)) {\n            const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);\n            if (!executable)\n                throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);\n            publicData[key] = getSerializableMethod(executable as RemoteMethod);\n        } else {\n            const subRoutes: Routes = routes[key] as Routes;\n            publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);\n        }\n    });\n\n    return publicData;\n}\n\nexport function getSerializableMethod(executable: RemoteMethod): MethodWithOptions {\n    const existing = publicMethods.get(executable.id);\n    if (existing) return existing as MethodWithOptions;\n\n    const newRemoteMethod: MethodWithOptions = {\n        type: executable.type,\n        id: executable.id,\n        nestLevel: executable.nestLevel,\n        isAsync: executable.isAsync,\n        hasReturnData: executable.hasReturnData,\n        paramsJitHash: executable.paramsJitHash,\n        returnJitHash: executable.returnJitHash,\n        pointer: executable.pointer,\n        ...(executable.paramNames ? {paramNames: executable.paramNames} : {}),\n        options: executable.options,\n    };\n    if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;\n    if (executable.middleFnIds) newRemoteMethod.middleFnIds = executable.middleFnIds;\n    publicMethods.set(executable.id, newRemoteMethod);\n    return newRemoteMethod as MethodWithOptions;\n}\n\n/** Serializes pure function dependencies into a namespaced cache structure.\n * @param namespacedDepHash - Pure function dependency in format \"namespace::fnHash\"\n * @param purFnDeps - Namespaced cache to store serialized pure functions\n * @param depth - Current recursion depth for stack overflow protection\n */\nexport function serializePureDeps(namespacedDepHash: string, purFnDeps: PureFnsDataCache, depth = 0) {\n    if (depth >= MAX_STACK_DEPTH)\n        throw new Error(`Max depth reached serializing pure function dependencies, for: ${namespacedDepHash}`);\n    // Parse \"namespace::fnHash\" format\n    const parts = namespacedDepHash.split('::');\n    if (parts.length !== 2)\n        throw new Error(`Invalid pure function dependency format: ${namespacedDepHash}, expected \"namespace::fnHash\"`);\n    const [namespace, fnHash] = parts;\n    // Ensure namespace exists in the cache\n    if (!purFnDeps[namespace]) purFnDeps[namespace] = {};\n    // Check if already serialized (prevent infinite recursion on circular dependencies)\n    if (purFnDeps[namespace][fnHash]) return;\n    const pureDep = getJitUtils().getCompiledPureFn(namespace, fnHash);\n    if (!pureDep) throw new Error(`Pure function ${fnHash} not found in namespace ${namespace}`);\n    const serializedPureDep: PureFunctionData = {\n        ...pureDep,\n        pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : undefined,\n    };\n    purFnDeps[namespace][fnHash] = serializedPureDep;\n    // Dependencies within the same namespace are stored as just fnHash, not namespaced\n    pureDep.pureFnDependencies?.forEach((depFnHash) => serializePureDeps(`${namespace}::${depFnHash}`, purFnDeps, depth + 1));\n}\n\nexport function serializeJitFn(\n    jitFnHash: string,\n    deps: Record<string, JitCompiledFnData>,\n    purFnDeps: PureFnsDataCache,\n    depth = 0\n) {\n    if (depth >= MAX_STACK_DEPTH)\n        throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${jitFnHash}`);\n    const jitFn = getJitUtils().getJIT(jitFnHash);\n    if (!jitFn) throw new Error(`Jit function ${jitFnHash} not found`);\n    if (deps[jitFnHash]) return; // already serialized and prevent infinite recursion on circular dependencies\n    const serializedJitFn = getSerializableJitCompiler(jitFn);\n    deps[jitFnHash] = serializedJitFn;\n    jitFn.jitDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));\n    jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));\n}\n\nexport function serializeMethodDeps(\n    method: MethodWithOptions,\n    deps: Record<string, JitCompiledFnData>,\n    purFnDeps: PureFnsDataCache\n) {\n    const {paramsJitHash, returnJitHash} = method;\n    // Skip serialization for empty hashes (no params or void return)\n    // Always request binary hashes so they are included when available (e.g. middleware in binary routes).\n    // serializeJitFn is only called when the JIT function exists in the store, so non-binary methods are unaffected.\n    if (paramsJitHash !== EMPTY_HASH) {\n        const paramsJitHashes = getJitFnHashes(paramsJitHash, true);\n        for (const k in paramsJitHashes) {\n            if (getJitUtils().getJIT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);\n        }\n    }\n    if (returnJitHash !== EMPTY_HASH) {\n        const returnJitHashes = getJitFnHashes(returnJitHash, true);\n        let foundAny = false;\n        for (const k in returnJitHashes) {\n            if (getJitUtils().getJIT(returnJitHashes[k])) {\n                serializeJitFn(returnJitHashes[k], deps, purFnDeps);\n                foundAny = true;\n            }\n        }\n        if (!foundAny) {\n            throw new Error(\n                `Method \"${method.id}\" declares returnJitHash=\"${returnJitHash}\" but no JIT functions are registered under that hash. ` +\n                    `This usually means a Promise/Function return type was not unwrapped before computing the hash.`\n            );\n        }\n    }\n}\n\nfunction getSerializableJitCompiler(comp: JitCompiledFn): JitCompiledFnData {\n    return {\n        typeName: comp.typeName,\n        fnID: comp.fnID,\n        jitFnHash: comp.jitFnHash,\n        args: structuredClone(comp.args),\n        isNoop: comp.isNoop,\n        defaultParamValues: structuredClone(comp.defaultParamValues),\n        code: comp.code,\n        jitDependencies: comp.jitDependencies ? [...comp.jitDependencies] : undefined,\n        pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : undefined,\n        ...(comp.paramNames ? {paramNames: [...comp.paramNames]} : {}),\n    };\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/router.js

@@ -1,11 +1,11 @@
 import { DEFAULT_ROUTE_OPTIONS, MAX_ROUTE_NESTING, WORKFLOW_KEY } from "./constants.js";
 import { isHeadersMiddleFnDef, isRoute, isRawMiddleFnDef, isMiddleFnDef, isAnyMiddleFnDef, isRoutes, isExecutable, isPublicExecutable } from "./types/guards.js";
 import { MION_ROUTES, getRouterItemId, HandlerType, routesCache, setErrorOptions, isTestEnv, resetRoutesCache, isMionAOTEmitMode, getENV, isMionCompileMode, getRoutePath, SerializerModes } from "@mionjs/core";
-import { getHandlerReflection, getRawMethodReflection } from "./lib/reflection.js";
+import { getHandlerReflection, getRawMethodReflection, ensureBinaryJitFns } from "./lib/reflection.js";
 import { serializerMiddleFns } from "./routes/serializer.routes.js";
 import { getPublicApi, resetRemoteMethodsMetadata } from "./lib/remoteMethods.js";
 import { getPersistedMethod, addToPersistedMethods, resetPersistedMethods } from "./lib/methodsCache.js";
-import { mionClientRoutes } from "./routes/client.routes.js";
+import { mionClientMiddleFns, mionClientRoutes } from "./routes/client.routes.js";
 import { mionErrorsRoutes } from "./routes/errors.routes.js";
 import { clearRoutesFlowCache } from "./routesFlow.js";
 import { clearContextPool } from "./callContext.js";
@@ -25,6 +25,7 @@ const defaultStartMiddleFns = {
   mionDeserializeRequest: serializerMiddleFns.mionDeserializeRequest
 };
 const defaultEndMiddleFns = {
+  ...mionClientMiddleFns,
   mionSerializeResponse: serializerMiddleFns.mionSerializeResponse
 };
 let startMiddleFnsDef = { ...defaultStartMiddleFns };
@@ -97,7 +98,9 @@ async function registerRoutes(routes) {
   if (!isRouterInitialized) throw new Error("initRouter should be called first");
   startMiddleFns = await getExecutablesFromMiddleFnsCollection(startMiddleFnsDef);
   endMiddleFns = await getExecutablesFromMiddleFnsCollection(endMiddleFnsDef);
-  await recursiveFlatRoutes(routes);
+  const binaryMiddlewares = /* @__PURE__ */ new Set();
+  await recursiveFlatRoutes(routes, [], [], [], binaryMiddlewares, 0);
+  if (binaryMiddlewares.size > 0) await compileBinaryForMiddleware(binaryMiddlewares);
   if (shouldFullGenerateSpec()) {
     return getPublicApi(routes);
   }
@@ -165,7 +168,7 @@ async function emitAOTCaches() {
   const aotEmitter = await import("./lib/aotEmitter.js");
   return aotEmitter.emitAOTCaches();
 }
-async function recursiveFlatRoutes(routes, currentPointer = [], preMiddleFns = [], postMiddleFns = [], nestLevel = 0) {
+async function recursiveFlatRoutes(routes, currentPointer = [], preMiddleFns = [], postMiddleFns = [], binaryMiddlewares = /* @__PURE__ */ new Set(), nestLevel = 0) {
   if (nestLevel > MAX_ROUTE_NESTING)
     throw new Error("Too many nested routes, you can only nest routes ${MAX_ROUTE_NESTING} levels");
   const entries = Object.entries(routes);
@@ -204,11 +207,12 @@ async function recursiveFlatRoutes(routes, currentPointer = [], preMiddleFns = [
       const itemType = typeof item;
       throw new Error(`Invalid route: ${joinPath(...newPointer)}. Type <${itemType}> is not a valid route.`);
     }
-    minus1Props = await recursiveCreateExecutionChainAsync(
+    minus1Props = await recursiveCreateExecutionChain(
       routeEntry,
       newPointer,
       preMiddleFns,
       postMiddleFns,
+      binaryMiddlewares,
       nestLevel,
       index,
       entries,
@@ -217,7 +221,7 @@ async function recursiveFlatRoutes(routes, currentPointer = [], preMiddleFns = [
     complexity++;
   }
 }
-async function recursiveCreateExecutionChainAsync(routeEntry, currentPointer, preMiddleFns, postMiddleFns, nestLevel, index, routeKeyedEntries, minus1Props) {
+async function recursiveCreateExecutionChain(routeEntry, currentPointer, preMiddleFns, postMiddleFns, binaryMiddlewares, nestLevel, index, routeKeyedEntries, minus1Props) {
   const minus1 = getEntry(index - 1, routeKeyedEntries);
   const plus1 = getEntry(index + 1, routeKeyedEntries);
   const props = getRouteEntryProperties(minus1, routeEntry, plus1);
@@ -255,12 +259,20 @@ async function recursiveCreateExecutionChainAsync(routeEntry, currentPointer, pr
     const middleFnIds = getPublicMiddleFnIds(methods);
     if (middleFnIds.length) routeMethod.middleFnIds = middleFnIds;
     flatRouter.set(path, executionChain);
+    if (routeMethod.options.serializer === "binary") {
+      for (const method of methods) {
+        if (method.type === HandlerType.middleFn || method.type === HandlerType.headersMiddleFn) {
+          binaryMiddlewares.add(method.id);
+        }
+      }
+    }
   } else if (!isExec) {
     await recursiveFlatRoutes(
       routeEntry.routes,
       routeEntry.pathPointer,
       [...preMiddleFns, ...props.preLevelMiddleFns],
       [...props.postLevelMiddleFns, ...postMiddleFns],
+      binaryMiddlewares,
       nestLevel + 1
     );
   }
@@ -284,6 +296,7 @@ async function getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel) {
       middleFn.handler,
       middleFnId,
       routerOptions,
+      middleFn.options ?? {},
       isHeader,
       middleFn.options?.strictTypes
     );
@@ -331,6 +344,12 @@ async function getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel
   routesCache.setMethodJitFns(middleFnId, executable);
   return executable;
 }
+async function compileBinaryForMiddleware(binaryMiddlewareIds) {
+  for (const id of binaryMiddlewareIds) {
+    const method = middleFnsById.get(id);
+    if (method) await ensureBinaryJitFns(method);
+  }
+}
 async function getExecutableFromRoute(route, routePointer, nestLevel) {
   const routeId = getRouterItemId(routePointer);
   const existing = routesById.get(routeId);
@@ -340,10 +359,12 @@ async function getExecutableFromRoute(route, routePointer, nestLevel) {
   if (compiledMethod) {
     executable = compiledMethod;
   } else {
+    const resolvedRouteOptions = { ...route.options, serializer: route.options?.serializer ?? routerOptions.serializer };
     const reflectionData = await getHandlerReflection(
       route.handler,
       routeId,
       routerOptions,
+      resolvedRouteOptions,
       false,
       route.options?.strictTypes
     );
@@ -420,6 +441,8 @@ function getSerializerCodeFromMode(mode) {
       return SerializerModes.binary;
     case "stringifyJson":
       return SerializerModes.stringifyJson;
+    case "optimistic":
+      return SerializerModes.stringifyJson;
     case "json":
     default:
       return SerializerModes.json;