@mionjs/router 0.13.0 → 0.14.0

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

@@ -10,6 +10,7 @@ function getRouterFatalErrorResponse(returnErr, respHeaders) {
 		statusCode: returnErr.statusCode || StatusCodes.SERVER_ERROR,
 		contentType: JSON_CONTENT_TYPE,
 		hasErrors: true,
+		stopped: true,
 		fatalError: returnErr,
 		headers: respHeaders,
 		body
@@ -23,7 +24,7 @@ function errorHeaderValue(type) {
 	return HEADER_SAFE_TYPE.test(type) ? type : "unknown-error";
 }
 /** Marks the response as ended by `rpcError`: the error header (first error only), the status code,
-*  `hasErrors` (what the dispatcher's skip rule reads) and `fatalError` (first one wins). Shared by the
+*  `hasErrors`, `stopped` (what the dispatcher's skip rule reads) and `fatalError` (first one wins). Shared by the
 *  thrown path and a returned FatalError; where the error itself lands is the caller's decision.
 *  `fallbackStatus` answers when the error carries no statusCode: a thrown one is unexpected (422), a
 *  returned FatalError a declared application error (400). */
@@ -35,6 +36,14 @@ function markResponseFailed(context, rpcError, fallbackStatus) {
 	}
 	response.statusCode = rpcError.statusCode ?? fallbackStatus;
 	response.hasErrors = true;
+	response.stopped = true;
+}
+/** Later members are skipped except `alwaysRun` ones, as after an error, but `hasErrors` stays false. */
+function endChain(context, statusCode = StatusCodes.OK) {
+	const response = context.response;
+	if (response.stopped) return;
+	response.statusCode = statusCode;
+	response.stopped = true;
 }
 /** Whatever an adapter caught, as the mion error the wire carries. */
 function toRpcError(err) {
@@ -70,6 +79,6 @@ function hasThrownError(context, key) {
 	return !!thrownErrors && Object.hasOwn(thrownErrors, key);
 }
 //#endregion
-export { addThrownError, errorHeaderValue, getRouterFatalErrorResponse, hasThrownError, markResponseFailed, recordUndeclaredError, toRpcError };
+export { addThrownError, endChain, errorHeaderValue, getRouterFatalErrorResponse, hasThrownError, markResponseFailed, recordUndeclaredError, toRpcError };
 
 //# sourceMappingURL=dispatchError.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"dispatchError.js","names":[],"sources":["../../../../src/lib/dispatchError.ts"],"sourcesContent":["import {RpcError, FatalError, MION_ROUTES, Mutable, StatusCodes, markFatal} from '@mionjs/core';\nimport {JSON_CONTENT_TYPE} from '../constants.ts';\nimport type {CallContext, MionHeaders, MionRequest, MionResponse, ResponseBody} from '../types/context.ts';\n\n/** The response for an error raised outside the router by any adapter; it goes in `@thrownErrors` like a route error. */\n\nexport function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse {\n  // a platform error ends the request before any handler runs, so it is fatal by definition\n  markFatal(returnErr);\n  const body: ResponseBody = {\n    '@thrownErrors': {[MION_ROUTES.platformError]: returnErr},\n  };\n  respHeaders.set('x-rpc-error', errorHeaderValue(returnErr.type));\n  const response: Mutable<MionResponse> = {\n    statusCode: returnErr.statusCode || StatusCodes.SERVER_ERROR, // Global errors are always unexpected\n    contentType: JSON_CONTENT_TYPE,\n    hasErrors: true,\n    fatalError: returnErr,\n    headers: respHeaders,\n    body,\n  };\n  return response;\n}\n\n/** An app-thrown RpcError may carry any string as its `type`, and a CR or LF there is header injection on\n *  adapters that write headers unchecked (or an ERR_INVALID_CHAR throw on node). Anything outside the token\n *  alphabet reports as `unknown-error` on the header; the body still carries the full type. */\nconst HEADER_SAFE_TYPE = /^[A-Za-z0-9_.:@-]{1,128}$/;\nexport function errorHeaderValue(type: string): string {\n  return HEADER_SAFE_TYPE.test(type) ? type : 'unknown-error';\n}\n\n/** Marks the response as ended by `rpcError`: the error header (first error only), the status code,\n *  `hasErrors` (what the dispatcher's skip rule reads) and `fatalError` (first one wins). Shared by the\n *  thrown path and a returned FatalError; where the error itself lands is the caller's decision.\n *  `fallbackStatus` answers when the error carries no statusCode: a thrown one is unexpected (422), a\n *  returned FatalError a declared application error (400). */\nexport function markResponseFailed(context: CallContext, rpcError: RpcError<string>, fallbackStatus: number) {\n  const response = context.response as Mutable<MionResponse>;\n  if (!response.hasErrors) {\n    response.headers.set('x-rpc-error', errorHeaderValue(rpcError.type));\n    response.fatalError = rpcError;\n  }\n  response.statusCode = rpcError.statusCode ?? fallbackStatus;\n  response.hasErrors = true;\n}\n\n/** Whatever an adapter caught, as the mion error the wire carries. */\nexport function toRpcError(err: unknown): RpcError<string> {\n  return err instanceof RpcError\n    ? err\n    : new FatalError({publicMessage: 'Unknown Error', type: 'unknown-error', originalError: err as Error});\n}\n\n/** Records an undeclared error under `key` and ends the request: it lands in `@thrownErrors` untyped, sets\n *  the status and the error header, and stops every later member that does not declare `alwaysRun`.\n *  Undeclared means thrown, or returned by a raw middleware, which cannot declare a return type; a declared\n *  error is returned from a handler and goes straight into `response.body`. The key is normally the member\n *  that failed; an adapter passes its own (`mion@platformError`) for a request no member could run. */\nexport function recordUndeclaredError(context: CallContext, key: string, err: any) {\n  const rpcError: RpcError<string> = markFatal(\n    err instanceof RpcError\n      ? err\n      : new FatalError({\n          statusCode: StatusCodes.UNEXPECTED_ERROR,\n          publicMessage: `Unknown error in handler \"${key}\" of route ExecutionChain.`,\n          originalError: err,\n          type: 'unknown-error',\n        })\n  );\n  markResponseFailed(context, rpcError, StatusCodes.UNEXPECTED_ERROR);\n  addThrownError(context, key, rpcError);\n}\n\n/** Unlike recordUndeclaredError, does not end the request. */\nexport function addThrownError(context: CallContext, key: string, rpcError: RpcError<string>) {\n  // tsgo types `readonly || mutable` as readonly, so casting only the `{}` fallback still forbids the write.\n  const thrownErrors = (context.request.thrownErrors || {}) as Record<string, RpcError<string>>;\n  thrownErrors[key] = rpcError;\n  (context.request as Mutable<MionRequest>).thrownErrors = thrownErrors;\n}\n\nexport function hasThrownError(context: CallContext, key: string): boolean {\n  const thrownErrors = context.request.thrownErrors;\n  return !!thrownErrors && Object.hasOwn(thrownErrors, key);\n}\n"],"mappings":";;;;AAMA,SAAgB,4BAA4B,WAA6B,aAAwC;CAE/G,UAAU,SAAS;CACnB,MAAM,OAAqB,EACzB,iBAAiB,GAAE,YAAY,gBAAgB,UAAS,EAC1D;CACA,YAAY,IAAI,eAAe,iBAAiB,UAAU,IAAI,CAAC;CAS/D,OAAO;EAPL,YAAY,UAAU,cAAc,YAAY;EAChD,aAAa;EACb,WAAW;EACX,YAAY;EACZ,SAAS;EACT;CAEK;AACT;;;;AAKA,IAAM,mBAAmB;AACzB,SAAgB,iBAAiB,MAAsB;CACrD,OAAO,iBAAiB,KAAK,IAAI,IAAI,OAAO;AAC9C;;;;;;AAOA,SAAgB,mBAAmB,SAAsB,UAA4B,gBAAwB;CAC3G,MAAM,WAAW,QAAQ;CACzB,IAAI,CAAC,SAAS,WAAW;EACvB,SAAS,QAAQ,IAAI,eAAe,iBAAiB,SAAS,IAAI,CAAC;EACnE,SAAS,aAAa;CACxB;CACA,SAAS,aAAa,SAAS,cAAc;CAC7C,SAAS,YAAY;AACvB;;AAGA,SAAgB,WAAW,KAAgC;CACzD,OAAO,eAAe,WAClB,MACA,IAAI,WAAW;EAAC,eAAe;EAAiB,MAAM;EAAiB,eAAe;CAAY,CAAC;AACzG;;;;;;AAOA,SAAgB,sBAAsB,SAAsB,KAAa,KAAU;CACjF,MAAM,WAA6B,UACjC,eAAe,WACX,MACA,IAAI,WAAW;EACb,YAAY,YAAY;EACxB,eAAe,6BAA6B,IAAI;EAChD,eAAe;EACf,MAAM;CACR,CAAC,CACP;CACA,mBAAmB,SAAS,UAAU,YAAY,gBAAgB;CAClE,eAAe,SAAS,KAAK,QAAQ;AACvC;;AAGA,SAAgB,eAAe,SAAsB,KAAa,UAA4B;CAE5F,MAAM,eAAgB,QAAQ,QAAQ,gBAAgB,CAAC;CACvD,aAAa,OAAO;CACpB,QAAS,QAAiC,eAAe;AAC3D;AAEA,SAAgB,eAAe,SAAsB,KAAsB;CACzE,MAAM,eAAe,QAAQ,QAAQ;CACrC,OAAO,CAAC,CAAC,gBAAgB,OAAO,OAAO,cAAc,GAAG;AAC1D"}
+{"version":3,"file":"dispatchError.js","names":[],"sources":["../../../../src/lib/dispatchError.ts"],"sourcesContent":["import {RpcError, FatalError, MION_ROUTES, Mutable, StatusCodes, markFatal} from '@mionjs/core';\nimport {JSON_CONTENT_TYPE} from '../constants.ts';\nimport type {CallContext, MionResponse, MionHeaders, MionRequest, ResponseBody} from '../types/context.ts';\n\n/** The response for an error raised outside the router by any adapter; it goes in `@thrownErrors` like a route error. */\n\nexport function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse {\n  // a platform error ends the request before any handler runs, so it is fatal by definition\n  markFatal(returnErr);\n  const body: ResponseBody = {\n    '@thrownErrors': {[MION_ROUTES.platformError]: returnErr},\n  };\n  respHeaders.set('x-rpc-error', errorHeaderValue(returnErr.type));\n  const response: Mutable<MionResponse> = {\n    statusCode: returnErr.statusCode || StatusCodes.SERVER_ERROR, // Global errors are always unexpected\n    contentType: JSON_CONTENT_TYPE,\n    hasErrors: true,\n    stopped: true,\n    fatalError: returnErr,\n    headers: respHeaders,\n    body,\n  };\n  return response;\n}\n\n/** An app-thrown RpcError may carry any string as its `type`, and a CR or LF there is header injection on\n *  adapters that write headers unchecked (or an ERR_INVALID_CHAR throw on node). Anything outside the token\n *  alphabet reports as `unknown-error` on the header; the body still carries the full type. */\nconst HEADER_SAFE_TYPE = /^[A-Za-z0-9_.:@-]{1,128}$/;\nexport function errorHeaderValue(type: string): string {\n  return HEADER_SAFE_TYPE.test(type) ? type : 'unknown-error';\n}\n\n/** Marks the response as ended by `rpcError`: the error header (first error only), the status code,\n *  `hasErrors`, `stopped` (what the dispatcher's skip rule reads) and `fatalError` (first one wins). Shared by the\n *  thrown path and a returned FatalError; where the error itself lands is the caller's decision.\n *  `fallbackStatus` answers when the error carries no statusCode: a thrown one is unexpected (422), a\n *  returned FatalError a declared application error (400). */\nexport function markResponseFailed(context: CallContext, rpcError: RpcError<string>, fallbackStatus: number) {\n  const response = context.response as Mutable<MionResponse>;\n  if (!response.hasErrors) {\n    response.headers.set('x-rpc-error', errorHeaderValue(rpcError.type));\n    response.fatalError = rpcError;\n  }\n  response.statusCode = rpcError.statusCode ?? fallbackStatus;\n  response.hasErrors = true;\n  response.stopped = true;\n}\n\n/** Later members are skipped except `alwaysRun` ones, as after an error, but `hasErrors` stays false. */\nexport function endChain(context: CallContext, statusCode: number = StatusCodes.OK): void {\n  const response = context.response as Mutable<MionResponse>;\n  if (response.stopped) return;\n  response.statusCode = statusCode;\n  response.stopped = true;\n}\n\n/** Whatever an adapter caught, as the mion error the wire carries. */\nexport function toRpcError(err: unknown): RpcError<string> {\n  return err instanceof RpcError\n    ? err\n    : new FatalError({publicMessage: 'Unknown Error', type: 'unknown-error', originalError: err as Error});\n}\n\n/** Records an undeclared error under `key` and ends the request: it lands in `@thrownErrors` untyped, sets\n *  the status and the error header, and stops every later member that does not declare `alwaysRun`.\n *  Undeclared means thrown, or returned by a raw middleware, which cannot declare a return type; a declared\n *  error is returned from a handler and goes straight into `response.body`. The key is normally the member\n *  that failed; an adapter passes its own (`mion@platformError`) for a request no member could run. */\nexport function recordUndeclaredError(context: CallContext, key: string, err: any) {\n  const rpcError: RpcError<string> = markFatal(\n    err instanceof RpcError\n      ? err\n      : new FatalError({\n          statusCode: StatusCodes.UNEXPECTED_ERROR,\n          publicMessage: `Unknown error in handler \"${key}\" of route ExecutionChain.`,\n          originalError: err,\n          type: 'unknown-error',\n        })\n  );\n  markResponseFailed(context, rpcError, StatusCodes.UNEXPECTED_ERROR);\n  addThrownError(context, key, rpcError);\n}\n\n/** Unlike recordUndeclaredError, does not end the request. */\nexport function addThrownError(context: CallContext, key: string, rpcError: RpcError<string>) {\n  // tsgo types `readonly || mutable` as readonly, so casting only the `{}` fallback still forbids the write.\n  const thrownErrors = (context.request.thrownErrors || {}) as Record<string, RpcError<string>>;\n  thrownErrors[key] = rpcError;\n  (context.request as Mutable<MionRequest>).thrownErrors = thrownErrors;\n}\n\nexport function hasThrownError(context: CallContext, key: string): boolean {\n  const thrownErrors = context.request.thrownErrors;\n  return !!thrownErrors && Object.hasOwn(thrownErrors, key);\n}\n"],"mappings":";;;;AAMA,SAAgB,4BAA4B,WAA6B,aAAwC;CAE/G,UAAU,SAAS;CACnB,MAAM,OAAqB,EACzB,iBAAiB,GAAE,YAAY,gBAAgB,UAAS,EAC1D;CACA,YAAY,IAAI,eAAe,iBAAiB,UAAU,IAAI,CAAC;CAU/D,OAAO;EARL,YAAY,UAAU,cAAc,YAAY;EAChD,aAAa;EACb,WAAW;EACX,SAAS;EACT,YAAY;EACZ,SAAS;EACT;CAEK;AACT;;;;AAKA,IAAM,mBAAmB;AACzB,SAAgB,iBAAiB,MAAsB;CACrD,OAAO,iBAAiB,KAAK,IAAI,IAAI,OAAO;AAC9C;;;;;;AAOA,SAAgB,mBAAmB,SAAsB,UAA4B,gBAAwB;CAC3G,MAAM,WAAW,QAAQ;CACzB,IAAI,CAAC,SAAS,WAAW;EACvB,SAAS,QAAQ,IAAI,eAAe,iBAAiB,SAAS,IAAI,CAAC;EACnE,SAAS,aAAa;CACxB;CACA,SAAS,aAAa,SAAS,cAAc;CAC7C,SAAS,YAAY;CACrB,SAAS,UAAU;AACrB;;AAGA,SAAgB,SAAS,SAAsB,aAAqB,YAAY,IAAU;CACxF,MAAM,WAAW,QAAQ;CACzB,IAAI,SAAS,SAAS;CACtB,SAAS,aAAa;CACtB,SAAS,UAAU;AACrB;;AAGA,SAAgB,WAAW,KAAgC;CACzD,OAAO,eAAe,WAClB,MACA,IAAI,WAAW;EAAC,eAAe;EAAiB,MAAM;EAAiB,eAAe;CAAY,CAAC;AACzG;;;;;;AAOA,SAAgB,sBAAsB,SAAsB,KAAa,KAAU;CACjF,MAAM,WAA6B,UACjC,eAAe,WACX,MACA,IAAI,WAAW;EACb,YAAY,YAAY;EACxB,eAAe,6BAA6B,IAAI;EAChD,eAAe;EACf,MAAM;CACR,CAAC,CACP;CACA,mBAAmB,SAAS,UAAU,YAAY,gBAAgB;CAClE,eAAe,SAAS,KAAK,QAAQ;AACvC;;AAGA,SAAgB,eAAe,SAAsB,KAAa,UAA4B;CAE5F,MAAM,eAAgB,QAAQ,QAAQ,gBAAgB,CAAC;CACvD,aAAa,OAAO;CACpB,QAAS,QAAiC,eAAe;AAC3D;AAEA,SAAgB,eAAe,SAAsB,KAAsB;CACzE,MAAM,eAAe,QAAQ,QAAQ;CACrC,OAAO,CAAC,CAAC,gBAAgB,OAAO,OAAO,cAAc,GAAG;AAC1D"}

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

@@ -1,11 +1,11 @@
 import { HeadersMiddlewareHelper, MiddlewareHelper, RawMiddlewareHelper, RouteHelper, RouterOptionsInput } from '../types/mionRouter.ts';
 import { CallContext } from '../types/context.ts';
 export declare const route: RouteHelper<RouterOptionsInput>;
-export declare const query: RouteHelper<Partial<import('../types/general.ts').RouterOptions<any, any>>, false>;
-export declare const mutation: RouteHelper<Partial<import('../types/general.ts').RouterOptions<any, any>>, true>;
+export declare const query: RouteHelper<Partial<import('../types/general.ts').RouterOptions<any, any>>, object, false>;
+export declare const mutation: RouteHelper<Partial<import('../types/general.ts').RouterOptions<any, any>>, object, true>;
 export declare const middleware: MiddlewareHelper<RouterOptionsInput>;
 export declare const headersMiddleware: HeadersMiddlewareHelper<RouterOptionsInput>;
-export declare const rawMiddleware: RawMiddlewareHelper<RouterOptionsInput>;
+export declare const rawMiddleware: RawMiddlewareHelper;
 type OnEveryCall = (ctx: CallContext) => void;
 export declare function markOnDemand<Def extends object>(def: Def, onEveryCall?: OnEveryCall): Def;
 export declare function isOnDemandMiddleware(def: object): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"handlers.js","names":[],"sources":["../../../../src/lib/handlers.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 {HandlerType, MION_ROUTES} from '@mionjs/core';\nimport type {\n  HeadersMiddlewareHelper,\n  MiddlewareHelper,\n  PinnedMutation,\n  RawMiddlewareHelper,\n  RouteHelper,\n  RouterOptionsInput,\n} from '../types/mionRouter.ts';\nimport type {CallContext} from '../types/context.ts';\n\n// ############# Route & Middlewares initialization (INTERNAL) #############\n// These bodies initialize the definition objects AND are the mion injection points: the trailing marker\n// params are filled at BUILD TIME by @mionjs/devtools. Not exported from the package, consumers reach\n// them as the closures `createMionRouter()` returns; only mion's own middlewares and its error / serializer routes\n// call them directly, each pinning its own `encoder`.\n// ⚠️ There is NO signature here on purpose: each body is TYPED BY its helper interface in\n// types/mionRouter.ts, the one place a helper signature is written, so there is no second surface to keep\n// in step. `RouterOptionsInput` is the widest options shape; `createMionRouter` narrows each helper to\n// its own `O` so a declaration reads the factory's options.\n\nexport const route: RouteHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  paramsFns,\n  returnFns,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.route,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n});\n\n/** Typed as the same helper as `route()`, so both keep the marker signature the scanner reads at the call site. */\nfunction routeWithMutation<M extends boolean>(isMutation: M): RouteHelper<RouterOptionsInput, M> {\n  return (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({\n    type: HandlerType.route,\n    handler,\n    options: {...opts, isMutation} as PinnedMutation<typeof opts & object, M>,\n    rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n  });\n}\n\n/** Route handler for read-only queries. Uses GET with ?data=base64url on the client when payload fits. */\nexport const query = routeWithMutation(false);\n\nexport const mutation = routeWithMutation(true);\n\nexport const middleware: MiddlewareHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  paramsFns,\n  returnFns,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.middleware,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n});\n\nexport const headersMiddleware: HeadersMiddlewareHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  headersFns,\n  paramsFns,\n  returnFns,\n  headersId,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.headersMiddleware,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId, headersFns, headersId},\n});\n\nexport const rawMiddleware: RawMiddlewareHelper<RouterOptionsInput> = (handler, opts) => ({\n  type: HandlerType.rawMiddleware,\n  handler,\n  options: opts,\n});\n\n/** Each on-demand middleware, with what it does on every call even without its slot. */\nconst onDemandMiddlewares = new WeakMap<object, OnEveryCall | undefined>();\ntype OnEveryCall = (ctx: CallContext) => void;\n\n/** Internal: the middleware runs only when the request body carries its slot, so an absent slot costs nothing */\nexport function markOnDemand<Def extends object>(def: Def, onEveryCall?: OnEveryCall): Def {\n  onDemandMiddlewares.set(def, onEveryCall);\n  return def;\n}\n\nexport function isOnDemandMiddleware(def: object): boolean {\n  return onDemandMiddlewares.has(def);\n}\n\nexport function getOnEveryCall(def: object): OnEveryCall | undefined {\n  return onDemandMiddlewares.get(def);\n}\n\n/** mion's own ids, never exposed to clients */\nexport const mionInternalRouteIds: ReadonlySet<string> = new Set(Object.values(MION_ROUTES));\n"],"mappings":";;AA4BA,IAAa,SACX,SACA,MACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;CAAM;AACrE;;AAGA,SAAS,kBAAqC,YAAmD;CAC/F,QAAQ,SAAS,MAAM,WAAW,WAAW,UAAU,UAAU,WAAW,YAAY;EACtF,MAAM,YAAY;EAClB;EACA,SAAS;GAAC,GAAG;GAAM;EAAU;EAC7B,OAAO;GAAC;GAAW;GAAW;GAAU;GAAU;GAAW;EAAM;CACrE;AACF;;AAGA,IAAa,QAAQ,kBAAkB,KAAK;AAE5C,IAAa,WAAW,kBAAkB,IAAI;AAE9C,IAAa,cACX,SACA,MACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;CAAM;AACrE;AAEA,IAAa,qBACX,SACA,MACA,YACA,WACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;EAAQ;EAAY;CAAS;AAC5F;AAEA,IAAa,iBAA0D,SAAS,UAAU;CACxF,MAAM,YAAY;CAClB;CACA,SAAS;AACX;;AAGA,IAAM,sCAAsB,IAAI,QAAyC;;AAIzE,SAAgB,aAAiC,KAAU,aAAgC;CACzF,oBAAoB,IAAI,KAAK,WAAW;CACxC,OAAO;AACT;AAEA,SAAgB,qBAAqB,KAAsB;CACzD,OAAO,oBAAoB,IAAI,GAAG;AACpC;AAEA,SAAgB,eAAe,KAAsC;CACnE,OAAO,oBAAoB,IAAI,GAAG;AACpC;;AAGA,IAAa,uBAA4C,IAAI,IAAI,OAAO,OAAO,WAAW,CAAC"}
+{"version":3,"file":"handlers.js","names":[],"sources":["../../../../src/lib/handlers.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 {HandlerType, MION_ROUTES} from '@mionjs/core';\nimport type {\n  HeadersMiddlewareHelper,\n  MiddlewareHelper,\n  PinnedMutation,\n  RawMiddlewareHelper,\n  RouteHelper,\n  RouterOptionsInput,\n} from '../types/mionRouter.ts';\n\nimport type {CallContext} from '../types/context.ts';\n\n// ############# Route & Middlewares initialization (INTERNAL) #############\n// These bodies initialize the definition objects AND are the mion injection points: the trailing marker\n// params are filled at BUILD TIME by @mionjs/devtools. Not exported from the package, consumers reach\n// them as the closures `createMionRouter()` returns; only mion's own middlewares and its error / serializer routes\n// call them directly, each pinning its own `encoder`.\n// ⚠️ There is NO signature here on purpose: each body is TYPED BY its helper interface in\n// types/mionRouter.ts, the one place a helper signature is written, so there is no second surface to keep\n// in step. The router factory narrows each `RouterOptionsInput` helper to its own `O` and `T`.\n\nexport const route: RouteHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  paramsFns,\n  returnFns,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.route,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n});\n\n/** Typed as the same helper as `route()`, so both keep the marker signature the scanner reads at the call site. */\nfunction routeWithMutation<M extends boolean>(isMutation: M): RouteHelper<RouterOptionsInput, object, M> {\n  return (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({\n    type: HandlerType.route,\n    handler,\n    options: {...opts, isMutation} as PinnedMutation<typeof opts & object, M>,\n    rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n  });\n}\n\n/** Route handler for read-only queries. Uses GET with ?data=base64url on the client when payload fits. */\nexport const query = routeWithMutation(false);\n\nexport const mutation = routeWithMutation(true);\n\nexport const middleware: MiddlewareHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  paramsFns,\n  returnFns,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.middleware,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId},\n});\n\nexport const headersMiddleware: HeadersMiddlewareHelper<RouterOptionsInput> = (\n  handler,\n  opts,\n  headersFns,\n  paramsFns,\n  returnFns,\n  headersId,\n  paramsId,\n  returnId,\n  isAsyncId,\n  syncId\n) => ({\n  type: HandlerType.headersMiddleware,\n  handler,\n  options: opts,\n  rtFns: {paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId, headersFns, headersId},\n});\n\nexport const rawMiddleware: RawMiddlewareHelper = (handler, opts) => ({\n  type: HandlerType.rawMiddleware,\n  handler,\n  options: opts,\n});\n\n/** Each on-demand middleware, with what it does on every call even without its slot. */\nconst onDemandMiddlewares = new WeakMap<object, OnEveryCall | undefined>();\ntype OnEveryCall = (ctx: CallContext) => void;\n\n/** Internal: the middleware runs only when the request body carries its slot, so an absent slot costs nothing */\nexport function markOnDemand<Def extends object>(def: Def, onEveryCall?: OnEveryCall): Def {\n  onDemandMiddlewares.set(def, onEveryCall);\n  return def;\n}\n\nexport function isOnDemandMiddleware(def: object): boolean {\n  return onDemandMiddlewares.has(def);\n}\n\nexport function getOnEveryCall(def: object): OnEveryCall | undefined {\n  return onDemandMiddlewares.get(def);\n}\n\n/** mion's own ids, never exposed to clients */\nexport const mionInternalRouteIds: ReadonlySet<string> = new Set(Object.values(MION_ROUTES));\n"],"mappings":";;AA4BA,IAAa,SACX,SACA,MACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;CAAM;AACrE;;AAGA,SAAS,kBAAqC,YAA2D;CACvG,QAAQ,SAAS,MAAM,WAAW,WAAW,UAAU,UAAU,WAAW,YAAY;EACtF,MAAM,YAAY;EAClB;EACA,SAAS;GAAC,GAAG;GAAM;EAAU;EAC7B,OAAO;GAAC;GAAW;GAAW;GAAU;GAAU;GAAW;EAAM;CACrE;AACF;;AAGA,IAAa,QAAQ,kBAAkB,KAAK;AAE5C,IAAa,WAAW,kBAAkB,IAAI;AAE9C,IAAa,cACX,SACA,MACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;CAAM;AACrE;AAEA,IAAa,qBACX,SACA,MACA,YACA,WACA,WACA,WACA,UACA,UACA,WACA,YACI;CACJ,MAAM,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;EAAQ;EAAY;CAAS;AAC5F;AAEA,IAAa,iBAAsC,SAAS,UAAU;CACpE,MAAM,YAAY;CAClB;CACA,SAAS;AACX;;AAGA,IAAM,sCAAsB,IAAI,QAAyC;;AAIzE,SAAgB,aAAiC,KAAU,aAAgC;CACzF,oBAAoB,IAAI,KAAK,WAAW;CACxC,OAAO;AACT;AAEA,SAAgB,qBAAqB,KAAsB;CACzD,OAAO,oBAAoB,IAAI,GAAG;AACpC;AAEA,SAAgB,eAAe,KAAsC;CACnE,OAAO,oBAAoB,IAAI,GAAG;AACpC;;AAGA,IAAa,uBAA4C,IAAI,IAAI,OAAO,OAAO,WAAW,CAAC"}

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

@@ -16,9 +16,11 @@ declare class MionHeadersImpl implements MionHeaders {
 export declare class RecordResponseHeaders extends MionHeadersImpl implements PooledHeaders {
     readonly defaults: ResponseDefaults;
     constructor(defaults: ResponseDefaults);
+    set(name: string, value: string): void;
     append(name: string, value: string): void;
     forEach(visit: (name: string, value: string | string[]) => void): void;
 }
+export declare function assertHeaderSafe(name: string, value: string): void;
 export declare class FetchResponseHeaders implements PooledHeaders {
     readonly defaults: ResponseDefaults;
     readonly native: import('undici-types').Headers;

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

@@ -53,8 +53,14 @@ var RecordResponseHeaders = class extends MionHeadersImpl {
 		super({ ...defaults });
 		this.defaults = defaults;
 	}
+	/** Refuses what fetch `Headers` refuses: uws and aws write a header record as it is, unchecked. */
+	set(name, value) {
+		assertHeaderSafe(name, value);
+		super.set(name, value);
+	}
 	/** Keeps a repeated name's values apart, never joined: the adapter writes them its own way. */
 	append(name, value) {
+		assertHeaderSafe(name, value);
 		this.unused = false;
 		const key = name.toLowerCase();
 		if (key === PROTO_KEY) return;
@@ -68,6 +74,18 @@ var RecordResponseHeaders = class extends MionHeadersImpl {
 		for (const name in this.headers) visit(name, this.headers[name]);
 	}
 };
+/** CR or LF splits the response (header injection); NUL ends it early on some hosts.
+*  The value stays out of the error: it may be what an attacker sent. */
+function assertHeaderSafe(name, value) {
+	if (hasControlBreak(name) || hasControlBreak(value)) throw new TypeError(`Invalid header ${JSON.stringify(name.slice(0, 64))}: CR, LF or NUL`);
+}
+function hasControlBreak(text) {
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code === 13 || code === 10 || code === 0) return true;
+	}
+	return false;
+}
 /** The response headers of the fetch adapters (bun, cloudflare, vercel). */
 var FetchResponseHeaders = class {
 	defaults;
@@ -169,6 +187,6 @@ function parseHeaders(headersObj, skipToLower = false) {
 	return headers;
 }
 //#endregion
-export { FetchResponseHeaders, RecordResponseHeaders, getDefaultFetchHeaders, getDefaultHeaders, headersFromRecord, releaseHeaders, replyFetch };
+export { FetchResponseHeaders, RecordResponseHeaders, assertHeaderSafe, getDefaultFetchHeaders, getDefaultHeaders, headersFromRecord, releaseHeaders, replyFetch };
 
 //# sourceMappingURL=headers.js.map

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

@@ -1 +1 @@
-{"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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"}
+{"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  /** Refuses what fetch `Headers` refuses: uws and aws write a header record as it is, unchecked. */\n  set(name: string, value: string): void {\n    assertHeaderSafe(name, value);\n    super.set(name, value);\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    assertHeaderSafe(name, value);\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/** CR or LF splits the response (header injection); NUL ends it early on some hosts.\n *  The value stays out of the error: it may be what an attacker sent. */\nexport function assertHeaderSafe(name: string, value: string): void {\n  if (hasControlBreak(name) || hasControlBreak(value))\n    throw new TypeError(`Invalid header ${JSON.stringify(name.slice(0, 64))}: CR, LF or NUL`);\n}\n\nfunction hasControlBreak(text: string): boolean {\n  // one pass, no allocation\n  for (let i = 0; i < text.length; i++) {\n    const code = text.charCodeAt(i);\n    if (code === 13 || code === 10 || code === 0) return true;\n  }\n  return false;\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/httpMethod.d.ts

@@ -0,0 +1,3 @@
+import { HttpMethod } from '../types/context.ts';
+export declare function toHttpMethod(method: string | undefined): HttpMethod;
+//# sourceMappingURL=httpMethod.d.ts.map

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

@@ -0,0 +1,21 @@
+//#region src/lib/httpMethod.ts
+var HTTP_METHODS = Object.assign(Object.create(null), {
+	GET: "GET",
+	HEAD: "HEAD",
+	POST: "POST",
+	PUT: "PUT",
+	DELETE: "DELETE",
+	CONNECT: "CONNECT",
+	OPTIONS: "OPTIONS",
+	TRACE: "TRACE",
+	PATCH: "PATCH",
+	QUERY: "QUERY"
+});
+/** HTTP methods are case sensitive, so `get` is `OTHER`. */
+function toHttpMethod(method) {
+	return method && HTTP_METHODS[method] || "OTHER";
+}
+//#endregion
+export { toHttpMethod };
+
+//# sourceMappingURL=httpMethod.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"httpMethod.js","names":[],"sources":["../../../../src/lib/httpMethod.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {HttpMethod} from '../types/context.ts';\n\n// null prototype: a `constructor` method off the wire must not read Object.prototype\nconst HTTP_METHODS: Readonly<Record<string, HttpMethod>> = Object.assign(Object.create(null), {\n  GET: 'GET',\n  HEAD: 'HEAD',\n  POST: 'POST',\n  PUT: 'PUT',\n  DELETE: 'DELETE',\n  CONNECT: 'CONNECT',\n  OPTIONS: 'OPTIONS',\n  TRACE: 'TRACE',\n  PATCH: 'PATCH',\n  QUERY: 'QUERY',\n});\n\n/** HTTP methods are case sensitive, so `get` is `OTHER`. */\nexport function toHttpMethod(method: string | undefined): HttpMethod {\n  return (method && HTTP_METHODS[method]) || 'OTHER';\n}\n"],"mappings":";AAUA,IAAM,eAAqD,OAAO,OAAO,OAAO,OAAO,IAAI,GAAG;CAC5F,KAAK;CACL,MAAM;CACN,MAAM;CACN,KAAK;CACL,QAAQ;CACR,SAAS;CACT,SAAS;CACT,OAAO;CACP,OAAO;CACP,OAAO;AACT,CAAC;;AAGD,SAAgB,aAAa,QAAwC;CACnE,OAAQ,UAAU,aAAa,WAAY;AAC7C"}

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

@@ -1,7 +1,2 @@
-import { SerializerCode } from '@mionjs/core';
-export interface QueryBodyResult {
-    rawBody: string;
-    bodyType: SerializerCode;
-}
-export declare function decodeQueryBody(urlQuery: string | undefined, rawBody: unknown): QueryBodyResult | undefined;
+export declare function decodeQueryBody(urlQuery: string | undefined): string | undefined;
 //# sourceMappingURL=queryBody.d.ts.map

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

@@ -1,16 +1,13 @@
 import { findMionQueryParam } from "./urlQuery.js";
-import { FatalError, SerializerModes, StatusCodes, fromBase64Url } from "@mionjs/core";
+import { FatalError, StatusCodes, fromBase64Url } from "@mionjs/core";
 //#region src/lib/queryBody.ts
-function decodeQueryBody(urlQuery, rawBody) {
-	if (rawBody) return void 0;
+/** The JSON body a GET carries in `?data=` */
+function decodeQueryBody(urlQuery) {
 	if (!urlQuery) return void 0;
 	const dataValue = findMionQueryParam(urlQuery, "data");
 	if (!dataValue) return void 0;
 	try {
-		return {
-			rawBody: fromBase64Url(dataValue),
-			bodyType: SerializerModes.stringifyJson
-		};
+		return fromBase64Url(dataValue);
 	} catch (err) {
 		throw invalidQueryBody(err);
 	}

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

@@ -1 +1 @@
-{"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"}
+{"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, StatusCodes} 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\n/** The JSON body a GET carries in `?data=` */\nexport function decodeQueryBody(urlQuery: string | undefined): string | undefined {\n  if (!urlQuery) return undefined;\n  const dataValue = findMionQueryParam(urlQuery, 'data');\n  if (!dataValue) return undefined;\n  try {\n    return fromBase64Url(dataValue);\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":";;;;AAeA,SAAgB,gBAAgB,UAAkD;CAChF,IAAI,CAAC,UAAU,OAAO,KAAA;CACtB,MAAM,YAAY,mBAAmB,UAAU,MAAM;CACrD,IAAI,CAAC,WAAW,OAAO,KAAA;CACvB,IAAI;EACF,OAAO,cAAc,SAAS;CAChC,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.js

@@ -1,4 +1,4 @@
-import { EMPTY_HASH, getHeadersReflectionFromMarkers, getNoopJitFns, getOrCreateGlobal, getReflectionFromMarkers, isAsyncHandler } from "@mionjs/core";
+import { EMPTY_HASH, getHeadersReflectionFromMarkers, getNoopJitFns, 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 {
@@ -11,7 +11,7 @@ var MissingRtFnsError = class extends Error {
 *  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}` : ""));
+		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. Already on 'both'? Then the entry named below comes from a dependency built in 'code' mode: rebuild that dependency with 'both'.` + (cause ? `\nCause: ${cause}` : ""));
 		this.name = "RuntimeCodeGenBlockedError";
 	}
 };
@@ -20,7 +20,7 @@ var CODE_GEN_BLOCKED = /code generation from strings|unsafe-eval/i;
 function isCodeGenBlocked(message) {
 	return !!message && CODE_GEN_BLOCKED.test(message);
 }
-var rawMiddlewareReflectionCache = getOrCreateGlobal("mion.reflection.rawMiddlewareReflectionCache", () => /* @__PURE__ */ new Map());
+var 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}`;
@@ -67,7 +67,7 @@ function assertCompiledParser(methodId, parser, reflection) {
 	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.`);
+		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 the router factory, so the build sees the same value the runtime reads.`);
 	}
 }
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"reflection.js","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,+BAA+B,kBACnC,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,cAAc,cAAc;EAC5B,cAAc,cAAc;EAC5B,eAAe;EACf,eAAe;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,sBACH,gCAAgC,IAAI,OAAO,IAAI,SAAS,OAAO,IAC/D,yBAAyB,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,8BAA8B,eAAe,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,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"}
+{"version":3,"file":"reflection.js","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, 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. Already on 'both'? Then the entry named below comes from a ` +\n        `dependency built in 'code' mode: rebuild that dependency with 'both'.` +\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 = new Map<string, MethodReflect>();\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 the router factory, 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,giBAO1B,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,+CAA+B,IAAI,IAA2B;;AAGpE,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,cAAc,cAAc;EAC5B,cAAc,cAAc;EAC5B,eAAe;EACf,eAAe;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,sBACH,gCAAgC,IAAI,OAAO,IAAI,SAAS,OAAO,IAC/D,yBAAyB,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,8BAA8B,eAAe,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,YAAY;EACzB,MAAM,SAAS,OAAO;EACtB,IAAI,IAAI,KAAK,aAAa,QACxB,MAAM,IAAI,MACR,SAAS,UAAU,cAAc,SAAS,QAAQ,OAAO,uCACnD,IAAI,KAAK,SAAS,kMAE1B;CACJ;AACF"}

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

@@ -1,9 +1,9 @@
 import { isHeadersMiddlewareDef, isMiddlewareDef, isRoute } from "../types/guards.js";
 import { getMiddlewareExecutable, getPlatformMaxBodySize, getRouteExecutable, isPrivateDefinition } from "../router.js";
-import { DEFAULT_PARSER, EMPTY_HASH, HandlerType, MAX_STACK_DEPTH, getJitFnHashes, getOrCreateGlobal, getRouterItemId, resolveCompiledPureFn } from "@mionjs/core";
+import { DEFAULT_PARSER, EMPTY_HASH, HandlerType, MAX_STACK_DEPTH, getJitFnHashes, getRouterItemId, resolveCompiledPureFn } from "@mionjs/core";
 import { RUN_TYPES_PURE_FN_ID_PREFIX, getRTUtils } from "@mionjs/run-types/runtime";
 //#region src/lib/remoteMethods.ts
-var publicMethods = getOrCreateGlobal("mion.remoteMethods.publicMethods", () => /* @__PURE__ */ new Map());
+var publicMethods = /* @__PURE__ */ new Map();
 function resetRemoteMethodsMetadata() {
 	publicMethods.clear();
 }

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

@@ -1 +1 @@
-{"version":3,"file":"remoteMethods.js","names":[],"sources":["../../../../src/lib/remoteMethods.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type RouterEntry, type Routes} from '../types/general.ts';\nimport {type RemoteMethod} from '../types/remoteMethods.ts';\nimport type {PublicApi} from '../types/publicMethods.ts';\nimport type {AnyObject, CompiledTypeFn, CompiledFnData, MethodWithOptions, PureFnsDataCache} from '@mionjs/core';\nimport {isRoute, isHeadersMiddlewareDef, isMiddlewareDef} from '../types/guards.ts';\nimport {getMiddlewareExecutable, getRouteExecutable, isPrivateDefinition, getPlatformMaxBodySize} from '../router.ts';\nimport {\n  getRouterItemId,\n  MAX_STACK_DEPTH,\n  getJitFnHashes,\n  DEFAULT_PARSER,\n  resolveCompiledPureFn,\n  EMPTY_HASH,\n  getOrCreateGlobal,\n  HandlerType,\n} from '@mionjs/core';\nimport {getRTUtils, RUN_TYPES_PURE_FN_ID_PREFIX} from '@mionjs/run-types/runtime';\n\n// ############# PRIVATE STATE #############\nconst publicMethods = getOrCreateGlobal('mion.remoteMethods.publicMethods', () => new Map<string, MethodWithOptions>());\n\n// ############# PUBLIC METHODS #############\nexport function resetRemoteMethodsMetadata() {\n  publicMethods.clear();\n}\n\n/** All the public information and types of the routes, what a router client is generated from. */\nexport function getPublicApi<R extends Routes>(routes: R): PublicApi<R> {\n  return recursiveGetSerializableRoutes(routes) as PublicApi<R>;\n}\n\n// ############# PRIVATE METHODS #############\n\nfunction recursiveGetSerializableRoutes<R extends Routes>(\n  routes: R,\n  currentPointer: string[] = [],\n  publicData: AnyObject = {}\n): AnyObject {\n  const entries = Object.entries(routes);\n  entries.forEach(([key, item]: [string, RouterEntry]) => {\n    const itemPointer = [...currentPointer, key];\n    const id = getRouterItemId(itemPointer);\n\n    if (isPrivateDefinition(item, id)) {\n      publicData[key] = null; // middlewares that don't receive or return data are not public\n    } else if (isMiddlewareDef(item) || isHeadersMiddlewareDef(item) || isRoute(item)) {\n      const executable = getMiddlewareExecutable(id) || getRouteExecutable(id);\n      if (!executable)\n        throw new Error(`Route or Middleware ${id} not found. Please check you have called mion.initRoutes first.`);\n      publicData[key] = getSerializableMethod(executable as RemoteMethod);\n    } else {\n      const subRoutes: Routes = routes[key] as Routes;\n      publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);\n    }\n  });\n\n  return publicData;\n}\n\nexport function getSerializableMethod(executable: RemoteMethod): MethodWithOptions {\n  const existing = publicMethods.get(executable.id);\n  if (existing) return existing as MethodWithOptions;\n\n  const newRemoteMethod: MethodWithOptions = {\n    type: executable.type,\n    id: executable.id,\n    nestLevel: executable.nestLevel,\n    isAsync: executable.isAsync,\n    hasReturnData: executable.hasReturnData,\n    paramsJitHash: executable.paramsJitHash,\n    returnJitHash: executable.returnJitHash,\n    pointer: executable.pointer,\n    paramsCount: executable.paramsCount ?? 0,\n    paramNames: executable.paramNames,\n    // a route whose types could not say takes the platform's number: filled in here, once, so the\n    // client sees the limit the server really applies (the adapter has published it by now)\n    options:\n      executable.type === HandlerType.route && executable.options.maxBodySize === undefined\n        ? {...executable.options, maxBodySize: getPlatformMaxBodySize()}\n        : executable.options,\n  };\n  if (executable.syncId) newRemoteMethod.syncId = executable.syncId;\n  if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;\n  // the client rebuilds a returned HeadersSubset from these names, so they must ride the wire\n  if (executable.headersReturn) {\n    newRemoteMethod.headersReturn = {\n      headerNames: executable.headersReturn.headerNames,\n      jitHash: executable.headersReturn.jitHash,\n    };\n  }\n  if (executable.middlewareIds) newRemoteMethod.middlewareIds = executable.middlewareIds;\n  publicMethods.set(executable.id, newRemoteMethod);\n  return newRemoteMethod as MethodWithOptions;\n}\n\n/** Serializes a pure function and everything it reaches into the wire cache, keyed by id. */\nexport function serializePureDeps(id: string, purFnDeps: PureFnsDataCache, depth = 0) {\n  if (depth >= MAX_STACK_DEPTH) throw new Error(`Max depth reached serializing pure function dependencies, for: ${id}`);\n  // Run-types' own pure fns never ride the wire: their bodies are hollowed in the dist build and served by\n  // the compiler, so each is already registered wherever `@mionjs/run-types` is loaded, guaranteed on the\n  // client since @mionjs/core value-imports it. addSerializedJitCaches skipped them on restore anyway.\n  if (id.startsWith(RUN_TYPES_PURE_FN_ID_PREFIX)) return;\n  // prevents infinite recursion on circular dependencies\n  if (purFnDeps[id]) return;\n  const pureDep = resolveCompiledPureFn(id);\n  if (!pureDep) throw new Error(`Pure function ${id} not found`);\n  // The client rebuilds a pure fn as `new Function(...paramNames, code)` and nothing else, so an entry with\n  // no code is unrecoverable there: fail here instead of shipping a payload that breaks on first use. With\n  // built-ins filtered out above, only a fn registered at runtime with no body reaches this: server-only.\n  if (!pureDep.code)\n    throw new Error(\n      `Pure function ${id} has no code payload and cannot be serialized to the client. ` +\n        `Runtime-registered pure fns are server-only; the client can rebuild only build-extracted ones.`\n    );\n  purFnDeps[id] = {\n    ...pureDep,\n    code: pureDep.code,\n    pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : undefined,\n  };\n  pureDep.pureFnDependencies?.forEach((depId) => serializePureDeps(depId, purFnDeps, depth + 1));\n}\n\nexport function serializeJitFn(rtFnHash: string, deps: Record<string, CompiledFnData>, purFnDeps: PureFnsDataCache, depth = 0) {\n  if (depth >= MAX_STACK_DEPTH)\n    throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${rtFnHash}`);\n  const jitFn = getRTUtils().getRT(rtFnHash);\n  if (!jitFn) throw new Error(`Jit function ${rtFnHash} not found`);\n  if (deps[rtFnHash]) return; // already serialized and prevent infinite recursion on circular dependencies\n  const serializedJitFn = getSerializableJitCompiler(jitFn);\n  deps[rtFnHash] = serializedJitFn;\n  jitFn.rtDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));\n  jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));\n}\n\nexport function serializeMethodDeps(\n  method: MethodWithOptions,\n  deps: Record<string, CompiledFnData>,\n  purFnDeps: PureFnsDataCache\n) {\n  const {paramsJitHash, returnJitHash} = method;\n  // an empty hash means no params, or a void return\n  const utl = getRTUtils();\n  const parser = method.options.parser ?? DEFAULT_PARSER;\n  if (paramsJitHash !== EMPTY_HASH) {\n    const paramsJitHashes = getJitFnHashes(paramsJitHash, parser.params);\n    for (const k in paramsJitHashes) {\n      if (utl.getRT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);\n    }\n  }\n  if (returnJitHash !== EMPTY_HASH) {\n    const returnJitHashes = getJitFnHashes(returnJitHash, parser.return);\n    let foundAny = false;\n    for (const k in returnJitHashes) {\n      if (utl.getRT(returnJitHashes[k])) {\n        serializeJitFn(returnJitHashes[k], deps, purFnDeps);\n        foundAny = true;\n      }\n    }\n    if (!foundAny) {\n      throw new Error(\n        `Method \"${method.id}\" declares returnJitHash=\"${returnJitHash}\" but no JIT functions are registered under that hash. ` +\n          `This usually means a Promise/Function return type was not unwrapped before computing the hash.`\n      );\n    }\n  }\n}\n\nfunction getSerializableJitCompiler(comp: CompiledTypeFn): CompiledFnData {\n  return {\n    typeName: comp.typeName,\n    fnID: comp.fnID,\n    // the exact emitting family — upstream's findRTForType gates on it, and unlike fnID it is\n    // not composited, so the client cannot recover it from anything else on the wire\n    familyTag: comp.familyTag,\n    rtFnHash: comp.rtFnHash,\n    args: {...comp.args},\n    isNoop: comp.isNoop,\n    defaultParamValues: {...comp.defaultParamValues},\n    code: comp.code,\n    rtDependencies: comp.rtDependencies ? [...comp.rtDependencies] : undefined,\n    pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : undefined,\n    // an alwaysThrow entry has no code, only this message; without it the client cannot rebuild\n    // the throwing factory and surfaces a bare TypeError instead of the build-time diagnostic\n    alwaysThrowMessage: comp.alwaysThrowMessage,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"remoteMethods.js","names":[],"sources":["../../../../src/lib/remoteMethods.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type RouterEntry, type Routes} from '../types/general.ts';\nimport {type RemoteMethod} from '../types/remoteMethods.ts';\nimport type {PublicApi} from '../types/publicMethods.ts';\nimport type {AnyObject, CompiledTypeFn, CompiledFnData, MethodWithOptions, PureFnsDataCache} from '@mionjs/core';\nimport {isRoute, isHeadersMiddlewareDef, isMiddlewareDef} from '../types/guards.ts';\nimport {getMiddlewareExecutable, getRouteExecutable, isPrivateDefinition, getPlatformMaxBodySize} from '../router.ts';\nimport {\n  getRouterItemId,\n  MAX_STACK_DEPTH,\n  getJitFnHashes,\n  DEFAULT_PARSER,\n  resolveCompiledPureFn,\n  EMPTY_HASH,\n  HandlerType,\n} from '@mionjs/core';\nimport {getRTUtils, RUN_TYPES_PURE_FN_ID_PREFIX} from '@mionjs/run-types/runtime';\n\n// ############# PRIVATE STATE #############\nconst publicMethods = new Map<string, MethodWithOptions>();\n\n// ############# PUBLIC METHODS #############\nexport function resetRemoteMethodsMetadata() {\n  publicMethods.clear();\n}\n\n/** All the public information and types of the routes, what a router client is generated from. */\nexport function getPublicApi<R extends Routes>(routes: R): PublicApi<R> {\n  return recursiveGetSerializableRoutes(routes) as PublicApi<R>;\n}\n\n// ############# PRIVATE METHODS #############\n\nfunction recursiveGetSerializableRoutes<R extends Routes>(\n  routes: R,\n  currentPointer: string[] = [],\n  publicData: AnyObject = {}\n): AnyObject {\n  const entries = Object.entries(routes);\n  entries.forEach(([key, item]: [string, RouterEntry]) => {\n    const itemPointer = [...currentPointer, key];\n    const id = getRouterItemId(itemPointer);\n\n    if (isPrivateDefinition(item, id)) {\n      publicData[key] = null; // middlewares that don't receive or return data are not public\n    } else if (isMiddlewareDef(item) || isHeadersMiddlewareDef(item) || isRoute(item)) {\n      const executable = getMiddlewareExecutable(id) || getRouteExecutable(id);\n      if (!executable)\n        throw new Error(`Route or Middleware ${id} not found. Please check you have called mion.initRoutes first.`);\n      publicData[key] = getSerializableMethod(executable as RemoteMethod);\n    } else {\n      const subRoutes: Routes = routes[key] as Routes;\n      publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);\n    }\n  });\n\n  return publicData;\n}\n\nexport function getSerializableMethod(executable: RemoteMethod): MethodWithOptions {\n  const existing = publicMethods.get(executable.id);\n  if (existing) return existing as MethodWithOptions;\n\n  const newRemoteMethod: MethodWithOptions = {\n    type: executable.type,\n    id: executable.id,\n    nestLevel: executable.nestLevel,\n    isAsync: executable.isAsync,\n    hasReturnData: executable.hasReturnData,\n    paramsJitHash: executable.paramsJitHash,\n    returnJitHash: executable.returnJitHash,\n    pointer: executable.pointer,\n    paramsCount: executable.paramsCount ?? 0,\n    paramNames: executable.paramNames,\n    // a route with no typed maxBodySize takes the platform's, so the client sees the real limit (published by now)\n    // registration copied a router's added keys onto the options: they reach the client as written\n    options: (executable.type === HandlerType.route && executable.options.maxBodySize === undefined\n      ? {...executable.options, maxBodySize: getPlatformMaxBodySize()}\n      : executable.options) as MethodWithOptions['options'],\n  };\n  if (executable.syncId) newRemoteMethod.syncId = executable.syncId;\n  if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;\n  // the client rebuilds a returned HeadersSubset from these names, so they must ride the wire\n  if (executable.headersReturn) {\n    newRemoteMethod.headersReturn = {\n      headerNames: executable.headersReturn.headerNames,\n      jitHash: executable.headersReturn.jitHash,\n    };\n  }\n  if (executable.middlewareIds) newRemoteMethod.middlewareIds = executable.middlewareIds;\n  publicMethods.set(executable.id, newRemoteMethod);\n  return newRemoteMethod as MethodWithOptions;\n}\n\n/** Serializes a pure function and everything it reaches into the wire cache, keyed by id. */\nexport function serializePureDeps(id: string, purFnDeps: PureFnsDataCache, depth = 0) {\n  if (depth >= MAX_STACK_DEPTH) throw new Error(`Max depth reached serializing pure function dependencies, for: ${id}`);\n  // Run-types' own pure fns never ride the wire: their bodies are hollowed in the dist build and served by\n  // the compiler, so each is already registered wherever `@mionjs/run-types` is loaded, guaranteed on the\n  // client since @mionjs/core value-imports it. addSerializedJitCaches skipped them on restore anyway.\n  if (id.startsWith(RUN_TYPES_PURE_FN_ID_PREFIX)) return;\n  // prevents infinite recursion on circular dependencies\n  if (purFnDeps[id]) return;\n  const pureDep = resolveCompiledPureFn(id);\n  if (!pureDep) throw new Error(`Pure function ${id} not found`);\n  // The client rebuilds a pure fn as `new Function(...paramNames, code)` and nothing else, so an entry with\n  // no code is unrecoverable there: fail here instead of shipping a payload that breaks on first use. With\n  // built-ins filtered out above, only a fn registered at runtime with no body reaches this: server-only.\n  if (!pureDep.code)\n    throw new Error(\n      `Pure function ${id} has no code payload and cannot be serialized to the client. ` +\n        `Runtime-registered pure fns are server-only; the client can rebuild only build-extracted ones.`\n    );\n  purFnDeps[id] = {\n    ...pureDep,\n    code: pureDep.code,\n    pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : undefined,\n  };\n  pureDep.pureFnDependencies?.forEach((depId) => serializePureDeps(depId, purFnDeps, depth + 1));\n}\n\nexport function serializeJitFn(rtFnHash: string, deps: Record<string, CompiledFnData>, purFnDeps: PureFnsDataCache, depth = 0) {\n  if (depth >= MAX_STACK_DEPTH)\n    throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${rtFnHash}`);\n  const jitFn = getRTUtils().getRT(rtFnHash);\n  if (!jitFn) throw new Error(`Jit function ${rtFnHash} not found`);\n  if (deps[rtFnHash]) return; // already serialized and prevent infinite recursion on circular dependencies\n  const serializedJitFn = getSerializableJitCompiler(jitFn);\n  deps[rtFnHash] = serializedJitFn;\n  jitFn.rtDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));\n  jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));\n}\n\nexport function serializeMethodDeps(\n  method: MethodWithOptions,\n  deps: Record<string, CompiledFnData>,\n  purFnDeps: PureFnsDataCache\n) {\n  const {paramsJitHash, returnJitHash} = method;\n  // an empty hash means no params, or a void return\n  const utl = getRTUtils();\n  const parser = method.options.parser ?? DEFAULT_PARSER;\n  if (paramsJitHash !== EMPTY_HASH) {\n    const paramsJitHashes = getJitFnHashes(paramsJitHash, parser.params);\n    for (const k in paramsJitHashes) {\n      if (utl.getRT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);\n    }\n  }\n  if (returnJitHash !== EMPTY_HASH) {\n    const returnJitHashes = getJitFnHashes(returnJitHash, parser.return);\n    let foundAny = false;\n    for (const k in returnJitHashes) {\n      if (utl.getRT(returnJitHashes[k])) {\n        serializeJitFn(returnJitHashes[k], deps, purFnDeps);\n        foundAny = true;\n      }\n    }\n    if (!foundAny) {\n      throw new Error(\n        `Method \"${method.id}\" declares returnJitHash=\"${returnJitHash}\" but no JIT functions are registered under that hash. ` +\n          `This usually means a Promise/Function return type was not unwrapped before computing the hash.`\n      );\n    }\n  }\n}\n\nfunction getSerializableJitCompiler(comp: CompiledTypeFn): CompiledFnData {\n  return {\n    typeName: comp.typeName,\n    fnID: comp.fnID,\n    // the exact emitting family — upstream's findRTForType gates on it, and unlike fnID it is\n    // not composited, so the client cannot recover it from anything else on the wire\n    familyTag: comp.familyTag,\n    rtFnHash: comp.rtFnHash,\n    args: {...comp.args},\n    isNoop: comp.isNoop,\n    defaultParamValues: {...comp.defaultParamValues},\n    code: comp.code,\n    rtDependencies: comp.rtDependencies ? [...comp.rtDependencies] : undefined,\n    pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : undefined,\n    // an alwaysThrow entry has no code, only this message; without it the client cannot rebuild\n    // the throwing factory and surfaces a bare TypeError instead of the build-time diagnostic\n    alwaysThrowMessage: comp.alwaysThrowMessage,\n  };\n}\n"],"mappings":"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"}

package/.dist/esm/src/middlewares/fetchMetadata.js

@@ -3,16 +3,16 @@ import { getBatchIds } from "../batches.js";
 import { markOnDemand, middleware, mionInternalRouteIds } from "../lib/handlers.js";
 import { getSerializableMethod, serializeMethodDeps } from "../lib/remoteMethods.js";
 import { getAllExecutablesIds, getAnyExecutable, getBuildVersion, getMiddlewareExecutable, getRouteExecutable, getRouterOptions, getTotalExecutables } from "../router.js";
-import { __rt_A0Qb_E1CjDEA } from "../../.mion/types/A0Qb_E1CjDEA.js";
-import { __rt_A0Qb_fMIJ1JT } from "../../.mion/types/A0Qb_fMIJ1JT.js";
-import { __rt_Ky89_E1CjDEA } from "../../.mion/types/Ky89_E1CjDEA.js";
-import { __rt_Ky89_fMIJ1JT } from "../../.mion/types/Ky89_fMIJ1JT.js";
-import { __rt_Xhuv_E1CjDEA } from "../../.mion/types/Xhuv_E1CjDEA.js";
-import { __rt_OBOg_E1CjDEA } from "../../.mion/types/OBOg_E1CjDEA.js";
-import { __rt_OBOg_fMIJ1JT } from "../../.mion/types/OBOg_fMIJ1JT.js";
-import { __rt_Xhuv_fMIJ1JT } from "../../.mion/types/Xhuv_fMIJ1JT.js";
-import { __rt_mzca_fMIJ1JT } from "../../.mion/types/mzca_fMIJ1JT.js";
-import { __rt_E1CjDEA, __rt_HmqctzF, __rt_fMIJ1JT, __rt_w6KmCD1 } from "../../.mion/types/rt/eF4wQzU6Fd.js";
+import { __rt_A0Qb_bWgCH09 } from "../../.mion/types/A0Qb_bWgCH09.js";
+import { __rt_A0Qb_jMcsHAh } from "../../.mion/types/A0Qb_jMcsHAh.js";
+import { __rt_Ky89_bWgCH09 } from "../../.mion/types/Ky89_bWgCH09.js";
+import { __rt_Ky89_jMcsHAh } from "../../.mion/types/Ky89_jMcsHAh.js";
+import { __rt_OBOg_bWgCH09 } from "../../.mion/types/OBOg_bWgCH09.js";
+import { __rt_Xhuv_jMcsHAh } from "../../.mion/types/Xhuv_jMcsHAh.js";
+import { __rt_OBOg_jMcsHAh } from "../../.mion/types/OBOg_jMcsHAh.js";
+import { __rt_Xhuv_bWgCH09 } from "../../.mion/types/Xhuv_bWgCH09.js";
+import { __rt_mzca_bWgCH09 } from "../../.mion/types/mzca_bWgCH09.js";
+import { __rt_A7jnlIr, __rt_RZVVXkq, __rt_bWgCH09, __rt_jMcsHAh } from "../../.mion/types/rt/eF4wQzU6Fd.js";
 import { BUILD_VERSION_HEADER, FatalError, RpcError, StatusCodes } from "@mionjs/core";
 //#region src/middlewares/fetchMetadata.ts
 /** Rows alongside the call; with a mode, rows alone and the call stopped before its route runs. */
@@ -80,17 +80,17 @@ var mionFetchMetadata = markOnDemand(middleware(fetchMetadata, {
 	},
 	maxBodySize: 4096
 }, [
-	__rt_Xhuv_fMIJ1JT,
-	__rt_OBOg_fMIJ1JT,
-	__rt_mzca_fMIJ1JT,
-	__rt_A0Qb_fMIJ1JT,
-	__rt_Ky89_fMIJ1JT
+	__rt_Xhuv_bWgCH09,
+	__rt_OBOg_bWgCH09,
+	__rt_mzca_bWgCH09,
+	__rt_A0Qb_bWgCH09,
+	__rt_Ky89_bWgCH09
 ], [
-	__rt_Xhuv_E1CjDEA,
-	__rt_OBOg_E1CjDEA,
-	__rt_A0Qb_E1CjDEA,
-	__rt_Ky89_E1CjDEA
-], __rt_fMIJ1JT, __rt_E1CjDEA, __rt_w6KmCD1, __rt_HmqctzF), setBuildVersionHeader);
+	__rt_Xhuv_jMcsHAh,
+	__rt_OBOg_jMcsHAh,
+	__rt_A0Qb_jMcsHAh,
+	__rt_Ky89_jMcsHAh
+], __rt_bWgCH09, __rt_jMcsHAh, __rt_A7jnlIr, __rt_RZVVXkq), setBuildVersionHeader);
 //#endregion
 export { getMethodsDataFor, mionFetchMetadata };
 

package/.dist/esm/src/middlewares/security.d.ts

@@ -0,0 +1,9 @@
+import { FatalError } from '@mionjs/core';
+import { CallContext } from '../types/context.ts';
+import { MionSecurityOptions } from '../types/general.ts';
+export declare function mionSecurity(options?: MionSecurityOptions): import('../types/definitions.ts').MiddlewareDef<(ctx: CallContext) => Promise<ReturnType<(ctx: CallContext, origin: string | null | undefined, trusted: boolean, sameOrigin: boolean) => void | FatalError<"unclear-body-length", any> | FatalError<"method-not-allowed", any> | FatalError<"cross-origin-request-refused", any> | FatalError<"unsupported-media-type", any>>>, {
+    readonly alwaysRun: true;
+}, Partial<import('../types/general.ts').RouterOptions<any, any>>> | import('../types/definitions.ts').MiddlewareDef<(ctx: CallContext) => ReturnType<(ctx: CallContext, origin: string | null | undefined, trusted: boolean, sameOrigin: boolean) => void | FatalError<"unclear-body-length", any> | FatalError<"method-not-allowed", any> | FatalError<"cross-origin-request-refused", any> | FatalError<"unsupported-media-type", any>>, {
+    readonly alwaysRun: true;
+}, Partial<import('../types/general.ts').RouterOptions<any, any>>>;
+//# sourceMappingURL=security.d.ts.map