@mionjs/router 0.8.10 → 0.13.0

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

@@ -1 +1 @@
-{"version":3,"file":"headers.js","sources":["../../../../src/lib/headers.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {MionHeaders} from '../types/context.ts';\n\n// ############# PUBLIC METHODS #############\n\ntype HeadersRecord = Record<string, string>;\n\n/**\n * Reusable class for managing HTTP headers with case-insensitive access\n * Similar to the fetch Headers API but optimized for performance\n * https://developer.mozilla.org/en-US/docs/Web/API/Headers\n */\nclass MionHeadersImpl implements MionHeaders {\n    constructor(private headers: HeadersRecord) {}\n\n    append(name: string, value: string): void {\n        const nl = name.toLowerCase();\n        const existing = this.headers[nl];\n        const headerValue = toSingleHeader(value);\n        if (existing) {\n            this.headers[nl] = `${existing}, ${headerValue}`;\n        } else {\n            this.headers[nl] = headerValue;\n        }\n    }\n\n    delete(name: string): void {\n        const nl = name.toLowerCase();\n        delete this.headers[nl];\n    }\n\n    get(name: string): string | undefined | null {\n        const nl = name.toLowerCase();\n        return this.headers[nl];\n    }\n\n    set(name: string, value: string): void {\n        const ln = name.toLowerCase();\n        this.headers[ln] = value as string;\n    }\n\n    has(name: string): boolean {\n        const nl = name.toLowerCase();\n        return !!this.headers[nl];\n    }\n\n    entries(): IterableIterator<[string, string]> {\n        return new Map(Object.entries(this.headers)).entries();\n    }\n\n    keys(): IterableIterator<string> {\n        return new Map(Object.entries(this.headers)).keys();\n    }\n\n    values(): IterableIterator<string> {\n        return new Map(Object.entries(this.headers)).values();\n    }\n}\n\n/**\n * Return a Headers Like object from a Headers Record structure (Record<string, string | string[]>)\n * Returned Headers object is similar to the fetch Headers object but not exactly the same\n * https://developer.mozilla.org/en-US/docs/Web/API/Headers\n *\n * This is optimized to avoid creating the Headers Map if it's not strictly needed.\n * ie. for incoming header that only use get method, the Headers object is never created and instead the HeadersRecord is used directly.\n *\n * This function can be used to create a Headers object from incoming request that has the headers in an object structure.\n * ie IncomingMessage.headers or ApiGatewayEvent.headers\n *\n * @param headersObj\n * @returns\n */\nexport function headersFromRecord(headersObj: Record<string, string>, skipToLower = false): MionHeaders {\n    // lazy load headers map\n    const headers = parseHeaders(headersObj, skipToLower);\n    return new MionHeadersImpl(headers);\n}\n\nfunction toSingleHeader(value: string | number): string {\n    if (Array.isArray(value)) return value.join(', ');\n    return value as string;\n}\n\nfunction parseHeaders(headersObj: Record<string, string>, skipToLower = false): HeadersRecord {\n    if (skipToLower) return headersObj;\n    const entries = Object.entries(headersObj);\n    const headers: HeadersRecord = {};\n    for (let i = 0; i < entries.length; i++) {\n        const [name, value] = entries[i];\n        if (!value) continue;\n        const ln = name.toLowerCase();\n        headers[ln] = toSingleHeader(value);\n    }\n    return headers;\n}\n"],"names":[],"mappings":"AAkBA,MAAM,gBAAuC;AAAA,EACzC,YAAoB,SAAwB;AAAxB,SAAA,UAAA;AAAA,EAAyB;AAAA,EAE7C,OAAO,MAAc,OAAqB;AACtC,UAAM,KAAK,KAAK,YAAA;AAChB,UAAM,WAAW,KAAK,QAAQ,EAAE;AAChC,UAAM,cAAc,eAAe,KAAK;AACxC,QAAI,UAAU;AACV,WAAK,QAAQ,EAAE,IAAI,GAAG,QAAQ,KAAK,WAAW;AAAA,IAClD,OAAO;AACH,WAAK,QAAQ,EAAE,IAAI;AAAA,IACvB;AAAA,EACJ;AAAA,EAEA,OAAO,MAAoB;AACvB,UAAM,KAAK,KAAK,YAAA;AAChB,WAAO,KAAK,QAAQ,EAAE;AAAA,EAC1B;AAAA,EAEA,IAAI,MAAyC;AACzC,UAAM,KAAK,KAAK,YAAA;AAChB,WAAO,KAAK,QAAQ,EAAE;AAAA,EAC1B;AAAA,EAEA,IAAI,MAAc,OAAqB;AACnC,UAAM,KAAK,KAAK,YAAA;AAChB,SAAK,QAAQ,EAAE,IAAI;AAAA,EACvB;AAAA,EAEA,IAAI,MAAuB;AACvB,UAAM,KAAK,KAAK,YAAA;AAChB,WAAO,CAAC,CAAC,KAAK,QAAQ,EAAE;AAAA,EAC5B;AAAA,EAEA,UAA8C;AAC1C,WAAO,IAAI,IAAI,OAAO,QAAQ,KAAK,OAAO,CAAC,EAAE,QAAA;AAAA,EACjD;AAAA,EAEA,OAAiC;AAC7B,WAAO,IAAI,IAAI,OAAO,QAAQ,KAAK,OAAO,CAAC,EAAE,KAAA;AAAA,EACjD;AAAA,EAEA,SAAmC;AAC/B,WAAO,IAAI,IAAI,OAAO,QAAQ,KAAK,OAAO,CAAC,EAAE,OAAA;AAAA,EACjD;AACJ;AAgBO,SAAS,kBAAkB,YAAoC,cAAc,OAAoB;AAEpG,QAAM,UAAU,aAAa,YAAY,WAAW;AACpD,SAAO,IAAI,gBAAgB,OAAO;AACtC;AAEA,SAAS,eAAe,OAAgC;AACpD,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,MAAM,KAAK,IAAI;AAChD,SAAO;AACX;AAEA,SAAS,aAAa,YAAoC,cAAc,OAAsB;AAC1F,MAAI,YAAa,QAAO;AACxB,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,QAAM,UAAyB,CAAA;AAC/B,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACrC,UAAM,CAAC,MAAM,KAAK,IAAI,QAAQ,CAAC;AAC/B,QAAI,CAAC,MAAO;AACZ,UAAM,KAAK,KAAK,YAAA;AAChB,YAAQ,EAAE,IAAI,eAAe,KAAK;AAAA,EACtC;AACA,SAAO;AACX;"}
+{"version":3,"file":"headers.js","names":[],"sources":["../../../../src/lib/headers.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {MionHeaders, MionResponse, PooledHeaders, ResponseDefaults} from '../types/context.ts';\nimport {JSON_CONTENT_TYPE} from '../constants.ts';\nimport {getResponseDefaults} from '../router.ts';\n\n// ############# PUBLIC METHODS #############\n\n// an array for a name appended twice on response headers (node's request record may hold one too)\ntype HeadersRecord = Record<string, string | string[]>;\n\nconst PROTO_KEY = '__proto__';\n\n/** Case-insensitive HTTP headers, like the fetch Headers API but optimized for performance.\n *  https://developer.mozilla.org/en-US/docs/Web/API/Headers */\nclass MionHeadersImpl implements MionHeaders {\n  // The record may be a plain object handed over by the platform (node's IncomingMessage.headers is one),\n  // where `constructor` or `toString` would be \"found\" on the prototype chain. A prototype hit is never a\n  // string, so a read checks the VALUE's type: cheaper than an own-key check per read (14 vs 23 ns).\n  // `__proto__` is never written: on a plain object that assignment swaps the prototype.\n  /** Read by the response headers pool only; request headers ignore it. */\n  unused = true;\n\n  constructor(protected headers: HeadersRecord) {}\n\n  append(name: string, value: string): void {\n    this.unused = false;\n    const nl = name.toLowerCase();\n    if (nl === PROTO_KEY) return;\n    const existing = readHeader(this.headers, nl);\n    const headerValue = toSingleHeader(value);\n    if (existing) {\n      this.headers[nl] = `${existing}, ${headerValue}`;\n    } else {\n      this.headers[nl] = headerValue;\n    }\n  }\n\n  delete(name: string): void {\n    this.unused = false;\n    delete this.headers[name.toLowerCase()];\n  }\n\n  get(name: string): string | undefined | null {\n    return readHeader(this.headers, name.toLowerCase());\n  }\n\n  set(name: string, value: string): void {\n    this.unused = false;\n    const ln = name.toLowerCase();\n    if (ln === PROTO_KEY) return;\n    this.headers[ln] = value as string;\n  }\n\n  has(name: string): boolean {\n    return !!readHeader(this.headers, name.toLowerCase());\n  }\n\n  entries(): IterableIterator<[string, string]> {\n    return Object.entries(this.headers)\n      .map(([name, value]): [string, string] => [name, joined(value)])\n      .values();\n  }\n\n  keys(): IterableIterator<string> {\n    return new Map(Object.entries(this.headers)).keys();\n  }\n\n  values(): IterableIterator<string> {\n    return Object.values(this.headers).map(joined).values();\n  }\n}\n\n/** Response headers over a copy of the defaults, for an adapter that answers from a header record (uws, aws). */\nexport class RecordResponseHeaders extends MionHeadersImpl implements PooledHeaders {\n  constructor(readonly defaults: ResponseDefaults) {\n    super({...defaults});\n  }\n\n  /** Keeps a repeated name's values apart, never joined: the adapter writes them its own way. */\n  append(name: string, value: string): void {\n    this.unused = false;\n    const key = name.toLowerCase();\n    if (key === PROTO_KEY) return;\n    const current = this.headers[key] as unknown;\n    // an empty earlier value counts as absent, and so does a prototype hit such as `constructor`\n    if (Array.isArray(current)) current.push(value);\n    else if (typeof current === 'string' && current) this.headers[key] = [current, value];\n    else this.headers[key] = value;\n  }\n\n  /** Walks the headers with no pair array per header; a repeated name gives its values apart. */\n  forEach(visit: (name: string, value: string | string[]) => void): void {\n    for (const name in this.headers) visit(name, this.headers[name]);\n  }\n}\n\n/** The response headers of the fetch adapters (bun, cloudflare, vercel). */\nexport class FetchResponseHeaders implements PooledHeaders {\n  /** What the reply hands to `Response`, which copies it. */\n  readonly native = new Headers();\n  unused = true;\n\n  constructor(readonly defaults: ResponseDefaults) {\n    // one set per name beats building from a record\n    for (const name in defaults) this.native.set(name, defaults[name]);\n  }\n\n  set(name: string, value: string): void {\n    this.unused = false;\n    this.native.set(name, value);\n  }\n  append(name: string, value: string): void {\n    this.unused = false;\n    this.native.append(name, value);\n  }\n  delete(name: string): void {\n    this.unused = false;\n    this.native.delete(name);\n  }\n  get(name: string): string | null {\n    return this.native.get(name);\n  }\n  has(name: string): boolean {\n    return this.native.has(name);\n  }\n  entries(): IterableIterator<[string, string]> {\n    return this.native.entries();\n  }\n  keys(): IterableIterator<string> {\n    return this.native.keys();\n  }\n  values(): IterableIterator<string> {\n    return this.native.values();\n  }\n}\n\n// Pools of unwritten response headers: one serves exactly one request and comes back only if still unused.\nconst MAX_UNUSED_HEADERS = 256;\nconst unusedRecordHeaders: RecordResponseHeaders[] = [];\nconst unusedFetchHeaders: FetchResponseHeaders[] = [];\nconst newRecordHeaders = (defaults: ResponseDefaults) => new RecordResponseHeaders(defaults);\nconst newFetchHeaders = (defaults: ResponseDefaults) => new FetchResponseHeaders(defaults);\n\n/** Response headers holding the defaults and nothing else, from the pool or new. */\nexport const getDefaultHeaders = (): RecordResponseHeaders => takeUnused(unusedRecordHeaders, newRecordHeaders);\n\n/** Like `getDefaultHeaders`, over a native `Headers` for the fetch adapters. */\nexport const getDefaultFetchHeaders = (): FetchResponseHeaders => takeUnused(unusedFetchHeaders, newFetchHeaders);\n\n/** Gives headers back once the reply is sent; written ones are dropped. */\nexport const releaseHeaders = (headers: RecordResponseHeaders): void => giveBackUnused(unusedRecordHeaders, headers);\n\nfunction takeUnused<Pooled extends PooledHeaders>(pool: Pooled[], create: (defaults: ResponseDefaults) => Pooled): Pooled {\n  const defaults = getResponseDefaults();\n  const headers = pool.pop();\n  if (headers?.defaults === defaults) return headers;\n  // the router restarted: pooled headers carry the old defaults\n  pool.length = 0;\n  return create(defaults);\n}\n\nfunction giveBackUnused<Pooled extends PooledHeaders>(pool: Pooled[], headers: Pooled): void {\n  if (headers.unused && pool.length < MAX_UNUSED_HEADERS) pool.push(headers);\n}\n\nexport function replyFetch(mionResp: MionResponse, headers: FetchResponseHeaders): Response {\n  // last, so a handler never replaces it; unused headers already hold the JSON one\n  if (!headers.unused || mionResp.contentType !== JSON_CONTENT_TYPE) headers.set('content-type', mionResp.contentType);\n  // Response copies its headers, so unused ones serve the next request\n  const response = Response.json(mionResp.body, {status: mionResp.statusCode, headers: headers.native});\n  giveBackUnused(unusedFetchHeaders, headers);\n  return response;\n}\n\n/** A fetch-like (not identical) Headers object over a header record, for an incoming request carrying its\n *  headers as an object: IncomingMessage.headers, ApiGatewayEvent.headers.\n *  https://developer.mozilla.org/en-US/docs/Web/API/Headers */\nexport function headersFromRecord(headersObj: Record<string, string>, skipToLower = false): MionHeaders {\n  const headers = parseHeaders(headersObj, skipToLower);\n  return new MionHeadersImpl(headers);\n}\n\n/** A header value, or undefined for a name the record does not carry as an own string (a prototype\n *  hit is a function or an object). A platform record may hold an array (node's `set-cookie`). */\nfunction readHeader(headers: HeadersRecord, lowerName: string): string | undefined {\n  const value = headers[lowerName] as unknown;\n  if (typeof value === 'string') return value;\n  return Array.isArray(value) ? value.join(', ') : undefined;\n}\n\nfunction joined(value: string | string[]): string {\n  return Array.isArray(value) ? value.join(', ') : value;\n}\n\nfunction toSingleHeader(value: string | number): string {\n  if (Array.isArray(value)) return value.join(', ');\n  return value as string;\n}\n\nfunction parseHeaders(headersObj: Record<string, string>, skipToLower = false): HeadersRecord {\n  if (skipToLower) return headersObj;\n  const entries = Object.entries(headersObj);\n  // null-prototype: header names come off the wire\n  const headers: HeadersRecord = Object.create(null);\n  for (let i = 0; i < entries.length; i++) {\n    const [name, value] = entries[i];\n    if (!value) continue;\n    const ln = name.toLowerCase();\n    headers[ln] = toSingleHeader(value);\n  }\n  return headers;\n}\n"],"mappings":"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"}

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

@@ -4,5 +4,4 @@ export interface QueryBodyResult {
     bodyType: SerializerCode;
 }
 export declare function decodeQueryBody(urlQuery: string | undefined, rawBody: unknown): QueryBodyResult | undefined;
-export declare type __ΩQueryBodyResult = any[];
 //# sourceMappingURL=queryBody.d.ts.map

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

@@ -1,34 +1,29 @@
-import { SerializerModes, fromBase64Url } from "@mionjs/core";
-const __ΩQueryBodyResult = ["rawBody", "SerializerCode", "bodyType", "QueryBodyResult", 'P&4!"w"4#Mw$y'];
+import { findMionQueryParam } from "./urlQuery.js";
+import { FatalError, SerializerModes, StatusCodes, fromBase64Url } from "@mionjs/core";
+//#region src/lib/queryBody.ts
 function decodeQueryBody(urlQuery, rawBody) {
-  if (rawBody)
-    return void 0;
-  if (!urlQuery)
-    return void 0;
-  const dataValue = extractDataParam(urlQuery);
-  if (!dataValue)
-    return void 0;
-  return {
-    rawBody: fromBase64Url(dataValue),
-    bodyType: SerializerModes.stringifyJson
-  };
+	if (rawBody) return void 0;
+	if (!urlQuery) return void 0;
+	const dataValue = findMionQueryParam(urlQuery, "data");
+	if (!dataValue) return void 0;
+	try {
+		return {
+			rawBody: fromBase64Url(dataValue),
+			bodyType: SerializerModes.stringifyJson
+		};
+	} catch (err) {
+		throw invalidQueryBody(err);
+	}
 }
-decodeQueryBody.__type = ["urlQuery", "rawBody", () => __ΩQueryBodyResult, "decodeQueryBody", 'PP&-J2!#2"Pn#-J/$'];
-function extractDataParam(urlQuery) {
-  if (urlQuery.startsWith("data=")) {
-    const ampIndex2 = urlQuery.indexOf("&", 5);
-    return ampIndex2 === -1 ? urlQuery.slice(5) : urlQuery.slice(5, ampIndex2);
-  }
-  const idx = urlQuery.indexOf("&data=");
-  if (idx === -1)
-    return void 0;
-  const start = idx + 6;
-  const ampIndex = urlQuery.indexOf("&", start);
-  return ampIndex === -1 ? urlQuery.slice(start) : urlQuery.slice(start, ampIndex);
+function invalidQueryBody(originalError) {
+	return new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "invalid-query-body",
+		publicMessage: "Invalid query body: the data parameter is not base64url encoded.",
+		originalError
+	});
 }
-extractDataParam.__type = ["urlQuery", "extractDataParam", 'P&2!P&-J/"'];
-export {
-  __ΩQueryBodyResult,
-  decodeQueryBody
-};
-//# sourceMappingURL=queryBody.js.map
+//#endregion
+export { decodeQueryBody };
+
+//# sourceMappingURL=queryBody.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"queryBody.js","sources":["../../../../src/lib/queryBody.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {fromBase64Url, SerializerModes} from '@mionjs/core';\nimport type {SerializerCode} from '@mionjs/core';\n\n/** Result of decoding a base64url query body from ?data= */\nexport interface QueryBodyResult {\n    rawBody: string;\n    bodyType: SerializerCode;\n}\n\n/** Detects and decodes base64url-encoded request body from ?data= query param.\n * Returns decoded body + bodyType if found, undefined otherwise. */\nexport function decodeQueryBody(urlQuery: string | undefined, rawBody: unknown): QueryBodyResult | undefined {\n    if (rawBody) return undefined;\n    if (!urlQuery) return undefined;\n    const dataValue = extractDataParam(urlQuery);\n    if (!dataValue) return undefined;\n    return {\n        rawBody: fromBase64Url(dataValue),\n        bodyType: SerializerModes.stringifyJson,\n    };\n}\n\nfunction extractDataParam(urlQuery: string): string | undefined {\n    if (urlQuery.startsWith('data=')) {\n        const ampIndex = urlQuery.indexOf('&', 5);\n        return ampIndex === -1 ? urlQuery.slice(5) : urlQuery.slice(5, ampIndex);\n    }\n    const idx = urlQuery.indexOf('&data=');\n    if (idx === -1) return undefined;\n    const start = idx + 6;\n    const ampIndex = urlQuery.indexOf('&', start);\n    return ampIndex === -1 ? urlQuery.slice(start) : urlQuery.slice(start, ampIndex);\n}\n"],"names":["ampIndex"],"mappings":";;AAkBM,SAAU,gBAAgB,UAA8B,SAAgB;AAC1E,MAAI;AAAS,WAAO;AACpB,MAAI,CAAC;AAAU,WAAO;AACtB,QAAM,YAAY,iBAAiB,QAAQ;AAC3C,MAAI,CAAC;AAAW,WAAO;AACvB,SAAO;AAAA,IACH,SAAS,cAAc,SAAS;AAAA,IAChC,UAAU,gBAAgB;AAAA,EAAA;AAElC;;AAEA,SAAS,iBAAiB,UAAgB;AACtC,MAAI,SAAS,WAAW,OAAO,GAAG;AAC9B,UAAMA,YAAW,SAAS,QAAQ,KAAK,CAAC;AACxC,WAAOA,cAAa,KAAK,SAAS,MAAM,CAAC,IAAI,SAAS,MAAM,GAAGA,SAAQ;AAAA,EAC3E;AACA,QAAM,MAAM,SAAS,QAAQ,QAAQ;AACrC,MAAI,QAAQ;AAAI,WAAO;AACvB,QAAM,QAAQ,MAAM;AACpB,QAAM,WAAW,SAAS,QAAQ,KAAK,KAAK;AAC5C,SAAO,aAAa,KAAK,SAAS,MAAM,KAAK,IAAI,SAAS,MAAM,OAAO,QAAQ;AACnF;;"}
+{"version":3,"file":"queryBody.js","names":[],"sources":["../../../../src/lib/queryBody.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {fromBase64Url, FatalError, RpcError, SerializerModes, StatusCodes} from '@mionjs/core';\nimport type {SerializerCode} from '@mionjs/core';\nimport {findMionQueryParam} from './urlQuery.ts';\n\n// `atob` throws a raw InvalidCharacterError on anything that is not base64, and one `GET /route?data=!`\n// used to take the node and uws processes down with an unhandled rejection. No pre-check: a regex over\n// the value doubled the cost of every query-body request (85 to 170 ns) to refuse what `atob` refuses.\n\nexport interface QueryBodyResult {\n  rawBody: string;\n  bodyType: SerializerCode;\n}\n\nexport function decodeQueryBody(urlQuery: string | undefined, rawBody: unknown): QueryBodyResult | undefined {\n  if (rawBody) return undefined;\n  if (!urlQuery) return undefined;\n  const dataValue = findMionQueryParam(urlQuery, 'data');\n  if (!dataValue) return undefined;\n  try {\n    return {rawBody: fromBase64Url(dataValue), bodyType: SerializerModes.stringifyJson};\n  } catch (err) {\n    throw invalidQueryBody(err);\n  }\n}\n\nfunction invalidQueryBody(originalError?: unknown): RpcError<'invalid-query-body'> {\n  return new FatalError({\n    statusCode: StatusCodes.UNEXPECTED_ERROR,\n    type: 'invalid-query-body',\n    publicMessage: 'Invalid query body: the data parameter is not base64url encoded.',\n    originalError: originalError as Error | undefined,\n  });\n}\n"],"mappings":";;;AAoBA,SAAgB,gBAAgB,UAA8B,SAA+C;CAC3G,IAAI,SAAS,OAAO,KAAA;CACpB,IAAI,CAAC,UAAU,OAAO,KAAA;CACtB,MAAM,YAAY,mBAAmB,UAAU,MAAM;CACrD,IAAI,CAAC,WAAW,OAAO,KAAA;CACvB,IAAI;EACF,OAAO;GAAC,SAAS,cAAc,SAAS;GAAG,UAAU,gBAAgB;EAAa;CACpF,SAAS,KAAK;EACZ,MAAM,iBAAiB,GAAG;CAC5B;AACF;AAEA,SAAS,iBAAiB,eAAyD;CACjF,OAAO,IAAI,WAAW;EACpB,YAAY,YAAY;EACxB,MAAM;EACN,eAAe;EACA;CACjB,CAAC;AACH"}

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

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

@@ -1,352 +1,76 @@
-import { __ΩHandler as ___Handler } from "../types/handlers.js";
-import { __ΩRouterOptions as ___RouterOptions } from "../types/general.js";
-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'];
-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((module) => {
-    runTypesModule = {
-      JitFunctions: module.JitFunctions,
-      reflectFunction: module.reflectFunction,
-      isUnionRunType: module.isUnionRunType,
-      isClassRunType: module.isClassRunType,
-      isLiteralRunType: module.isLiteralRunType,
-      isNeverRunType: module.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: getNoopJitFns(),
-    returnJitFns: getNoopJitFns(),
-    paramsJitHash: EMPTY_HASH,
-    returnJitHash: 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: getJitFunctionsFromHash(cached.paramsJitHash),
-    returnJitFns: 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: getJitFunctionsFromHash(cached.headersParam.jitHash),
-      jitHash: cached.headersParam.jitHash
-    };
-  }
-  if (cached.headersReturn) {
-    reflectionItems.headersReturn = {
-      headerNames: cached.headersReturn.headerNames,
-      jitFns: 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 = 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 = [() => ___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)
-    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 = [() => ___Handler, "handler", "routeId", () => ___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 || 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: HEADER_HOOK_DEFAULT_PARAMS.length } : { start: ROUTE_DEFAULT_PARAMS.length };
-  const paramsOpts = { ...runTypeOptions, paramsSlice };
-  try {
-    reflectionItems.paramNames = handlerRunType.getParameterNames(paramsOpts);
-    if (reflectionItems.paramNames.length === 0) {
-      reflectionItems.paramsJitHash = EMPTY_HASH;
-      reflectionItems.paramsJitFns = 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 = getNoopJitFns();
-      reflectionItems.returnJitHash = 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 = [() => ___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 {
-    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 = [() => ___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", () => ___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, 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 = [() => ___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 === 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,
-  resetRunTypesCache
+import { EMPTY_HASH, getHeadersReflectionFromMarkers, getNoopJitFns, getOrCreateGlobal, getReflectionFromMarkers, isAsyncHandler } from "@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";
+	}
 };
-//# sourceMappingURL=reflection.js.map
+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 = 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: getNoopJitFns(),
+		returnJitFns: getNoopJitFns(),
+		paramsJitHash: EMPTY_HASH,
+		returnJitHash: 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 ? getHeadersReflectionFromMarkers(def.rtFns, def.handler, routeId) : 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(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 === 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
+export { MissingRtFnsError, RuntimeCodeGenBlockedError, assertCompiledParser, getHandlerReflection, getRawMethodReflection };
+
+//# sourceMappingURL=reflection.js.map