@mionjs/router 0.13.0 → 0.14.0

package/.dist/cjs/src/lib/dispatchError.cjs

@@ -1,82 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src_constants = require("../constants.cjs");
-let _mionjs_core = require("@mionjs/core");
-//#region src/lib/dispatchError.ts
-/** The response for an error raised outside the router by any adapter; it goes in `@thrownErrors` like a route error. */
-function getRouterFatalErrorResponse(returnErr, respHeaders) {
-	(0, _mionjs_core.markFatal)(returnErr);
-	const body = { "@thrownErrors": { [_mionjs_core.MION_ROUTES.platformError]: returnErr } };
-	respHeaders.set("x-rpc-error", errorHeaderValue(returnErr.type));
-	return {
-		statusCode: returnErr.statusCode || _mionjs_core.StatusCodes.SERVER_ERROR,
-		contentType: require_src_constants.JSON_CONTENT_TYPE,
-		hasErrors: true,
-		fatalError: returnErr,
-		headers: respHeaders,
-		body
-	};
-}
-/** An app-thrown RpcError may carry any string as its `type`, and a CR or LF there is header injection on
-*  adapters that write headers unchecked (or an ERR_INVALID_CHAR throw on node). Anything outside the token
-*  alphabet reports as `unknown-error` on the header; the body still carries the full type. */
-var HEADER_SAFE_TYPE = /^[A-Za-z0-9_.:@-]{1,128}$/;
-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
-*  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). */
-function markResponseFailed(context, rpcError, fallbackStatus) {
-	const response = context.response;
-	if (!response.hasErrors) {
-		response.headers.set("x-rpc-error", errorHeaderValue(rpcError.type));
-		response.fatalError = rpcError;
-	}
-	response.statusCode = rpcError.statusCode ?? fallbackStatus;
-	response.hasErrors = true;
-}
-/** Whatever an adapter caught, as the mion error the wire carries. */
-function toRpcError(err) {
-	return err instanceof _mionjs_core.RpcError ? err : new _mionjs_core.FatalError({
-		publicMessage: "Unknown Error",
-		type: "unknown-error",
-		originalError: err
-	});
-}
-/** Records an undeclared error under `key` and ends the request: it lands in `@thrownErrors` untyped, sets
-*  the status and the error header, and stops every later member that does not declare `alwaysRun`.
-*  Undeclared means thrown, or returned by a raw middleware, which cannot declare a return type; a declared
-*  error is returned from a handler and goes straight into `response.body`. The key is normally the member
-*  that failed; an adapter passes its own (`mion@platformError`) for a request no member could run. */
-function recordUndeclaredError(context, key, err) {
-	const rpcError = (0, _mionjs_core.markFatal)(err instanceof _mionjs_core.RpcError ? err : new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
-		publicMessage: `Unknown error in handler "${key}" of route ExecutionChain.`,
-		originalError: err,
-		type: "unknown-error"
-	}));
-	markResponseFailed(context, rpcError, _mionjs_core.StatusCodes.UNEXPECTED_ERROR);
-	addThrownError(context, key, rpcError);
-}
-/** Unlike recordUndeclaredError, does not end the request. */
-function addThrownError(context, key, rpcError) {
-	const thrownErrors = context.request.thrownErrors || {};
-	thrownErrors[key] = rpcError;
-	context.request.thrownErrors = thrownErrors;
-}
-function hasThrownError(context, key) {
-	const thrownErrors = context.request.thrownErrors;
-	return !!thrownErrors && Object.hasOwn(thrownErrors, key);
-}
-//#endregion
-exports.addThrownError = addThrownError;
-exports.errorHeaderValue = errorHeaderValue;
-exports.getRouterFatalErrorResponse = getRouterFatalErrorResponse;
-exports.hasThrownError = hasThrownError;
-exports.markResponseFailed = markResponseFailed;
-exports.recordUndeclaredError = recordUndeclaredError;
-exports.toRpcError = toRpcError;
-
-//# sourceMappingURL=dispatchError.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dispatchError.cjs","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,CAAA,GAAA,aAAA,WAAU,SAAS;CACnB,MAAM,OAAqB,EACzB,iBAAiB,GAAE,aAAA,YAAY,gBAAgB,UAAS,EAC1D;CACA,YAAY,IAAI,eAAe,iBAAiB,UAAU,IAAI,CAAC;CAS/D,OAAO;EAPL,YAAY,UAAU,cAAc,aAAA,YAAY;EAChD,aAAa,sBAAA;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,aAAA,WAClB,MACA,IAAI,aAAA,WAAW;EAAC,eAAe;EAAiB,MAAM;EAAiB,eAAe;CAAY,CAAC;AACzG;;;;;;AAOA,SAAgB,sBAAsB,SAAsB,KAAa,KAAU;CACjF,MAAM,YAAA,GAAA,aAAA,WACJ,eAAe,aAAA,WACX,MACA,IAAI,aAAA,WAAW;EACb,YAAY,aAAA,YAAY;EACxB,eAAe,6BAA6B,IAAI;EAChD,eAAe;EACf,MAAM;CACR,CAAC,CACP;CACA,mBAAmB,SAAS,UAAU,aAAA,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/cjs/src/lib/dispatchError.d.ts

@@ -1,10 +0,0 @@
-import { RpcError } from '@mionjs/core';
-import { CallContext, MionHeaders, MionResponse } from '../types/context.ts';
-export declare function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse;
-export declare function errorHeaderValue(type: string): string;
-export declare function markResponseFailed(context: CallContext, rpcError: RpcError<string>, fallbackStatus: number): void;
-export declare function toRpcError(err: unknown): RpcError<string>;
-export declare function recordUndeclaredError(context: CallContext, key: string, err: any): void;
-export declare function addThrownError(context: CallContext, key: string, rpcError: RpcError<string>): void;
-export declare function hasThrownError(context: CallContext, key: string): boolean;
-//# sourceMappingURL=dispatchError.d.ts.map

package/.dist/cjs/src/lib/handlers.cjs

@@ -1,99 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _mionjs_core = require("@mionjs/core");
-//#region src/lib/handlers.ts
-var route = (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({
-	type: _mionjs_core.HandlerType.route,
-	handler,
-	options: opts,
-	rtFns: {
-		paramsFns,
-		returnFns,
-		paramsId,
-		returnId,
-		isAsyncId,
-		syncId
-	}
-});
-/** Typed as the same helper as `route()`, so both keep the marker signature the scanner reads at the call site. */
-function routeWithMutation(isMutation) {
-	return (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({
-		type: _mionjs_core.HandlerType.route,
-		handler,
-		options: {
-			...opts,
-			isMutation
-		},
-		rtFns: {
-			paramsFns,
-			returnFns,
-			paramsId,
-			returnId,
-			isAsyncId,
-			syncId
-		}
-	});
-}
-/** Route handler for read-only queries. Uses GET with ?data=base64url on the client when payload fits. */
-var query = routeWithMutation(false);
-var mutation = routeWithMutation(true);
-var middleware = (handler, opts, paramsFns, returnFns, paramsId, returnId, isAsyncId, syncId) => ({
-	type: _mionjs_core.HandlerType.middleware,
-	handler,
-	options: opts,
-	rtFns: {
-		paramsFns,
-		returnFns,
-		paramsId,
-		returnId,
-		isAsyncId,
-		syncId
-	}
-});
-var headersMiddleware = (handler, opts, headersFns, paramsFns, returnFns, headersId, paramsId, returnId, isAsyncId, syncId) => ({
-	type: _mionjs_core.HandlerType.headersMiddleware,
-	handler,
-	options: opts,
-	rtFns: {
-		paramsFns,
-		returnFns,
-		paramsId,
-		returnId,
-		isAsyncId,
-		syncId,
-		headersFns,
-		headersId
-	}
-});
-var rawMiddleware = (handler, opts) => ({
-	type: _mionjs_core.HandlerType.rawMiddleware,
-	handler,
-	options: opts
-});
-/** Each on-demand middleware, with what it does on every call even without its slot. */
-var onDemandMiddlewares = /* @__PURE__ */ new WeakMap();
-/** Internal: the middleware runs only when the request body carries its slot, so an absent slot costs nothing */
-function markOnDemand(def, onEveryCall) {
-	onDemandMiddlewares.set(def, onEveryCall);
-	return def;
-}
-function isOnDemandMiddleware(def) {
-	return onDemandMiddlewares.has(def);
-}
-function getOnEveryCall(def) {
-	return onDemandMiddlewares.get(def);
-}
-/** mion's own ids, never exposed to clients */
-var mionInternalRouteIds = new Set(Object.values(_mionjs_core.MION_ROUTES));
-//#endregion
-exports.getOnEveryCall = getOnEveryCall;
-exports.headersMiddleware = headersMiddleware;
-exports.isOnDemandMiddleware = isOnDemandMiddleware;
-exports.markOnDemand = markOnDemand;
-exports.middleware = middleware;
-exports.mionInternalRouteIds = mionInternalRouteIds;
-exports.mutation = mutation;
-exports.query = query;
-exports.rawMiddleware = rawMiddleware;
-exports.route = route;
-
-//# sourceMappingURL=handlers.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.cjs","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,aAAA,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,aAAA,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,aAAA,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,aAAA,YAAY;CAClB;CACA,SAAS;CACT,OAAO;EAAC;EAAW;EAAW;EAAU;EAAU;EAAW;EAAQ;EAAY;CAAS;AAC5F;AAEA,IAAa,iBAA0D,SAAS,UAAU;CACxF,MAAM,aAAA,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,aAAA,WAAW,CAAC"}

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

@@ -1,15 +0,0 @@
-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 middleware: MiddlewareHelper<RouterOptionsInput>;
-export declare const headersMiddleware: HeadersMiddlewareHelper<RouterOptionsInput>;
-export declare const rawMiddleware: RawMiddlewareHelper<RouterOptionsInput>;
-type OnEveryCall = (ctx: CallContext) => void;
-export declare function markOnDemand<Def extends object>(def: Def, onEveryCall?: OnEveryCall): Def;
-export declare function isOnDemandMiddleware(def: object): boolean;
-export declare function getOnEveryCall(def: object): OnEveryCall | undefined;
-export declare const mionInternalRouteIds: ReadonlySet<string>;
-export {};
-//# sourceMappingURL=handlers.d.ts.map

package/.dist/cjs/src/lib/headers.cjs

@@ -1,181 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../constants.cjs");
-const require_src_router = require("../router.cjs");
-//#region src/lib/headers.ts
-var PROTO_KEY = "__proto__";
-/** Case-insensitive HTTP headers, like the fetch Headers API but optimized for performance.
-*  https://developer.mozilla.org/en-US/docs/Web/API/Headers */
-var MionHeadersImpl = class {
-	headers;
-	/** Read by the response headers pool only; request headers ignore it. */
-	unused = true;
-	constructor(headers) {
-		this.headers = headers;
-	}
-	append(name, value) {
-		this.unused = false;
-		const nl = name.toLowerCase();
-		if (nl === PROTO_KEY) return;
-		const existing = readHeader(this.headers, nl);
-		const headerValue = toSingleHeader(value);
-		if (existing) this.headers[nl] = `${existing}, ${headerValue}`;
-		else this.headers[nl] = headerValue;
-	}
-	delete(name) {
-		this.unused = false;
-		delete this.headers[name.toLowerCase()];
-	}
-	get(name) {
-		return readHeader(this.headers, name.toLowerCase());
-	}
-	set(name, value) {
-		this.unused = false;
-		const ln = name.toLowerCase();
-		if (ln === PROTO_KEY) return;
-		this.headers[ln] = value;
-	}
-	has(name) {
-		return !!readHeader(this.headers, name.toLowerCase());
-	}
-	entries() {
-		return Object.entries(this.headers).map(([name, value]) => [name, joined(value)]).values();
-	}
-	keys() {
-		return new Map(Object.entries(this.headers)).keys();
-	}
-	values() {
-		return Object.values(this.headers).map(joined).values();
-	}
-};
-/** Response headers over a copy of the defaults, for an adapter that answers from a header record (uws, aws). */
-var RecordResponseHeaders = class extends MionHeadersImpl {
-	defaults;
-	constructor(defaults) {
-		super({ ...defaults });
-		this.defaults = defaults;
-	}
-	/** Keeps a repeated name's values apart, never joined: the adapter writes them its own way. */
-	append(name, value) {
-		this.unused = false;
-		const key = name.toLowerCase();
-		if (key === PROTO_KEY) return;
-		const current = this.headers[key];
-		if (Array.isArray(current)) current.push(value);
-		else if (typeof current === "string" && current) this.headers[key] = [current, value];
-		else this.headers[key] = value;
-	}
-	/** Walks the headers with no pair array per header; a repeated name gives its values apart. */
-	forEach(visit) {
-		for (const name in this.headers) visit(name, this.headers[name]);
-	}
-};
-/** The response headers of the fetch adapters (bun, cloudflare, vercel). */
-var FetchResponseHeaders = class {
-	defaults;
-	/** What the reply hands to `Response`, which copies it. */
-	native = new Headers();
-	unused = true;
-	constructor(defaults) {
-		this.defaults = defaults;
-		for (const name in defaults) this.native.set(name, defaults[name]);
-	}
-	set(name, value) {
-		this.unused = false;
-		this.native.set(name, value);
-	}
-	append(name, value) {
-		this.unused = false;
-		this.native.append(name, value);
-	}
-	delete(name) {
-		this.unused = false;
-		this.native.delete(name);
-	}
-	get(name) {
-		return this.native.get(name);
-	}
-	has(name) {
-		return this.native.has(name);
-	}
-	entries() {
-		return this.native.entries();
-	}
-	keys() {
-		return this.native.keys();
-	}
-	values() {
-		return this.native.values();
-	}
-};
-var MAX_UNUSED_HEADERS = 256;
-var unusedRecordHeaders = [];
-var unusedFetchHeaders = [];
-var newRecordHeaders = (defaults) => new RecordResponseHeaders(defaults);
-var newFetchHeaders = (defaults) => new FetchResponseHeaders(defaults);
-/** Response headers holding the defaults and nothing else, from the pool or new. */
-var getDefaultHeaders = () => takeUnused(unusedRecordHeaders, newRecordHeaders);
-/** Like `getDefaultHeaders`, over a native `Headers` for the fetch adapters. */
-var getDefaultFetchHeaders = () => takeUnused(unusedFetchHeaders, newFetchHeaders);
-/** Gives headers back once the reply is sent; written ones are dropped. */
-var releaseHeaders = (headers) => giveBackUnused(unusedRecordHeaders, headers);
-function takeUnused(pool, create) {
-	const defaults = require_src_router.getResponseDefaults();
-	const headers = pool.pop();
-	if (headers?.defaults === defaults) return headers;
-	pool.length = 0;
-	return create(defaults);
-}
-function giveBackUnused(pool, headers) {
-	if (headers.unused && pool.length < MAX_UNUSED_HEADERS) pool.push(headers);
-}
-function replyFetch(mionResp, headers) {
-	if (!headers.unused || mionResp.contentType !== "application/json; charset=utf-8") headers.set("content-type", mionResp.contentType);
-	const response = Response.json(mionResp.body, {
-		status: mionResp.statusCode,
-		headers: headers.native
-	});
-	giveBackUnused(unusedFetchHeaders, headers);
-	return response;
-}
-/** A fetch-like (not identical) Headers object over a header record, for an incoming request carrying its
-*  headers as an object: IncomingMessage.headers, ApiGatewayEvent.headers.
-*  https://developer.mozilla.org/en-US/docs/Web/API/Headers */
-function headersFromRecord(headersObj, skipToLower = false) {
-	return new MionHeadersImpl(parseHeaders(headersObj, skipToLower));
-}
-/** A header value, or undefined for a name the record does not carry as an own string (a prototype
-*  hit is a function or an object). A platform record may hold an array (node's `set-cookie`). */
-function readHeader(headers, lowerName) {
-	const value = headers[lowerName];
-	if (typeof value === "string") return value;
-	return Array.isArray(value) ? value.join(", ") : void 0;
-}
-function joined(value) {
-	return Array.isArray(value) ? value.join(", ") : value;
-}
-function toSingleHeader(value) {
-	if (Array.isArray(value)) return value.join(", ");
-	return value;
-}
-function parseHeaders(headersObj, skipToLower = false) {
-	if (skipToLower) return headersObj;
-	const entries = Object.entries(headersObj);
-	const headers = Object.create(null);
-	for (let i = 0; i < entries.length; i++) {
-		const [name, value] = entries[i];
-		if (!value) continue;
-		const ln = name.toLowerCase();
-		headers[ln] = toSingleHeader(value);
-	}
-	return headers;
-}
-//#endregion
-exports.FetchResponseHeaders = FetchResponseHeaders;
-exports.RecordResponseHeaders = RecordResponseHeaders;
-exports.getDefaultFetchHeaders = getDefaultFetchHeaders;
-exports.getDefaultHeaders = getDefaultHeaders;
-exports.headersFromRecord = headersFromRecord;
-exports.releaseHeaders = releaseHeaders;
-exports.replyFetch = replyFetch;
-
-//# sourceMappingURL=headers.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"headers.cjs","names":[],"sources":["../../../../src/lib/headers.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {MionHeaders, MionResponse, PooledHeaders, ResponseDefaults} from '../types/context.ts';\nimport {JSON_CONTENT_TYPE} from '../constants.ts';\nimport {getResponseDefaults} from '../router.ts';\n\n// ############# PUBLIC METHODS #############\n\n// an array for a name appended twice on response headers (node's request record may hold one too)\ntype HeadersRecord = Record<string, string | string[]>;\n\nconst PROTO_KEY = '__proto__';\n\n/** Case-insensitive HTTP headers, like the fetch Headers API but optimized for performance.\n *  https://developer.mozilla.org/en-US/docs/Web/API/Headers */\nclass MionHeadersImpl implements MionHeaders {\n  // The record may be a plain object handed over by the platform (node's IncomingMessage.headers is one),\n  // where `constructor` or `toString` would be \"found\" on the prototype chain. A prototype hit is never a\n  // string, so a read checks the VALUE's type: cheaper than an own-key check per read (14 vs 23 ns).\n  // `__proto__` is never written: on a plain object that assignment swaps the prototype.\n  /** Read by the response headers pool only; request headers ignore it. */\n  unused = true;\n\n  constructor(protected headers: HeadersRecord) {}\n\n  append(name: string, value: string): void {\n    this.unused = false;\n    const nl = name.toLowerCase();\n    if (nl === PROTO_KEY) return;\n    const existing = readHeader(this.headers, nl);\n    const headerValue = toSingleHeader(value);\n    if (existing) {\n      this.headers[nl] = `${existing}, ${headerValue}`;\n    } else {\n      this.headers[nl] = headerValue;\n    }\n  }\n\n  delete(name: string): void {\n    this.unused = false;\n    delete this.headers[name.toLowerCase()];\n  }\n\n  get(name: string): string | undefined | null {\n    return readHeader(this.headers, name.toLowerCase());\n  }\n\n  set(name: string, value: string): void {\n    this.unused = false;\n    const ln = name.toLowerCase();\n    if (ln === PROTO_KEY) return;\n    this.headers[ln] = value as string;\n  }\n\n  has(name: string): boolean {\n    return !!readHeader(this.headers, name.toLowerCase());\n  }\n\n  entries(): IterableIterator<[string, string]> {\n    return Object.entries(this.headers)\n      .map(([name, value]): [string, string] => [name, joined(value)])\n      .values();\n  }\n\n  keys(): IterableIterator<string> {\n    return new Map(Object.entries(this.headers)).keys();\n  }\n\n  values(): IterableIterator<string> {\n    return Object.values(this.headers).map(joined).values();\n  }\n}\n\n/** Response headers over a copy of the defaults, for an adapter that answers from a header record (uws, aws). */\nexport class RecordResponseHeaders extends MionHeadersImpl implements PooledHeaders {\n  constructor(readonly defaults: ResponseDefaults) {\n    super({...defaults});\n  }\n\n  /** Keeps a repeated name's values apart, never joined: the adapter writes them its own way. */\n  append(name: string, value: string): void {\n    this.unused = false;\n    const key = name.toLowerCase();\n    if (key === PROTO_KEY) return;\n    const current = this.headers[key] as unknown;\n    // an empty earlier value counts as absent, and so does a prototype hit such as `constructor`\n    if (Array.isArray(current)) current.push(value);\n    else if (typeof current === 'string' && current) this.headers[key] = [current, value];\n    else this.headers[key] = value;\n  }\n\n  /** Walks the headers with no pair array per header; a repeated name gives its values apart. */\n  forEach(visit: (name: string, value: string | string[]) => void): void {\n    for (const name in this.headers) visit(name, this.headers[name]);\n  }\n}\n\n/** The response headers of the fetch adapters (bun, cloudflare, vercel). */\nexport class FetchResponseHeaders implements PooledHeaders {\n  /** What the reply hands to `Response`, which copies it. */\n  readonly native = new Headers();\n  unused = true;\n\n  constructor(readonly defaults: ResponseDefaults) {\n    // one set per name beats building from a record\n    for (const name in defaults) this.native.set(name, defaults[name]);\n  }\n\n  set(name: string, value: string): void {\n    this.unused = false;\n    this.native.set(name, value);\n  }\n  append(name: string, value: string): void {\n    this.unused = false;\n    this.native.append(name, value);\n  }\n  delete(name: string): void {\n    this.unused = false;\n    this.native.delete(name);\n  }\n  get(name: string): string | null {\n    return this.native.get(name);\n  }\n  has(name: string): boolean {\n    return this.native.has(name);\n  }\n  entries(): IterableIterator<[string, string]> {\n    return this.native.entries();\n  }\n  keys(): IterableIterator<string> {\n    return this.native.keys();\n  }\n  values(): IterableIterator<string> {\n    return this.native.values();\n  }\n}\n\n// Pools of unwritten response headers: one serves exactly one request and comes back only if still unused.\nconst MAX_UNUSED_HEADERS = 256;\nconst unusedRecordHeaders: RecordResponseHeaders[] = [];\nconst unusedFetchHeaders: FetchResponseHeaders[] = [];\nconst newRecordHeaders = (defaults: ResponseDefaults) => new RecordResponseHeaders(defaults);\nconst newFetchHeaders = (defaults: ResponseDefaults) => new FetchResponseHeaders(defaults);\n\n/** Response headers holding the defaults and nothing else, from the pool or new. */\nexport const getDefaultHeaders = (): RecordResponseHeaders => takeUnused(unusedRecordHeaders, newRecordHeaders);\n\n/** Like `getDefaultHeaders`, over a native `Headers` for the fetch adapters. */\nexport const getDefaultFetchHeaders = (): FetchResponseHeaders => takeUnused(unusedFetchHeaders, newFetchHeaders);\n\n/** Gives headers back once the reply is sent; written ones are dropped. */\nexport const releaseHeaders = (headers: RecordResponseHeaders): void => giveBackUnused(unusedRecordHeaders, headers);\n\nfunction takeUnused<Pooled extends PooledHeaders>(pool: Pooled[], create: (defaults: ResponseDefaults) => Pooled): Pooled {\n  const defaults = getResponseDefaults();\n  const headers = pool.pop();\n  if (headers?.defaults === defaults) return headers;\n  // the router restarted: pooled headers carry the old defaults\n  pool.length = 0;\n  return create(defaults);\n}\n\nfunction giveBackUnused<Pooled extends PooledHeaders>(pool: Pooled[], headers: Pooled): void {\n  if (headers.unused && pool.length < MAX_UNUSED_HEADERS) pool.push(headers);\n}\n\nexport function replyFetch(mionResp: MionResponse, headers: FetchResponseHeaders): Response {\n  // last, so a handler never replaces it; unused headers already hold the JSON one\n  if (!headers.unused || mionResp.contentType !== JSON_CONTENT_TYPE) headers.set('content-type', mionResp.contentType);\n  // Response copies its headers, so unused ones serve the next request\n  const response = Response.json(mionResp.body, {status: mionResp.statusCode, headers: headers.native});\n  giveBackUnused(unusedFetchHeaders, headers);\n  return response;\n}\n\n/** A fetch-like (not identical) Headers object over a header record, for an incoming request carrying its\n *  headers as an object: IncomingMessage.headers, ApiGatewayEvent.headers.\n *  https://developer.mozilla.org/en-US/docs/Web/API/Headers */\nexport function headersFromRecord(headersObj: Record<string, string>, skipToLower = false): MionHeaders {\n  const headers = parseHeaders(headersObj, skipToLower);\n  return new MionHeadersImpl(headers);\n}\n\n/** A header value, or undefined for a name the record does not carry as an own string (a prototype\n *  hit is a function or an object). A platform record may hold an array (node's `set-cookie`). */\nfunction readHeader(headers: HeadersRecord, lowerName: string): string | undefined {\n  const value = headers[lowerName] as unknown;\n  if (typeof value === 'string') return value;\n  return Array.isArray(value) ? value.join(', ') : undefined;\n}\n\nfunction joined(value: string | string[]): string {\n  return Array.isArray(value) ? value.join(', ') : value;\n}\n\nfunction toSingleHeader(value: string | number): string {\n  if (Array.isArray(value)) return value.join(', ');\n  return value as string;\n}\n\nfunction parseHeaders(headersObj: Record<string, string>, skipToLower = false): HeadersRecord {\n  if (skipToLower) return headersObj;\n  const entries = Object.entries(headersObj);\n  // null-prototype: header names come off the wire\n  const headers: HeadersRecord = Object.create(null);\n  for (let i = 0; i < entries.length; i++) {\n    const [name, value] = entries[i];\n    if (!value) continue;\n    const ln = name.toLowerCase();\n    headers[ln] = toSingleHeader(value);\n  }\n  return headers;\n}\n"],"mappings":"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"}

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

@@ -1,42 +0,0 @@
-import { MionHeaders, MionResponse, PooledHeaders, ResponseDefaults } from '../types/context.ts';
-type HeadersRecord = Record<string, string | string[]>;
-declare class MionHeadersImpl implements MionHeaders {
-    protected headers: HeadersRecord;
-    unused: boolean;
-    constructor(headers: HeadersRecord);
-    append(name: string, value: string): void;
-    delete(name: string): void;
-    get(name: string): string | undefined | null;
-    set(name: string, value: string): void;
-    has(name: string): boolean;
-    entries(): IterableIterator<[string, string]>;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<string>;
-}
-export declare class RecordResponseHeaders extends MionHeadersImpl implements PooledHeaders {
-    readonly defaults: ResponseDefaults;
-    constructor(defaults: ResponseDefaults);
-    append(name: string, value: string): void;
-    forEach(visit: (name: string, value: string | string[]) => void): void;
-}
-export declare class FetchResponseHeaders implements PooledHeaders {
-    readonly defaults: ResponseDefaults;
-    readonly native: import('undici-types').Headers;
-    unused: boolean;
-    constructor(defaults: ResponseDefaults);
-    set(name: string, value: string): void;
-    append(name: string, value: string): void;
-    delete(name: string): void;
-    get(name: string): string | null;
-    has(name: string): boolean;
-    entries(): IterableIterator<[string, string]>;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<string>;
-}
-export declare const getDefaultHeaders: () => RecordResponseHeaders;
-export declare const getDefaultFetchHeaders: () => FetchResponseHeaders;
-export declare const releaseHeaders: (headers: RecordResponseHeaders) => void;
-export declare function replyFetch(mionResp: MionResponse, headers: FetchResponseHeaders): Response;
-export declare function headersFromRecord(headersObj: Record<string, string>, skipToLower?: boolean): MionHeaders;
-export {};
-//# sourceMappingURL=headers.d.ts.map

package/.dist/cjs/src/lib/queryBody.cjs

@@ -1,30 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src_lib_urlQuery = require("./urlQuery.cjs");
-let _mionjs_core = require("@mionjs/core");
-//#region src/lib/queryBody.ts
-function decodeQueryBody(urlQuery, rawBody) {
-	if (rawBody) return void 0;
-	if (!urlQuery) return void 0;
-	const dataValue = require_src_lib_urlQuery.findMionQueryParam(urlQuery, "data");
-	if (!dataValue) return void 0;
-	try {
-		return {
-			rawBody: (0, _mionjs_core.fromBase64Url)(dataValue),
-			bodyType: _mionjs_core.SerializerModes.stringifyJson
-		};
-	} catch (err) {
-		throw invalidQueryBody(err);
-	}
-}
-function invalidQueryBody(originalError) {
-	return new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
-		type: "invalid-query-body",
-		publicMessage: "Invalid query body: the data parameter is not base64url encoded.",
-		originalError
-	});
-}
-//#endregion
-exports.decodeQueryBody = decodeQueryBody;
-
-//# sourceMappingURL=queryBody.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"queryBody.cjs","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,yBAAA,mBAAmB,UAAU,MAAM;CACrD,IAAI,CAAC,WAAW,OAAO,KAAA;CACvB,IAAI;EACF,OAAO;GAAC,UAAA,GAAA,aAAA,eAAuB,SAAS;GAAG,UAAU,aAAA,gBAAgB;EAAa;CACpF,SAAS,KAAK;EACZ,MAAM,iBAAiB,GAAG;CAC5B;AACF;AAEA,SAAS,iBAAiB,eAAyD;CACjF,OAAO,IAAI,aAAA,WAAW;EACpB,YAAY,aAAA,YAAY;EACxB,MAAM;EACN,eAAe;EACA;CACjB,CAAC;AACH"}

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

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

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

@@ -1,81 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _mionjs_core = require("@mionjs/core");
-//#region src/lib/reflection.ts
-/** The definition carries no injected type information: it was built or run without the mion plugin active. */
-var MissingRtFnsError = class extends Error {
-	constructor(routeId, cause) {
-		super(`Route/middleware "${routeId}" has no build-time type information.\nDeclare it through route()/middleware() and make sure mionVitePlugin (@mionjs/devtools) is active in the build.` + (cause ? `\nCause: ${cause}` : ""));
-		this.name = "MissingRtFnsError";
-	}
-};
-/** The injected type information IS present but the host forbids building functions from strings (workerd,
-*  Vercel's EdgeVM, a CSP without 'unsafe-eval'). A BUILD-CONFIG problem, not a missing-plugin one. */
-var RuntimeCodeGenBlockedError = class extends Error {
-	constructor(routeId, cause) {
-		super(`Route/middleware "${routeId}" carries build-time type information, but this runtime forbids compiling functions from strings.\nBuild with \`mionVitePlugin({runTypes: {emitMode: 'both'}})\`: the default 'code' ships each compiled fn as a source string that is turned into a function on first use, which edge runtimes (Cloudflare Workers / workerd, Vercel Edge) refuse. 'both' also emits the live factory, so nothing is compiled at runtime.` + (cause ? `\nCause: ${cause}` : ""));
-		this.name = "RuntimeCodeGenBlockedError";
-	}
-};
-var CODE_GEN_BLOCKED = /code generation from strings|unsafe-eval/i;
-/** True when an error from the mion runtime is a blocked `new Function`, not a missing payload. */
-function isCodeGenBlocked(message) {
-	return !!message && CODE_GEN_BLOCKED.test(message);
-}
-var rawMiddlewareReflectionCache = (0, _mionjs_core.getOrCreateGlobal)("mion.reflection.rawMiddlewareReflectionCache", () => /* @__PURE__ */ new Map());
-/** Creates a MethodReflect for raw middlewares: no type info, NoopJitFns. */
-function createRawMiddlewareReflection(isAsync, hasReturnData = false, paramsCount = 0) {
-	const cacheKey = `${isAsync}_${hasReturnData}_${paramsCount}`;
-	const cached = rawMiddlewareReflectionCache.get(cacheKey);
-	if (cached) return cached;
-	const reflection = {
-		paramsCount,
-		paramsJitFns: (0, _mionjs_core.getNoopJitFns)(),
-		returnJitFns: (0, _mionjs_core.getNoopJitFns)(),
-		paramsJitHash: _mionjs_core.EMPTY_HASH,
-		returnJitHash: _mionjs_core.EMPTY_HASH,
-		hasReturnData,
-		isAsync
-	};
-	rawMiddlewareReflectionCache.set(cacheKey, reflection);
-	return reflection;
-}
-/** All data derives from the mion marker payload the factory stashed on the definition (`def.rtFns`);
-*  registration fails loudly when that payload is missing (plugin not active). */
-function getHandlerReflection(def, routeId, routerOptions, handlerOptions = {}, isHeadersMiddleware = false) {
-	try {
-		return isHeadersMiddleware ? (0, _mionjs_core.getHeadersReflectionFromMarkers)(def.rtFns, def.handler, routeId) : (0, _mionjs_core.getReflectionFromMarkers)(def.rtFns, def.handler, routeId);
-	} catch (error) {
-		if (isCodeGenBlocked(error?.message)) throw new RuntimeCodeGenBlockedError(routeId, error.message);
-		throw new MissingRtFnsError(routeId, error?.message);
-	}
-}
-/** Raw middlewares parse the raw request / response themselves, so they carry no type info. */
-function getRawMethodReflection(handler, routeId, routerOptions) {
-	return createRawMiddlewareReflection((0, _mionjs_core.isAsyncHandler)(handler));
-}
-/** Checks each direction's compiled strategy against the resolved one: they differ only when the
-*  build saw a different literal than the runtime value. */
-function assertCompiledParser(methodId, parser, reflection) {
-	const sides = [[
-		"params",
-		reflection.paramsJitHash,
-		reflection.paramsJitFns
-	], [
-		"return",
-		reflection.returnJitHash,
-		reflection.returnJitFns
-	]];
-	for (const [direction, hash, fns] of sides) {
-		if (hash === _mionjs_core.EMPTY_HASH) continue;
-		const wanted = parser[direction];
-		if (fns.json.strategy !== wanted) throw new Error(`mion: ${direction} parser of "${methodId}" is '${wanted}' at runtime but the build compiled '${fns.json.strategy}'. Write the parser option inline on the route (or as an \`as const\` preset) and the router-wide default as a literal on createMionRouter, so the build sees the same value the runtime reads.`);
-	}
-}
-//#endregion
-exports.MissingRtFnsError = MissingRtFnsError;
-exports.RuntimeCodeGenBlockedError = RuntimeCodeGenBlockedError;
-exports.assertCompiledParser = assertCompiledParser;
-exports.getHandlerReflection = getHandlerReflection;
-exports.getRawMethodReflection = getRawMethodReflection;
-
-//# sourceMappingURL=reflection.cjs.map

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

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