@mionjs/router 0.8.10 → 0.13.2

package/.dist/cjs/src/lib/reflection.cjs

@@ -1,374 +1,81 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_types_handlers = require("../types/handlers.cjs");
-const src_types_general = require("../types/general.cjs");
-const src_constants = require("../constants.cjs");
-const core = require("@mionjs/core");
-const src_lib_methodsCache = require("./methodsCache.cjs");
-const src_types_remoteMethods = require("../types/remoteMethods.cjs");
-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'];
-function __assignType(fn, args) {
-  fn.__type = args;
-  return fn;
-}
-const __ΩMethodReflect = [() => __ΩOmit, "MethodWithJitFns", "id", "type", "nestLevel", "pointer", "options", "MethodReflect", `"w"P.#.$.%.&.'Jo!#w(y`];
-class AOTCacheError extends Error {
-  constructor(routeId, type = "route") {
-    const typeLabel = type === "rawMiddleFn" ? "Raw middleFn" : type === "middleFn" ? "MiddleFn" : "Route/middleFn";
-    super(`${typeLabel} "${routeId}" not found in AOT cache.
-Regenerate AOT caches using 'mion-build-aot' command.`);
-    this.name = "AOTCacheError";
-  }
-  static __type = [() => Error, "routeId", "route", "middleFn", "rawMiddleFn", "type", () => "route", "constructor", "AOTCacheError", `P7!P&2"P.#.$.%J2&>'"0(5w)`];
-}
-const __ΩRunTypesModule = ["RunTypesModule", "!w!y"];
-const __ΩRunTypesFunctions = [() => __ΩRunTypesModule, "JitFunctions", "JitFunctions", () => __ΩRunTypesModule, "reflectFunction", "reflectFunction", () => __ΩRunTypesModule, "isUnionRunType", "isUnionRunType", () => __ΩRunTypesModule, "isClassRunType", "isClassRunType", () => __ΩRunTypesModule, "isLiteralRunType", "isLiteralRunType", () => __ΩRunTypesModule, "isNeverRunType", "isNeverRunType", "RunTypesFunctions", `Pn!."f4#n$.%f4&n'.(f4)n*.+f4,n-..f4/n0.1f42Mw3y`];
-let runTypesModule = null;
-let runTypesLoadPromise = null;
-async function loadRunTypesModule() {
-  if (runTypesModule)
-    return runTypesModule;
-  if (runTypesLoadPromise)
-    return runTypesLoadPromise;
-  runTypesLoadPromise = import("@mionjs/run-types").then(__assignType((module2) => {
-    runTypesModule = {
-      JitFunctions: module2.JitFunctions,
-      reflectFunction: module2.reflectFunction,
-      isUnionRunType: module2.isUnionRunType,
-      isClassRunType: module2.isClassRunType,
-      isLiteralRunType: module2.isLiteralRunType,
-      isNeverRunType: module2.isNeverRunType
-    };
-    return runTypesModule;
-  }, ["module", "", 'P"2!"/"']));
-  return runTypesLoadPromise;
-}
-loadRunTypesModule.__type = [() => __ΩRunTypesFunctions, "loadRunTypesModule", 'Pn!`/"'];
-function resetRunTypesCache() {
-  runTypesModule = null;
-  runTypesLoadPromise = null;
-}
-resetRunTypesCache.__type = ["resetRunTypesCache", "P$/!"];
-function resetReflectionCaches() {
-  rawMiddleFnReflectionCache.clear();
-}
-resetReflectionCaches.__type = ["resetReflectionCaches", "P$/!"];
-const rawMiddleFnReflectionCache = (Map.Ω = [["&"], [() => __ΩMethodReflect, "n!"]], /* @__PURE__ */ new Map());
-function createRawMiddleFnReflection(isAsync, hasReturnData = false, paramNames = []) {
-  const cacheKey = `${isAsync}_${hasReturnData}_${paramNames.join(",")}`;
-  const cached = rawMiddleFnReflectionCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const reflection = {
-    paramNames,
-    paramsJitFns: core.getNoopJitFns(),
-    returnJitFns: core.getNoopJitFns(),
-    paramsJitHash: core.EMPTY_HASH,
-    returnJitHash: core.EMPTY_HASH,
-    hasReturnData,
-    isAsync
-  };
-  rawMiddleFnReflectionCache.set(cacheKey, reflection);
-  return reflection;
-}
-createRawMiddleFnReflection.__type = ["isAsync", "hasReturnData", () => false, "paramNames", () => [], () => __ΩMethodReflect, "createRawMiddleFnReflection", `P)2!)2">#&F2$>%n&/'`];
-const __ΩCachedMethodMetadata = ["MethodMetadata", () => __ΩMethodReflect, "_cachedReflection", "CachedMethodMetadata", 'P"w!Pn"4#8MKw$y'];
-function extractReflectionFromCached(cached) {
-  if (cached._cachedReflection)
-    return cached._cachedReflection;
-  const reflectionItems = {
-    paramNames: cached.paramNames || [],
-    paramsJitFns: core.getJitFunctionsFromHash(cached.paramsJitHash),
-    returnJitFns: core.getJitFunctionsFromHash(cached.returnJitHash),
-    paramsJitHash: cached.paramsJitHash,
-    returnJitHash: cached.returnJitHash,
-    hasReturnData: cached.hasReturnData,
-    isAsync: cached.isAsync
-  };
-  if (cached.headersParam) {
-    reflectionItems.headersParam = {
-      headerNames: cached.headersParam.headerNames,
-      jitFns: core.getJitFunctionsFromHash(cached.headersParam.jitHash),
-      jitHash: cached.headersParam.jitHash
-    };
-  }
-  if (cached.headersReturn) {
-    reflectionItems.headersReturn = {
-      headerNames: cached.headersReturn.headerNames,
-      jitFns: core.getJitFunctionsFromHash(cached.headersReturn.jitHash),
-      jitHash: cached.headersReturn.jitHash
-    };
-  }
-  cached._cachedReflection = reflectionItems;
-  return reflectionItems;
-}
-extractReflectionFromCached.__type = [() => __ΩCachedMethodMetadata, "cached", () => __ΩMethodReflect, "extractReflectionFromCached", 'Pn!2"n#/$'];
-async function getHandlerReflection(handler, routeId, routerOptions, handlerOptions = {}, isHeadersMiddleFn = false, methodStrictTypes) {
-  const cached = src_lib_methodsCache.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, handlerOptions, isHeadersMiddleFn, rt, methodStrictTypes);
-}
-getHandlerReflection.__type = [() => src_types_handlers.__ΩHandler, "handler", "routeId", () => src_types_general.__ΩRouterOptions, "routerOptions", () => src_types_remoteMethods.__ΩRouteOptions, () => src_types_remoteMethods.__ΩMiddleFnOptions, () => src_types_remoteMethods.__Ω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 = src_lib_methodsCache.getPersistedMethodMetadata(routeId);
-  if (cached)
-    return createRawMiddleFnReflection(cached.isAsync, cached.hasReturnData, cached.paramNames || []);
-  if (routerOptions.aot)
-    return createRawMiddleFnReflection(true);
-  const rt = await loadRunTypesModule();
-  return generateRawMethodReflection(handler, routeId, rt);
-}
-getRawMethodReflection.__type = [() => src_types_handlers.__ΩHandler, "handler", "routeId", () => src_types_general.__ΩRouterOptions, "routerOptions", () => __ΩMethodReflect, "getRawMethodReflection", "Pn!2\"&2#n$2%n&`/'"];
-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 || src_constants.DEFAULT_ROUTE_OPTIONS.runTypeOptions,
-    ...effectiveStrictTypes !== void 0 ? { strictTypes: effectiveStrictTypes } : {}
-  };
-  try {
-    handlerRunType = rt.reflectFunction(handler);
-  } catch (error) {
-    throw new Error(`Can not get RunType of handler for route/middleFn "${routeId}." Error: ${error?.message}`);
-  }
-  const paramsSlice = isHeadersMiddleFn ? { start: src_constants.HEADER_HOOK_DEFAULT_PARAMS.length } : { start: src_constants.ROUTE_DEFAULT_PARAMS.length };
-  const paramsOpts = { ...runTypeOptions, paramsSlice };
-  try {
-    reflectionItems.paramNames = handlerRunType.getParameterNames(paramsOpts);
-    if (reflectionItems.paramNames.length === 0) {
-      reflectionItems.paramsJitHash = core.EMPTY_HASH;
-      reflectionItems.paramsJitFns = core.getNoopJitFns();
-    } else {
-      reflectionItems.paramsJitFns = getFunctionJitFns(handler, paramsOpts, rt, false, needsBinary);
-      reflectionItems.paramsJitHash = handlerRunType.getParameters().getJitHash(paramsOpts);
-    }
-  } catch (error) {
-    throw new Error(`Can not compile Jit Functions for Parameters of route/middleFn "${routeId}." Error: ${error?.message}`);
-  }
-  if (isHeadersMiddleFn) {
-    const headersRunType = getParamsHeadersRunType(handlerRunType, routeId, routerOptions, rt);
-    const headerNames = getHeaderNames(headersRunType, routeId, rt);
-    try {
-      const opts = {
-        ...runTypeOptions,
-        paramsSlice: void 0
-      };
-      const jitFns = getTypeJitFunctions(headersRunType, opts, rt, false);
-      const jitHash = headersRunType.getJitHash(opts);
-      reflectionItems.headersParam = { headerNames, jitFns, jitHash };
-    } catch (error) {
-      throw new Error(`Can not compile Jit Functions for Headers of Headers MiddleFn "${routeId}." Error: ${error?.message}`);
-    }
-  }
-  const returnHeadersRunType = getReturnHeadersRunType(handlerRunType, rt);
-  if (returnHeadersRunType) {
-    const opts = {};
-    const headerNames = getHeaderNames(returnHeadersRunType, routeId, rt);
-    const jitFns = getFunctionJitFns(handler, opts, rt, true, false);
-    const jitHash = returnHeadersRunType.getJitHash(opts);
-    reflectionItems.headersReturn = { headerNames, jitFns, jitHash };
-  }
-  const returnOpts = runTypeOptions;
-  reflectionItems.hasReturnData = handlerRunType.hasReturnData();
-  try {
-    if (!reflectionItems.hasReturnData) {
-      reflectionItems.returnJitFns = core.getNoopJitFns();
-      reflectionItems.returnJitHash = core.EMPTY_HASH;
-    } else {
-      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}`);
-  }
-  reflectionItems.isAsync = handlerRunType.isAsync();
-  return reflectionItems;
-}
-generateHandlerReflection.__type = [() => src_types_handlers.__ΩHandler, "handler", "routeId", () => src_types_general.__ΩRouterOptions, "routerOptions", () => src_types_remoteMethods.__ΩRouteOptions, () => src_types_remoteMethods.__ΩMiddleFnOptions, () => src_types_remoteMethods.__Ω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 {
-    handlerRunType = rt.reflectFunction(handler);
-  } catch (error) {
-    throw new Error(`Can not get RunType of handler for route/middleFn "${routeId}." Error: ${error?.message}`);
-  }
-  const isAsync = handlerRunType?.isAsync() || true;
-  return createRawMiddleFnReflection(isAsync);
-}
-generateRawMethodReflection.__type = [() => src_types_handlers.__ΩHandler, "handler", "routeId", () => __ΩRunTypesFunctions, "rt", () => __ΩMethodReflect, "generateRawMethodReflection", `Pn!2"&2#n$2%n&/'`];
-function getParamsHeadersRunType(handlerRunType, routeId, routerOptions, rt) {
-  const paramRunTypes = handlerRunType.getParameters().getParamRunTypes(getFakeCompiler(routerOptions));
-  const headersSubset = paramRunTypes[1]?.getMemberType?.();
-  if (!isHeaderSubSetRunType(headersSubset, rt)) {
-    throw new Error(`Headers MiddleFn '${routeId}' second parameter must be a HeadersSubset.`);
-  }
-  return headersSubset;
-}
-getParamsHeadersRunType.__type = ["FunctionRunType", "handlerRunType", "routeId", () => src_types_general.__ΩRouterOptions, "routerOptions", () => __ΩRunTypesFunctions, "rt", "BaseRunType", "getParamsHeadersRunType", `P"w!2"&2#n$2%n&2'"w(/)`];
-function getReturnHeadersRunType(handlerRunType, rt) {
-  const returnRunType = handlerRunType.getReturnType();
-  if (rt.isUnionRunType(returnRunType)) {
-    const headersSubset = returnRunType.getChildRunTypes().find(__assignType((child) => isHeaderSubSetRunType(child, rt), ["child", "", 'P"2!"/"']));
-    if (!headersSubset)
-      return void 0;
-    return headersSubset;
-  }
-  if (!isHeaderSubSetRunType(returnRunType, rt))
-    return void 0;
-  return returnRunType;
-}
-getReturnHeadersRunType.__type = ["FunctionRunType", "handlerRunType", () => __ΩRunTypesFunctions, "rt", "BaseRunType", "getReturnHeadersRunType", 'P"w!2"n#2$P"w%-J/&'];
-function isHeaderSubSetRunType(runType, rt) {
-  if (!runType)
-    return false;
-  return rt.isClassRunType(runType, core.HeadersSubset);
-}
-isHeaderSubSetRunType.__type = ["BaseRunType", "runType", () => __ΩRunTypesFunctions, "rt", "isHeaderSubSetRunType", 'PP"w!-J2"n#2$!/%'];
-function getHeaderNames(runType, routeId, rt) {
-  const typeArguments = runType.src.typeArguments;
-  if (!typeArguments || typeArguments.length === 0) {
-    throw new Error(`HeadersSubset must have type arguments in route/middleFn ${routeId}`);
-  }
-  const headerNames = [];
-  const requiredArg = typeArguments[0];
-  if (requiredArg) {
-    const requiredNames = extractLiteralStringsFromType(requiredArg._rt, rt);
-    headerNames.push(...requiredNames);
-  }
-  if (typeArguments.length > 1) {
-    const optionalArg = typeArguments[1];
-    if (optionalArg) {
-      const optionalNames = extractLiteralStringsFromType(optionalArg._rt, rt);
-      headerNames.push(...optionalNames);
-    }
-  }
-  if (headerNames.length === 0)
-    throw new Error(`Header names array cannot be empty in route/middleFn ${routeId}`);
-  return headerNames;
-}
-getHeaderNames.__type = ["BaseRunType", "runType", "routeId", () => __ΩRunTypesFunctions, "rt", "getHeaderNames", 'P"w!2"&2#n$2%&F/&'];
-function extractLiteralStringsFromTypeRecursive(runType, rt) {
-  if (rt.isLiteralRunType(runType)) {
-    const literal = runType.getLiteralValue();
-    if (typeof literal === "string") {
-      return [literal];
-    }
-    return [];
-  }
-  if (rt.isUnionRunType(runType)) {
-    const children = runType.getChildRunTypes();
-    const literals = [];
-    for (const child of children) {
-      const childLiterals = extractLiteralStringsFromTypeRecursive(child, rt);
-      literals.push(...childLiterals);
-    }
-    return literals;
-  }
-  return [];
-}
-extractLiteralStringsFromTypeRecursive.__type = ["BaseRunType", "runType", () => __ΩRunTypesFunctions, "rt", "extractLiteralStringsFromTypeRecursive", 'P"w!2"n#2$&F/%'];
-function extractLiteralStringsFromType(runType, rt) {
-  if (rt.isNeverRunType(runType))
-    return [];
-  return extractLiteralStringsFromTypeRecursive(runType, rt);
-}
-extractLiteralStringsFromType.__type = ["BaseRunType", "runType", () => __ΩRunTypesFunctions, "rt", "extractLiteralStringsFromType", 'P"w!2"n#2$&F/%'];
-function getFakeCompiler(routerOptions) {
-  return { opts: routerOptions };
-}
-getFakeCompiler.__type = [() => src_types_general.__ΩRouterOptions, "routerOptions", "JitFnCompiler", "getFakeCompiler", 'Pn!2""w#/$'];
-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),
-    ...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", "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, needsBinary = false) {
-  let runType = functionRunTypeCache.get(fn);
-  if (!runType) {
-    runType = rtModule.reflectFunction(fn);
-    functionRunTypeCache.set(fn, runType);
-  }
-  const createFn = isReturn ? runType.createJitCompiledReturnFunction.bind(runType) : runType.createJitCompiledParamsFunction.bind(runType);
-  const jitFunctions = {
-    isType: createFn(rtModule.JitFunctions.isType, opts),
-    typeErrors: createFn(rtModule.JitFunctions.typeErrors, opts),
-    prepareForJson: createFn(rtModule.JitFunctions.prepareForJson, opts),
-    restoreFromJson: createFn(rtModule.JitFunctions.restoreFromJson, opts),
-    stringifyJson: createFn(rtModule.JitFunctions.stringifyJson, opts),
-    ...needsBinary ? {
-      toBinary: createFn(rtModule.JitFunctions.toBinary, opts),
-      fromBinary: createFn(rtModule.JitFunctions.fromBinary, opts)
-    } : {}
-  };
-  return jitFunctions;
-}
-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 === core.HandlerType.headersMiddleFn;
-  const paramsSlice = isHeader ? { start: src_constants.HEADER_HOOK_DEFAULT_PARAMS.length } : { start: src_constants.ROUTE_DEFAULT_PARAMS.length };
-  const opts = { paramsSlice };
-  if (!method.paramsJitFns.toBinary && method.paramsJitHash !== core.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 !== core.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 = [() => src_types_remoteMethods.__ΩMiddleFnMethod, () => src_types_remoteMethods.__ΩHeadersMethod, "method", "ensureBinaryJitFns", 'PPn!n"J2#$`/$'];
-exports.AOTCacheError = AOTCacheError;
-exports.ensureBinaryJitFns = ensureBinaryJitFns;
+let _mionjs_core = require("@mionjs/core");
+//#region src/lib/reflection.ts
+/** The definition carries no injected type information: it was built or run without the mion plugin active. */
+var MissingRtFnsError = class extends Error {
+	constructor(routeId, cause) {
+		super(`Route/middleware "${routeId}" has no build-time type information.\nDeclare it through route()/middleware() and make sure mionVitePlugin (@mionjs/devtools) is active in the build.` + (cause ? `\nCause: ${cause}` : ""));
+		this.name = "MissingRtFnsError";
+	}
+};
+/** The injected type information IS present but the host forbids building functions from strings (workerd,
+*  Vercel's EdgeVM, a CSP without 'unsafe-eval'). A BUILD-CONFIG problem, not a missing-plugin one. */
+var RuntimeCodeGenBlockedError = class extends Error {
+	constructor(routeId, cause) {
+		super(`Route/middleware "${routeId}" carries build-time type information, but this runtime forbids compiling functions from strings.\nBuild with \`mionVitePlugin({runTypes: {emitMode: 'both'}})\`: the default 'code' ships each compiled fn as a source string that is turned into a function on first use, which edge runtimes (Cloudflare Workers / workerd, Vercel Edge) refuse. 'both' also emits the live factory, so nothing is compiled at runtime.` + (cause ? `\nCause: ${cause}` : ""));
+		this.name = "RuntimeCodeGenBlockedError";
+	}
+};
+var CODE_GEN_BLOCKED = /code generation from strings|unsafe-eval/i;
+/** True when an error from the mion runtime is a blocked `new Function`, not a missing payload. */
+function isCodeGenBlocked(message) {
+	return !!message && CODE_GEN_BLOCKED.test(message);
+}
+var rawMiddlewareReflectionCache = (0, _mionjs_core.getOrCreateGlobal)("mion.reflection.rawMiddlewareReflectionCache", () => /* @__PURE__ */ new Map());
+/** Creates a MethodReflect for raw middlewares: no type info, NoopJitFns. */
+function createRawMiddlewareReflection(isAsync, hasReturnData = false, paramsCount = 0) {
+	const cacheKey = `${isAsync}_${hasReturnData}_${paramsCount}`;
+	const cached = rawMiddlewareReflectionCache.get(cacheKey);
+	if (cached) return cached;
+	const reflection = {
+		paramsCount,
+		paramsJitFns: (0, _mionjs_core.getNoopJitFns)(),
+		returnJitFns: (0, _mionjs_core.getNoopJitFns)(),
+		paramsJitHash: _mionjs_core.EMPTY_HASH,
+		returnJitHash: _mionjs_core.EMPTY_HASH,
+		hasReturnData,
+		isAsync
+	};
+	rawMiddlewareReflectionCache.set(cacheKey, reflection);
+	return reflection;
+}
+/** All data derives from the mion marker payload the factory stashed on the definition (`def.rtFns`);
+*  registration fails loudly when that payload is missing (plugin not active). */
+function getHandlerReflection(def, routeId, routerOptions, handlerOptions = {}, isHeadersMiddleware = false) {
+	try {
+		return isHeadersMiddleware ? (0, _mionjs_core.getHeadersReflectionFromMarkers)(def.rtFns, def.handler, routeId) : (0, _mionjs_core.getReflectionFromMarkers)(def.rtFns, def.handler, routeId);
+	} catch (error) {
+		if (isCodeGenBlocked(error?.message)) throw new RuntimeCodeGenBlockedError(routeId, error.message);
+		throw new MissingRtFnsError(routeId, error?.message);
+	}
+}
+/** Raw middlewares parse the raw request / response themselves, so they carry no type info. */
+function getRawMethodReflection(handler, routeId, routerOptions) {
+	return createRawMiddlewareReflection((0, _mionjs_core.isAsyncHandler)(handler));
+}
+/** Checks each direction's compiled strategy against the resolved one: they differ only when the
+*  build saw a different literal than the runtime value. */
+function assertCompiledParser(methodId, parser, reflection) {
+	const sides = [[
+		"params",
+		reflection.paramsJitHash,
+		reflection.paramsJitFns
+	], [
+		"return",
+		reflection.returnJitHash,
+		reflection.returnJitFns
+	]];
+	for (const [direction, hash, fns] of sides) {
+		if (hash === _mionjs_core.EMPTY_HASH) continue;
+		const wanted = parser[direction];
+		if (fns.json.strategy !== wanted) throw new Error(`mion: ${direction} parser of "${methodId}" is '${wanted}' at runtime but the build compiled '${fns.json.strategy}'. Write the parser option inline on the route (or as an \`as const\` preset) and the router-wide default as a literal on createMionRouter, so the build sees the same value the runtime reads.`);
+	}
+}
+//#endregion
+exports.MissingRtFnsError = MissingRtFnsError;
+exports.RuntimeCodeGenBlockedError = RuntimeCodeGenBlockedError;
+exports.assertCompiledParser = assertCompiledParser;
 exports.getHandlerReflection = getHandlerReflection;
 exports.getRawMethodReflection = getRawMethodReflection;
-exports.resetReflectionCaches = resetReflectionCaches;
-exports.resetRunTypesCache = resetRunTypesCache;
-//# sourceMappingURL=reflection.cjs.map
+
+//# sourceMappingURL=reflection.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"reflection.cjs","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":["module","getNoopJitFns","EMPTY_HASH","getJitFunctionsFromHash","getPersistedMethodMetadata","DEFAULT_ROUTE_OPTIONS","HEADER_HOOK_DEFAULT_PARAMS","ROUTE_DEFAULT_PARAMS","HeadersSubset","HandlerType"],"mappings":"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"}
+{"version":3,"file":"reflection.cjs","names":[],"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} from '@mionjs/core';\nimport {EMPTY_HASH, getNoopJitFns, getOrCreateGlobal, type ResolvedParser} from '@mionjs/core';\nimport {getHeadersReflectionFromMarkers, getReflectionFromMarkers, isAsyncHandler} from '@mionjs/core';\nimport {Handler} from '../types/handlers.ts';\nimport {RouterOptions} from '../types/general.ts';\nimport {RouteOptions, MiddlewareOptions} from '../types/remoteMethods.ts';\nimport {AnyHandlerDef, RawMiddlewareDef} from '../types/definitions.ts';\n\n// ############ This file is the only one consuming type reflection within the router ########\n// All type information is injected AT BUILD TIME into the route()/middleware() call sites (lib/handlers.ts)\n// and this module only adapts those payloads into the MethodReflect shape the router consumes. No runtime\n// reflection, no JIT compilation, no AOT cache: the modules the mion vite plugin emits ARE the artifacts.\n\ntype MethodReflect = Omit<MethodWithJitFns, 'id' | 'type' | 'nestLevel' | 'pointer' | 'options'>;\n\n/** The definition carries no injected type information: it was built or run without the mion plugin active. */\nexport class MissingRtFnsError extends Error {\n  constructor(routeId: string, cause?: string) {\n    super(\n      `Route/middleware \"${routeId}\" has no build-time type information.\\n` +\n        `Declare it through route()/middleware() and make sure mionVitePlugin (@mionjs/devtools) is active in the build.` +\n        (cause ? `\\nCause: ${cause}` : '')\n    );\n    this.name = 'MissingRtFnsError';\n  }\n}\n\n/** The injected type information IS present but the host forbids building functions from strings (workerd,\n *  Vercel's EdgeVM, a CSP without 'unsafe-eval'). A BUILD-CONFIG problem, not a missing-plugin one. */\nexport class RuntimeCodeGenBlockedError extends Error {\n  constructor(routeId: string, cause?: string) {\n    super(\n      `Route/middleware \"${routeId}\" carries build-time type information, but this runtime forbids ` +\n        `compiling functions from strings.\\n` +\n        `Build with \\`mionVitePlugin({runTypes: {emitMode: 'both'}})\\`: the default 'code' ships each ` +\n        `compiled fn as a source string that is turned into a function on first use, which edge ` +\n        `runtimes (Cloudflare Workers / workerd, Vercel Edge) refuse. 'both' also emits the live ` +\n        `factory, so nothing is compiled at runtime.` +\n        (cause ? `\\nCause: ${cause}` : '')\n    );\n    this.name = 'RuntimeCodeGenBlockedError';\n  }\n}\n\n// workerd: \"Code generation from strings disallowed for this context\"; V8/EdgeVM with a CSP:\n// \"Code generation from strings disallowed\"/\"unsafe-eval\". Matched on the shared stem so both land.\nconst CODE_GEN_BLOCKED = /code generation from strings|unsafe-eval/i;\n\n/** True when an error from the mion runtime is a blocked `new Function`, not a missing payload. */\nfunction isCodeGenBlocked(message?: string): boolean {\n  return !!message && CODE_GEN_BLOCKED.test(message);\n}\n\n// ############ Raw Middleware Reflection ############\n\nconst rawMiddlewareReflectionCache = getOrCreateGlobal(\n  'mion.reflection.rawMiddlewareReflectionCache',\n  () => new Map<string, MethodReflect>()\n);\n\n/** Creates a MethodReflect for raw middlewares: no type info, NoopJitFns. */\nfunction createRawMiddlewareReflection(isAsync: boolean, hasReturnData: boolean = false, paramsCount: number = 0): MethodReflect {\n  const cacheKey = `${isAsync}_${hasReturnData}_${paramsCount}`;\n  const cached = rawMiddlewareReflectionCache.get(cacheKey);\n  if (cached) return cached;\n\n  const reflection: MethodReflect = {\n    paramsCount,\n    paramsJitFns: getNoopJitFns(),\n    returnJitFns: getNoopJitFns(),\n    paramsJitHash: EMPTY_HASH,\n    returnJitHash: EMPTY_HASH,\n    hasReturnData,\n    isAsync,\n  };\n\n  rawMiddlewareReflectionCache.set(cacheKey, reflection);\n  return reflection;\n}\n\n// ############ Main Reflection Functions ############\n\n/** Definitions that carry an injected `rtFns` payload. RawMiddlewareDef is excluded: a raw\n *  middleware declares no extra params, so it has no reflection and goes through\n *  getRawMethodReflection instead. */\ntype ReflectableDef = Exclude<AnyHandlerDef, RawMiddlewareDef>;\n\n/** All data derives from the mion marker payload the factory stashed on the definition (`def.rtFns`);\n *  registration fails loudly when that payload is missing (plugin not active). */\nexport function getHandlerReflection(\n  def: ReflectableDef,\n  routeId: string,\n  routerOptions: RouterOptions,\n  // handlerOptions stays unused here: what a route compiles is decided at build time by its parser strategy.\n  handlerOptions: RouteOptions | MiddlewareOptions = {}, // eslint-disable-line @typescript-eslint/no-unused-vars\n  isHeadersMiddleware: boolean = false\n): MethodReflect {\n  try {\n    return isHeadersMiddleware\n      ? getHeadersReflectionFromMarkers(def.rtFns, def.handler, routeId)\n      : getReflectionFromMarkers(def.rtFns, def.handler, routeId);\n  } catch (error: any) {\n    if (isCodeGenBlocked(error?.message)) throw new RuntimeCodeGenBlockedError(routeId, error.message);\n    throw new MissingRtFnsError(routeId, error?.message);\n  }\n}\n\n/** Raw middlewares parse the raw request / response themselves, so they carry no type info. */\nexport function getRawMethodReflection(\n  handler: Handler,\n  routeId: string, // eslint-disable-line @typescript-eslint/no-unused-vars\n  routerOptions: RouterOptions // eslint-disable-line @typescript-eslint/no-unused-vars\n): MethodReflect {\n  return createRawMiddlewareReflection(isAsyncHandler(handler));\n}\n\n/** Checks each direction's compiled strategy against the resolved one: they differ only when the\n *  build saw a different literal than the runtime value. */\nexport function assertCompiledParser(methodId: string, parser: ResolvedParser, reflection: MethodReflect): void {\n  const sides = [\n    ['params', reflection.paramsJitHash, reflection.paramsJitFns],\n    ['return', reflection.returnJitHash, reflection.returnJitFns],\n  ] as const;\n  for (const [direction, hash, fns] of sides) {\n    if (hash === EMPTY_HASH) continue;\n    const wanted = parser[direction];\n    if (fns.json.strategy !== wanted)\n      throw new Error(\n        `mion: ${direction} parser of \"${methodId}\" is '${wanted}' at runtime but the build compiled ` +\n          `'${fns.json.strategy}'. Write the parser option inline on the route (or as an \\`as const\\` preset) and the ` +\n          `router-wide default as a literal on createMionRouter, so the build sees the same value the runtime reads.`\n      );\n  }\n}\n"],"mappings":";;;;AAuBA,IAAa,oBAAb,cAAuC,MAAM;CAC3C,YAAY,SAAiB,OAAgB;EAC3C,MACE,qBAAqB,QAAQ,2JAE1B,QAAQ,YAAY,UAAU,GACnC;EACA,KAAK,OAAO;CACd;AACF;;;AAIA,IAAa,6BAAb,cAAgD,MAAM;CACpD,YAAY,SAAiB,OAAgB;EAC3C,MACE,qBAAqB,QAAQ,+ZAM1B,QAAQ,YAAY,UAAU,GACnC;EACA,KAAK,OAAO;CACd;AACF;AAIA,IAAM,mBAAmB;;AAGzB,SAAS,iBAAiB,SAA2B;CACnD,OAAO,CAAC,CAAC,WAAW,iBAAiB,KAAK,OAAO;AACnD;AAIA,IAAM,gCAAA,GAAA,aAAA,mBACJ,sEACM,IAAI,IAA2B,CACvC;;AAGA,SAAS,8BAA8B,SAAkB,gBAAyB,OAAO,cAAsB,GAAkB;CAC/H,MAAM,WAAW,GAAG,QAAQ,GAAG,cAAc,GAAG;CAChD,MAAM,SAAS,6BAA6B,IAAI,QAAQ;CACxD,IAAI,QAAQ,OAAO;CAEnB,MAAM,aAA4B;EAChC;EACA,eAAA,GAAA,aAAA,eAA4B;EAC5B,eAAA,GAAA,aAAA,eAA4B;EAC5B,eAAe,aAAA;EACf,eAAe,aAAA;EACf;EACA;CACF;CAEA,6BAA6B,IAAI,UAAU,UAAU;CACrD,OAAO;AACT;;;AAWA,SAAgB,qBACd,KACA,SACA,eAEA,iBAAmD,CAAC,GACpD,sBAA+B,OAChB;CACf,IAAI;EACF,OAAO,uBAAA,GAAA,aAAA,iCAC6B,IAAI,OAAO,IAAI,SAAS,OAAO,KAAA,GAAA,aAAA,0BACtC,IAAI,OAAO,IAAI,SAAS,OAAO;CAC9D,SAAS,OAAY;EACnB,IAAI,iBAAiB,OAAO,OAAO,GAAG,MAAM,IAAI,2BAA2B,SAAS,MAAM,OAAO;EACjG,MAAM,IAAI,kBAAkB,SAAS,OAAO,OAAO;CACrD;AACF;;AAGA,SAAgB,uBACd,SACA,SACA,eACe;CACf,OAAO,+BAAA,GAAA,aAAA,gBAA6C,OAAO,CAAC;AAC9D;;;AAIA,SAAgB,qBAAqB,UAAkB,QAAwB,YAAiC;CAC9G,MAAM,QAAQ,CACZ;EAAC;EAAU,WAAW;EAAe,WAAW;CAAY,GAC5D;EAAC;EAAU,WAAW;EAAe,WAAW;CAAY,CAC9D;CACA,KAAK,MAAM,CAAC,WAAW,MAAM,QAAQ,OAAO;EAC1C,IAAI,SAAS,aAAA,YAAY;EACzB,MAAM,SAAS,OAAO;EACtB,IAAI,IAAI,KAAK,aAAa,QACxB,MAAM,IAAI,MACR,SAAS,UAAU,cAAc,SAAS,QAAQ,OAAO,uCACnD,IAAI,KAAK,SAAS,gMAE1B;CACJ;AACF"}

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

@@ -1,15 +1,18 @@
-import { MethodWithJitFns } from '@mionjs/core';
+import { MethodWithJitFns, ResolvedParser } from '@mionjs/core';
 import { Handler } from '../types/handlers.ts';
 import { RouterOptions } from '../types/general.ts';
-import { RouteOptions, MiddleFnOptions, HeadersMiddleFnOptions, MiddleFnMethod, HeadersMethod } from '../types/remoteMethods.ts';
+import { RouteOptions, MiddlewareOptions } from '../types/remoteMethods.ts';
+import { AnyHandlerDef, RawMiddlewareDef } from '../types/definitions.ts';
 type MethodReflect = Omit<MethodWithJitFns, 'id' | 'type' | 'nestLevel' | 'pointer' | 'options'>;
-export declare class AOTCacheError extends Error {
-    constructor(routeId: string, type?: 'route' | 'middleFn' | 'rawMiddleFn');
+export declare class MissingRtFnsError extends Error {
+    constructor(routeId: string, cause?: string);
 }
-export declare function resetRunTypesCache(): void;
-export declare function resetReflectionCaches(): void;
-export declare function getHandlerReflection(handler: Handler, routeId: string, routerOptions: RouterOptions, handlerOptions?: RouteOptions | MiddleFnOptions | HeadersMiddleFnOptions, isHeadersMiddleFn?: boolean, methodStrictTypes?: boolean): Promise<MethodReflect>;
-export declare function getRawMethodReflection(handler: Handler, routeId: string, routerOptions: RouterOptions): Promise<MethodReflect>;
-export declare function ensureBinaryJitFns(method: MiddleFnMethod | HeadersMethod): Promise<void>;
+export declare class RuntimeCodeGenBlockedError extends Error {
+    constructor(routeId: string, cause?: string);
+}
+type ReflectableDef = Exclude<AnyHandlerDef, RawMiddlewareDef>;
+export declare function getHandlerReflection(def: ReflectableDef, routeId: string, routerOptions: RouterOptions, handlerOptions?: RouteOptions | MiddlewareOptions, isHeadersMiddleware?: boolean): MethodReflect;
+export declare function getRawMethodReflection(handler: Handler, routeId: string, routerOptions: RouterOptions): MethodReflect;
+export declare function assertCompiledParser(methodId: string, parser: ResolvedParser, reflection: MethodReflect): void;
 export {};
 //# sourceMappingURL=reflection.d.ts.map