@mionjs/router 0.8.10 → 0.13.0

package/.dist/esm/src/types/guards.js

@@ -1,66 +1,47 @@
-import { __ΩRouterEntry as ___RouterEntry, __ΩRoutes as ___Routes } from "./general.js";
-import { __ΩRemoteMethod as ___RemoteMethod } from "./remoteMethods.js";
 import { HandlerType } from "@mionjs/core";
+//#region src/types/guards.ts
 function isRouteDef(entry) {
-  return entry.type === HandlerType.route;
+	return entry.type === HandlerType.route;
 }
-isRouteDef.__type = [() => ___RouterEntry, "entry", "isRouteDef", 'Pn!2"!/#'];
-function isMiddleFnDef(entry) {
-  return entry.type === HandlerType.middleFn;
+function isMiddlewareDef(entry) {
+	return entry.type === HandlerType.middleware;
 }
-isMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isMiddleFnDef", 'Pn!2"!/#'];
-function isRawMiddleFnDef(entry) {
-  return entry.type === HandlerType.rawMiddleFn;
+function isRawMiddlewareDef(entry) {
+	return entry.type === HandlerType.rawMiddleware;
 }
-isRawMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isRawMiddleFnDef", 'Pn!2"!/#'];
-function isHeadersMiddleFnDef(entry) {
-  return entry.type === HandlerType.headersMiddleFn;
+function isHeadersMiddlewareDef(entry) {
+	return entry.type === HandlerType.headersMiddleware;
 }
-isHeadersMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isHeadersMiddleFnDef", 'Pn!2"!/#'];
-function isAnyMiddleFnDef(entry) {
-  return isMiddleFnDef(entry) || isRawMiddleFnDef(entry) || isHeadersMiddleFnDef(entry);
+function isAnyMiddlewareDef(entry) {
+	return isMiddlewareDef(entry) || isRawMiddlewareDef(entry) || isHeadersMiddlewareDef(entry);
 }
-isAnyMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isAnyMiddleFnDef", 'Pn!2"!/#'];
 function isRoute(entry) {
-  return entry.type === HandlerType.route;
+	return entry.type === HandlerType.route;
 }
-isRoute.__type = [() => ___RouterEntry, "entry", "isRoute", 'Pn!2"!/#'];
 function isRoutes(entry) {
-  return typeof entry === "object";
+	return typeof entry === "object";
 }
-isRoutes.__type = [() => ___RouterEntry, () => ___Routes, "entry", "isRoutes", 'PPn!n"J2#!/$'];
 function isExecutable(entry) {
-  return typeof entry?.id === "string" && (entry.routes === "undefined" || typeof entry.handler === "function");
+	return typeof entry?.id === "string" && typeof entry.handler === "function";
 }
-isExecutable.__type = [() => ___RemoteMethod, "pathPointer", "entry", "isExecutable", 'PPn!P&F4"MJ2#!/$'];
 function isRawExecutable(entry) {
-  return entry.type === HandlerType.rawMiddleFn;
+	return entry.type === HandlerType.rawMiddleware;
 }
-isRawExecutable.__type = [() => ___RemoteMethod, "entry", "isRawExecutable", 'Pn!2"!/#'];
-function isPublicExecutable(entry) {
-  return entry.hasReturnData || entry.type === HandlerType.route || !!entry.paramNames?.length || !!entry.headersParam?.headerNames?.length;
+/** What the metadata route exposes: whatever the client must encode or decode. NOT access control. */
+function isPublicExecutable(executable) {
+	if (executable.type === HandlerType.rawMiddleware) return false;
+	if (executable.type === HandlerType.route) return true;
+	const hasPublicParams = !!executable.paramsCount;
+	const hasHeaderParams = !!executable.headersParam?.headerNames?.length;
+	return hasPublicParams || hasHeaderParams || executable.hasReturnData;
 }
-isPublicExecutable.__type = [() => ___RemoteMethod, "entry", "isPublicExecutable", 'Pn!2"!/#'];
 function isHeaderExecutable(entry) {
-  return entry.type === HandlerType.headersMiddleFn;
+	return entry.type === HandlerType.headersMiddleware;
 }
-isHeaderExecutable.__type = [() => ___RemoteMethod, "entry", "isHeaderExecutable", 'Pn!2"!/#'];
 function isRouteExecutable(entry) {
-  return entry.type === HandlerType.route;
+	return entry.type === HandlerType.route;
 }
-isRouteExecutable.__type = [() => ___RemoteMethod, "entry", "isRouteExecutable", 'Pn!2"!/#'];
-export {
-  isAnyMiddleFnDef,
-  isExecutable,
-  isHeaderExecutable,
-  isHeadersMiddleFnDef,
-  isMiddleFnDef,
-  isPublicExecutable,
-  isRawExecutable,
-  isRawMiddleFnDef,
-  isRoute,
-  isRouteDef,
-  isRouteExecutable,
-  isRoutes
-};
-//# sourceMappingURL=guards.js.map
+//#endregion
+export { isAnyMiddlewareDef, isExecutable, isHeaderExecutable, isHeadersMiddlewareDef, isMiddlewareDef, isPublicExecutable, isRawExecutable, isRawMiddlewareDef, isRoute, isRouteDef, isRouteExecutable, isRoutes };
+
+//# sourceMappingURL=guards.js.map

package/.dist/esm/src/types/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","sources":["../../../../src/types/guards.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 {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from './definitions.ts';\nimport {Route, RouterEntry, Routes} from './general.ts';\nimport {RawMethod} from './remoteMethods.ts';\nimport {HeadersMethod} from './remoteMethods.ts';\nimport {RouteMethod} from './remoteMethods.ts';\nimport {RemoteMethod} from './remoteMethods.ts';\nimport {HandlerType} from '@mionjs/core';\n\n// #######  type guards #######\n\nexport function isRouteDef(entry: RouterEntry): entry is RouteDef {\n    return entry.type === HandlerType.route;\n}\n\nexport function isMiddleFnDef(entry: RouterEntry): entry is MiddleFnDef {\n    return entry.type === HandlerType.middleFn;\n}\n\nexport function isRawMiddleFnDef(entry: RouterEntry): entry is RawMiddleFnDef {\n    return entry.type === HandlerType.rawMiddleFn;\n}\n\nexport function isHeadersMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef {\n    return entry.type === HandlerType.headersMiddleFn;\n}\n\nexport function isAnyMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef | MiddleFnDef | RawMiddleFnDef {\n    return isMiddleFnDef(entry) || isRawMiddleFnDef(entry) || isHeadersMiddleFnDef(entry);\n}\n\nexport function isRoute(entry: RouterEntry): entry is Route {\n    return entry.type === HandlerType.route;\n}\n\nexport function isRoutes(entry: RouterEntry | Routes): entry is Route {\n    return typeof entry === 'object';\n}\n\nexport function isExecutable(entry: RemoteMethod | {pathPointer: string[]}): entry is RemoteMethod {\n    return (\n        typeof (entry as RemoteMethod)?.id === 'string' &&\n        ((entry as any).routes === 'undefined' || typeof (entry as RemoteMethod).handler === 'function')\n    );\n}\nexport function isRawExecutable(entry: RemoteMethod): entry is RawMethod {\n    return entry.type === HandlerType.rawMiddleFn;\n}\n\nexport function isPublicExecutable(entry: RemoteMethod): entry is RemoteMethod {\n    return (\n        entry.hasReturnData ||\n        entry.type === HandlerType.route ||\n        !!entry.paramNames?.length ||\n        !!(entry as HeadersMethod).headersParam?.headerNames?.length\n    );\n}\n\nexport function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod {\n    return entry.type === HandlerType.headersMiddleFn;\n}\n\nexport function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod {\n    return entry.type === HandlerType.route;\n}\n"],"names":[],"mappings":";;;AAiBM,SAAU,WAAW,OAAkB;AACzC,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,cAAc,OAAkB;AAC5C,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,iBAAiB,OAAkB;AAC/C,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,qBAAqB,OAAkB;AACnD,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,iBAAiB,OAAkB;AAC/C,SAAO,cAAc,KAAK,KAAK,iBAAiB,KAAK,KAAK,qBAAqB,KAAK;AACxF;;AAEM,SAAU,QAAQ,OAAkB;AACtC,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,SAAS,OAA2B;AAChD,SAAO,OAAO,UAAU;AAC5B;;AAEM,SAAU,aAAa,OAA6C;AACtE,SACI,OAAQ,OAAwB,OAAO,aACrC,MAAc,WAAW,eAAe,OAAQ,MAAuB,YAAY;AAE7F;;AACM,SAAU,gBAAgB,OAAmB;AAC/C,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,mBAAmB,OAAmB;AAClD,SACI,MAAM,iBACN,MAAM,SAAS,YAAY,SAC3B,CAAC,CAAC,MAAM,YAAY,UACpB,CAAC,CAAE,MAAwB,cAAc,aAAa;AAE9D;;AAEM,SAAU,mBAAmB,OAAmB;AAClD,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,kBAAkB,OAAmB;AACjD,SAAO,MAAM,SAAS,YAAY;AACtC;;"}
+{"version":3,"file":"guards.js","names":[],"sources":["../../../../src/types/guards.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 {HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef, RouteDef} from './definitions.ts';\nimport {Route, RouterEntry, Routes} from './general.ts';\nimport {RawMethod} from './remoteMethods.ts';\nimport {HeadersMethod} from './remoteMethods.ts';\nimport {RouteMethod} from './remoteMethods.ts';\nimport {RemoteMethod} from './remoteMethods.ts';\nimport {HandlerType} from '@mionjs/core';\n\n// #######  type guards #######\n\nexport function isRouteDef(entry: RouterEntry): entry is RouteDef {\n  return entry.type === HandlerType.route;\n}\n\nexport function isMiddlewareDef(entry: RouterEntry): entry is MiddlewareDef {\n  return entry.type === HandlerType.middleware;\n}\n\nexport function isRawMiddlewareDef(entry: RouterEntry): entry is RawMiddlewareDef {\n  return entry.type === HandlerType.rawMiddleware;\n}\n\nexport function isHeadersMiddlewareDef(entry: RouterEntry): entry is HeadersMiddlewareDef {\n  return entry.type === HandlerType.headersMiddleware;\n}\n\nexport function isAnyMiddlewareDef(entry: RouterEntry): entry is HeadersMiddlewareDef | MiddlewareDef | RawMiddlewareDef {\n  return isMiddlewareDef(entry) || isRawMiddlewareDef(entry) || isHeadersMiddlewareDef(entry);\n}\n\nexport function isRoute(entry: RouterEntry): entry is Route {\n  return entry.type === HandlerType.route;\n}\n\nexport function isRoutes(entry: RouterEntry | Routes): entry is Routes {\n  return typeof entry === 'object';\n}\n\nexport function isExecutable(entry: RemoteMethod | {pathPointer: string[]}): entry is RemoteMethod {\n  return typeof (entry as RemoteMethod)?.id === 'string' && typeof (entry as RemoteMethod).handler === 'function';\n}\nexport function isRawExecutable(entry: RemoteMethod): entry is RawMethod {\n  return entry.type === HandlerType.rawMiddleware;\n}\n\n/** What the metadata route exposes: whatever the client must encode or decode. NOT access control. */\nexport function isPublicExecutable(executable: RemoteMethod): boolean {\n  if (executable.type === HandlerType.rawMiddleware) return false;\n  if (executable.type === HandlerType.route) return true;\n  const hasPublicParams = !!executable.paramsCount;\n  const hasHeaderParams = !!(executable as HeadersMethod).headersParam?.headerNames?.length;\n  return hasPublicParams || hasHeaderParams || executable.hasReturnData;\n}\n\nexport function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod {\n  return entry.type === HandlerType.headersMiddleware;\n}\n\nexport function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod {\n  return entry.type === HandlerType.route;\n}\n"],"mappings":";;AAiBA,SAAgB,WAAW,OAAuC;CAChE,OAAO,MAAM,SAAS,YAAY;AACpC;AAEA,SAAgB,gBAAgB,OAA4C;CAC1E,OAAO,MAAM,SAAS,YAAY;AACpC;AAEA,SAAgB,mBAAmB,OAA+C;CAChF,OAAO,MAAM,SAAS,YAAY;AACpC;AAEA,SAAgB,uBAAuB,OAAmD;CACxF,OAAO,MAAM,SAAS,YAAY;AACpC;AAEA,SAAgB,mBAAmB,OAAsF;CACvH,OAAO,gBAAgB,KAAK,KAAK,mBAAmB,KAAK,KAAK,uBAAuB,KAAK;AAC5F;AAEA,SAAgB,QAAQ,OAAoC;CAC1D,OAAO,MAAM,SAAS,YAAY;AACpC;AAEA,SAAgB,SAAS,OAA8C;CACrE,OAAO,OAAO,UAAU;AAC1B;AAEA,SAAgB,aAAa,OAAsE;CACjG,OAAO,OAAQ,OAAwB,OAAO,YAAY,OAAQ,MAAuB,YAAY;AACvG;AACA,SAAgB,gBAAgB,OAAyC;CACvE,OAAO,MAAM,SAAS,YAAY;AACpC;;AAGA,SAAgB,mBAAmB,YAAmC;CACpE,IAAI,WAAW,SAAS,YAAY,eAAe,OAAO;CAC1D,IAAI,WAAW,SAAS,YAAY,OAAO,OAAO;CAClD,MAAM,kBAAkB,CAAC,CAAC,WAAW;CACrC,MAAM,kBAAkB,CAAC,CAAE,WAA6B,cAAc,aAAa;CACnF,OAAO,mBAAmB,mBAAmB,WAAW;AAC1D;AAEA,SAAgB,mBAAmB,OAA6C;CAC9E,OAAO,MAAM,SAAS,YAAY;AACpC;AAEA,SAAgB,kBAAkB,OAA2C;CAC3E,OAAO,MAAM,SAAS,YAAY;AACpC"}

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

@@ -4,10 +4,13 @@ import { RouterOptions } from './general.ts';
 import { MayReturnError } from './publicMethods.ts';
 export type Handler<Context extends CallContext = any, Params extends any[] = any[], Ret = any> = (context: Context, ...parameters: Params) => Ret | Promise<Ret>;
 export type HeaderHandler<Context extends CallContext = any, ExpectedHeaders extends HeadersSubset<any> = any, Params extends any[] = any[], Ret = any> = (context: Context, headers: ExpectedHeaders, ...parameters: Params) => Ret | Promise<Ret>;
-export type RawMiddleFnHandler<Context extends CallContext = any, RawReq = any, RawResp = any, Opts extends RouterOptions<RawReq> = RouterOptions<RawReq>> = (ctx: Context, request: RawReq, response: RawResp, opts: Opts) => MayReturnError;
+export type RawMiddlewareHandler<Context extends CallContext = any, RawReq = any, RawResp = any, Opts extends RouterOptions<RawReq> = RouterOptions<RawReq>> = (ctx: Context, request: RawReq, response: RawResp, opts: Opts) => MayReturnError;
 export type AnyHandler<Context extends CallContext = any, Params extends any[] = any, Ret = any> = Handler<Context, Params, Ret>;
-export declare type __ΩHandler = any[];
-export declare type __ΩHeaderHandler = any[];
-export declare type __ΩRawMiddleFnHandler = any[];
-export declare type __ΩAnyHandler = any[];
+export type HandlerParams<H extends AnyHandler> = Parameters<H> extends [any, ...infer P] ? P : [];
+export type HandlerReturn<H extends AnyHandler> = Awaited<ReturnType<H>>;
+export type HandlerIsAsync<H extends AnyHandler> = true extends IsPromiseArm<ReturnType<H>> ? true : false;
+type IsPromiseArm<T> = T extends PromiseLike<any> ? true : false;
+export type HeaderHandlerHeaders<H extends HeaderHandler> = Parameters<H> extends [any, infer HS, ...any[]] ? HS : never;
+export type HeaderHandlerParams<H extends HeaderHandler> = Parameters<H> extends [any, any, ...infer P] ? P : [];
+export {};
 //# sourceMappingURL=handlers.d.ts.map

package/.dist/esm/src/types/handlers.js

@@ -1,13 +0,0 @@
-import { __ΩRouterOptions as ___RouterOptions } from "./general.js";
-import { __ΩMayReturnError as ___MayReturnError } from "./publicMethods.js";
-const __ΩHandler = ["Context", "Params", "Ret", "context", "parameters", "", "Handler", '"c!"Fc""c#Pe"!2$e""@2%Pe##e##`J/&w\'y'];
-const __ΩHeaderHandler = ["Context", "ExpectedHeaders", "Params", "Ret", "context", "headers", "parameters", "", "HeaderHandler", '"c!"c""Fc#"c$Pe"!2%e""2&e"#@2\'Pe#$e#$`J/(w)y'];
-const __ΩRawMiddleFnHandler = ["Context", "RawReq", "RawResp", () => ___RouterOptions, "Opts", "ctx", "request", "response", "opts", () => ___MayReturnError, "", "RawMiddleFnHandler", `"c!"c""c#e!"o$"c%Pe"!2&e""2'e"#2(e"$2)n*/+w,y`];
-const __ΩAnyHandler = ["Context", "Params", "Ret", () => __ΩHandler, "AnyHandler", '"c!"c""c#e!!e!"e!#o$$w%y'];
-export {
-  __ΩAnyHandler,
-  __ΩHandler,
-  __ΩHeaderHandler,
-  __ΩRawMiddleFnHandler
-};
-//# sourceMappingURL=handlers.js.map

package/.dist/esm/src/types/mionRouter.d.ts

@@ -0,0 +1,44 @@
+import { CompTimeArgs, InjectBuildVersion, InjectRunTypeId } from '@mionjs/run-types';
+import { ParserLiteralGuard, HeaderMarkerSlots, MarkerSlots } from './parser.ts';
+import { CallContext, ContextDataFactory } from './context.ts';
+import { RouterOptions, Routes } from './general.ts';
+import { Handler, HandlerParams, HandlerReturn, HandlerIsAsync, HeaderHandler, HeaderHandlerHeaders, HeaderHandlerParams, RawMiddlewareHandler } from './handlers.ts';
+import { HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef, RouteDef } from './definitions.ts';
+import { PlainHeadersMiddlewareOptions, PlainMiddlewareOptions, PlainRouteOptions, RawMiddlewareOptions, MiddlewareOptions, HeadersMiddlewareOptions, RouteOptions } from './remoteMethods.ts';
+import { ApiBuildVersion, PublicApi } from './publicMethods.ts';
+export type RouterOptionsInput = Partial<RouterOptions>;
+export type RouterOptionsArg<O extends RouterOptionsInput> = O & ParserLiteralGuard<O>;
+export type ContextDataOf<O extends RouterOptionsInput> = O extends {
+    contextDataFactory: ContextDataFactory<infer ContextData>;
+} ? ContextData : any;
+export type RouterCallContext<O extends RouterOptionsInput> = CallContext<ContextDataOf<O>>;
+type RouteSlots<O, H extends Handler, RO> = MarkerSlots<HandlerParams<H>, HandlerReturn<H>, RO, O>;
+type HeadersRouteSlots<O, H extends HeaderHandler, RO> = MarkerSlots<HeaderHandlerParams<H>, HandlerReturn<H>, RO, O>;
+type HeaderSlots<H extends HeaderHandler> = HeaderMarkerSlots<HeaderHandlerHeaders<H>>;
+export interface RouteHelper<O extends RouterOptionsInput, M extends boolean | undefined = undefined> {
+    <H extends Handler<RouterCallContext<O>>, const RO extends RouteOptions = PlainRouteOptions>(handler: H, opts?: CompTimeArgs<RO>, paramsFns?: RouteSlots<O, H, RO>[0], returnFns?: RouteSlots<O, H, RO>[1], paramsId?: RouteSlots<O, H, RO>[2], returnId?: RouteSlots<O, H, RO>[3], isAsyncId?: InjectRunTypeId<HandlerIsAsync<H>>, syncId?: RouteSlots<O, H, RO>[4]): RouteDef<H, PinnedMutation<RO, M>, O>;
+}
+export type PinnedMutation<RO, M extends boolean | undefined> = M extends boolean ? RO & {
+    isMutation: M;
+} : RO;
+export interface MiddlewareHelper<O extends RouterOptionsInput> {
+    <H extends Handler<RouterCallContext<O>>, const RO extends MiddlewareOptions = PlainMiddlewareOptions>(handler: H, opts?: CompTimeArgs<RO>, paramsFns?: RouteSlots<O, H, RO>[0], returnFns?: RouteSlots<O, H, RO>[1], paramsId?: RouteSlots<O, H, RO>[2], returnId?: RouteSlots<O, H, RO>[3], isAsyncId?: InjectRunTypeId<HandlerIsAsync<H>>, syncId?: RouteSlots<O, H, RO>[4]): MiddlewareDef<H, RO, O>;
+}
+export interface HeadersMiddlewareHelper<O extends RouterOptionsInput> {
+    <H extends HeaderHandler<RouterCallContext<O>>, const RO extends HeadersMiddlewareOptions = PlainHeadersMiddlewareOptions>(handler: H, opts?: CompTimeArgs<RO>, headersFns?: HeaderSlots<H>[0], paramsFns?: HeadersRouteSlots<O, H, RO>[0], returnFns?: HeadersRouteSlots<O, H, RO>[1], headersId?: HeaderSlots<H>[1], paramsId?: HeadersRouteSlots<O, H, RO>[2], returnId?: HeadersRouteSlots<O, H, RO>[3], isAsyncId?: InjectRunTypeId<HandlerIsAsync<H>>, syncId?: HeadersRouteSlots<O, H, RO>[4]): HeadersMiddlewareDef<H, RO, O>;
+}
+export interface RawMiddlewareHelper<O extends RouterOptionsInput> {
+    <H extends RawMiddlewareHandler<RouterCallContext<O>>>(handler: H, opts?: RawMiddlewareOptions): RawMiddlewareDef<H>;
+}
+export interface MionRouter<O extends RouterOptionsInput = RouterOptionsInput> {
+    readonly options: Readonly<O>;
+    readonly route: RouteHelper<O>;
+    readonly query: RouteHelper<O, false>;
+    readonly mutation: RouteHelper<O, true>;
+    readonly middleware: MiddlewareHelper<O>;
+    readonly headersMiddleware: HeadersMiddlewareHelper<O>;
+    readonly rawMiddleware: RawMiddlewareHelper<O>;
+    initRoutes<R extends Routes, const Version extends string = string>(routes: R, buildVersion?: InjectBuildVersion<PublicApi<R>> & Version): PublicApi<R> & ApiBuildVersion<Version>;
+}
+export {};
+//# sourceMappingURL=mionRouter.d.ts.map

package/.dist/esm/src/types/parser.d.ts

@@ -0,0 +1,43 @@
+import { DefaultParser, ParseModeRow, ParseModes, ParserOption, ResolvedParser } from '@mionjs/core';
+import { InjectRunTypeId, InjectTypeFnArgs } from '@mionjs/run-types';
+type Direction = keyof ResolvedParser;
+type ParserOf<Options> = Options extends {
+    parser: infer Parser;
+} ? Parser : never;
+type DirectionStrategy<Parser, Dir extends Direction> = [Parser] extends [string] ? SingleLiteral<Parser> : [Parser] extends [Record<Dir, infer Strategy extends string>] ? SingleLiteral<Strategy> : never;
+type FallbackTo<Strategy, Else> = [Strategy] extends [never] ? Else : Strategy;
+type ResolveStrategy<RouteOpts, RouterOpts, Dir extends Direction> = FallbackTo<DirectionStrategy<ParserOf<RouteOpts>, Dir>, FallbackTo<DirectionStrategy<ParserOf<RouterOpts>, Dir>, DefaultParser[Dir]>>;
+type ModeFamily<Strategy, Family extends keyof ParseModeRow> = Strategy extends keyof ParseModes ? ParseModes[Strategy][Family] : never;
+export type ParamsStrategy<RouteOpts, RouterOpts> = ResolveStrategy<RouteOpts, RouterOpts, 'params'>;
+export type ReturnStrategy<RouteOpts, RouterOpts> = ResolveStrategy<RouteOpts, RouterOpts, 'return'>;
+type ParamsFn<RouteOpts, RouterOpts, Family extends keyof ParseModeRow> = ModeFamily<ParamsStrategy<RouteOpts, RouterOpts>, Family>;
+type ReturnFn<RouteOpts, RouterOpts, Family extends keyof ParseModeRow> = ModeFamily<ReturnStrategy<RouteOpts, RouterOpts>, Family>;
+export type ParserLiteralGuard<Options> = Options extends {
+    parser: infer Parser;
+} ? Parser extends ParserOption ? {
+    parser: LiteralParser<Parser>;
+} : never : unknown;
+type IsUnion<Candidate, All = Candidate> = Candidate extends unknown ? ([All] extends [Candidate] ? false : true) : never;
+type SingleLiteral<Strategy> = [Strategy] extends [string] ? string extends Strategy ? never : IsUnion<Strategy> extends true ? never : Strategy : never;
+type LiteralParser<Parser> = Parser extends string ? SingleLiteral<Parser> : {
+    [Key in keyof Parser]: SingleLiteral<Parser[Key]>;
+};
+export type WireFormat<Strategy> = Strategy extends 'compact' ? 'compact' : 'json';
+export type MarkerSlots<Params, Return, RouteOpts, RouterOpts> = [
+    paramsFns: InjectTypeFnArgs<Params, ParamsFn<RouteOpts, RouterOpts, 'validate'>, ParamsFn<RouteOpts, RouterOpts, 'validationErrors'>, 'formatTransform', ParamsFn<RouteOpts, RouterOpts, 'encode'>, ParamsFn<RouteOpts, RouterOpts, 'decode'>>,
+    returnFns: InjectTypeFnArgs<Return, ReturnFn<RouteOpts, RouterOpts, 'validate'>, ReturnFn<RouteOpts, RouterOpts, 'validationErrors'>, ReturnFn<RouteOpts, RouterOpts, 'encode'>, ReturnFn<RouteOpts, RouterOpts, 'decode'>>,
+    paramsId: InjectRunTypeId<Params>,
+    returnId: InjectRunTypeId<Return>,
+    syncId: InjectRunTypeId<[
+        Params,
+        Return,
+        WireFormat<ParamsStrategy<RouteOpts, RouterOpts>>,
+        WireFormat<ReturnStrategy<RouteOpts, RouterOpts>>
+    ]>
+];
+export type HeaderMarkerSlots<Headers> = [
+    headersFns: InjectTypeFnArgs<Headers, 'validate', 'validationErrors'>,
+    headersId: InjectRunTypeId<Headers>
+];
+export {};
+//# sourceMappingURL=parser.d.ts.map

package/.dist/esm/src/types/publicMethods.d.ts

@@ -1,46 +1,86 @@
-import { Prettify, RpcError, MethodMetadata, HandlerType } from '@mionjs/core';
+import { Prettify, RpcError, MethodMetadata, RemoteMethodOpts, HandlerType } from '@mionjs/core';
+import { ResolvedMiddlewareOptions, ResolvedRouteOptions } from './resolvedOptions.ts';
+import { ParamsStrategy, ReturnStrategy, WireFormat } from './parser.ts';
 import { CallContext } from './context.ts';
 import { Routes } from './general.ts';
-import { Handler } from './handlers.ts';
-import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
+import { Handler, HeaderHandler, HandlerIsAsync, HandlerParams, HandlerReturn, HeaderHandlerHeaders, HeaderHandlerParams } from './handlers.ts';
+import { HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef } from './definitions.ts';
 export type MayReturnError = void | RpcError<string> | Promise<RpcError<string> | void>;
-export type MiddleFnsCollection = {
-    [key: string]: MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;
+export type MiddlewaresCollection = {
+    [key: string]: MiddlewareDef | HeadersMiddlewareDef | RawMiddlewareDef;
 };
-export interface PrivateMiddleFnDef extends MiddleFnDef {
+export interface PrivateMiddlewareDef extends MiddlewareDef {
     handler: (ctx?: any) => void | never | undefined;
 }
-export type PrivateDef = PrivateMiddleFnDef | RawMiddleFnDef;
+export type PrivateDef = PrivateMiddlewareDef | RawMiddlewareDef;
+type IsPrivateDef<Definition> = Definition extends RawMiddlewareDef ? true : Definition extends PrivateMiddlewareDef ? (HandlerParams<Definition['handler']> extends [] ? true : false) : false;
 export type PublicApi<Type extends Routes> = Prettify<{
-    [Property in keyof Type as Type[Property] extends PrivateDef ? never : Property]: Type[Property] extends MiddleFnDef ? PublicMiddleFn<PublicHandler<Type[Property]['handler']>> : Type[Property] extends HeadersMiddleFnDef ? PublicHeadersFn<PublicHandler<Type[Property]['handler']>> : Type[Property] extends RouteDef ? PublicRoute<PublicHandler<Type[Property]['handler']>> : Type[Property] extends Routes ? PublicApi<Type[Property]> : never;
+    [Property in keyof Type as IsPrivateDef<Type[Property]> extends false ? Property : never]: Type[Property] extends {
+        type: typeof HandlerType.route;
+        handler: infer H extends Handler;
+        options?: infer RO;
+        routerOptions?: infer O;
+    } ? PublicRoute<PublicHandler<H>, ResolvedRouteOptions<RO, O>, HandlerMethodTypes<H, RO, O>> : Type[Property] extends {
+        type: typeof HandlerType.headersMiddleware;
+        handler: infer H extends HeaderHandler;
+        options?: infer RO;
+        routerOptions?: infer O;
+    } ? PublicHeadersMiddleware<PublicHandler<H>, ResolvedMiddlewareOptions<RO, O>, HeadersHandlerMethodTypes<H, RO, O>> : Type[Property] extends {
+        type: typeof HandlerType.middleware;
+        handler: infer H extends Handler;
+        options?: infer RO;
+        routerOptions?: infer O;
+    } ? PublicMiddleware<PublicHandler<H>, ResolvedMiddlewareOptions<RO, O>, HandlerMethodTypes<H, RO, O>> : Type[Property] extends Routes ? PublicApi<Type[Property]> : never;
 }>;
+declare const apiBuildVersion: unique symbol;
+export type ApiBuildVersion<Version extends string> = {
+    readonly [apiBuildVersion]?: Version;
+};
 export type RemoteApi = {
-    [key: string]: PublicRoute | PublicMiddleFn | PublicHeadersFn | RemoteApi;
+    [key: string]: PublicRoute<any, any, any> | PublicMiddleware<any, any, any> | PublicHeadersMiddleware<any, any, any> | RemoteApi;
 };
-export interface PublicRoute<H extends Handler = any> extends MethodMetadata {
+export interface MethodTypes {
+    params: unknown;
+    return: unknown;
+    headers: unknown;
+    isAsync: boolean;
+    sync: unknown;
+}
+export interface HandlerMethodTypes<H extends Handler, RO = unknown, O = unknown> {
+    params: HandlerParams<H>;
+    return: HandlerReturn<H>;
+    headers: never;
+    isAsync: HandlerIsAsync<H>;
+    sync: [HandlerParams<H>, HandlerReturn<H>, WireFormat<ParamsStrategy<RO, O>>, WireFormat<ReturnStrategy<RO, O>>];
+}
+export interface HeadersHandlerMethodTypes<H extends HeaderHandler, RO = unknown, O = unknown> {
+    params: HeaderHandlerParams<H>;
+    return: HandlerReturn<H>;
+    headers: HeaderHandlerHeaders<H>;
+    isAsync: HandlerIsAsync<H>;
+    sync: [HeaderHandlerParams<H>, HandlerReturn<H>, WireFormat<ParamsStrategy<RO, O>>, WireFormat<ReturnStrategy<RO, O>>];
+}
+export interface PublicRoute<H extends Handler = any, Opts = RemoteMethodOpts, Types = MethodTypes> extends MethodMetadata {
     type: typeof HandlerType.route;
-    middleFnIds: string[];
+    middlewareIds: string[];
     headerNames: undefined;
     handler: H;
+    options: Opts;
+    readonly types?: Types;
 }
-export interface PublicMiddleFn<H extends Handler = any> extends MethodMetadata {
-    type: typeof HandlerType.middleFn;
+export interface PublicMiddleware<H extends Handler = any, Opts = RemoteMethodOpts, Types = MethodTypes> extends MethodMetadata {
+    type: typeof HandlerType.middleware;
     handler: H;
+    options: Opts;
+    readonly types?: Types;
 }
-export interface PublicHeadersFn<H extends Handler = any> extends MethodMetadata {
-    type: typeof HandlerType.headersMiddleFn;
+export interface PublicHeadersMiddleware<H extends Handler = any, Opts = RemoteMethodOpts, Types = MethodTypes> extends MethodMetadata {
+    type: typeof HandlerType.headersMiddleware;
     headerNames: string[];
     handler: H;
+    options: Opts;
+    readonly types?: Types;
 }
 export type PublicHandler<H extends Handler> = H extends (ctx: CallContext, ...rest: infer Req) => infer Resp ? (...rest: Req) => Promise<Awaited<Resp>> : never;
-export declare type __ΩMayReturnError = any[];
-export declare type __ΩMiddleFnsCollection = any[];
-export declare type __ΩPrivateMiddleFnDef = any[];
-export declare type __ΩPrivateDef = any[];
-export declare type __ΩPublicApi = any[];
-export declare type __ΩRemoteApi = any[];
-export declare type __ΩPublicRoute = any[];
-export declare type __ΩPublicMiddleFn = any[];
-export declare type __ΩPublicHeadersFn = any[];
-export declare type __ΩPublicHandler = any[];
+export {};
 //# sourceMappingURL=publicMethods.d.ts.map

package/.dist/esm/src/types/publicMethods.js

@@ -1,24 +0,0 @@
-const __ΩAwaited = ["T", "onfulfilled", "args", "then", "value", "", 0, "Awaited", `lŒe$!Re"!o'"R!RPde#!Ph"!2%h&"@2#"/&qk'.QRPde#!p0Re$!RPdde#!P%PPh$!2"h$"@2#"1$MKqkJRQRPde%!pVRPe#!P,-Jqk#vQRb!Pde"!p~w(y`];
-const __ΩMayReturnError = ["RpcError", "MayReturnError", 'P$"w!P"w!$J`Jw"y'];
-const __ΩMiddleFnsCollection = ["MiddleFnDef", "HeadersMiddleFnDef", "RawMiddleFnDef", "MiddleFnsCollection", 'P&P"w!"w""w#JLMw$y'];
-const __ΩPrivateMiddleFnDef = ["MiddleFnDef", "ctx", "", "handler", "PrivateMiddleFnDef", 'P"w!P"2"8P$!-J/#4$Mw%y'];
-const __ΩPrivateDef = [() => __ΩPrivateMiddleFnDef, "RawMiddleFnDef", "PrivateDef", 'Pn!"w"Jw#y'];
-const __ΩPublicApi = ["Type", "Prettify", "PublicApi", 'b!"w"w#y'];
-const __ΩRemoteApi = [() => __ΩPublicRoute, () => __ΩPublicMiddleFn, () => __ΩPublicHeadersFn, 0, "RemoteApi", 'P&Pn!n"n#n$JLMw%y'];
-const __ΩPublicRoute = ["H", "MethodMetadata", () => HandlerType.route, "type", "middleFnIds", "headerNames", "handler", "PublicRoute", `"c!P"w"i#4$&F4%-4&e"!4'Mw(y`];
-const __ΩPublicMiddleFn = ["H", "MethodMetadata", () => HandlerType.middleFn, "type", "handler", "PublicMiddleFn", '"c!P"w"i#4$e"!4%Mw&y'];
-const __ΩPublicHeadersFn = ["H", "MethodMetadata", () => HandlerType.headersMiddleFn, "type", "headerNames", "handler", "PublicHeadersFn", `"c!P"w"i#4$&F4%e"!4&Mw'y`];
-const __ΩPublicHandler = ["H", "CallContext", "ctx", "rest", "", () => __ΩAwaited, "PublicHandler", 'lSPe#!@2$e#"o&"`/%R!RPdde#!P"w"2#h"!@2$h""/%qk#4QRb!Pde"!p6w\'y'];
-export {
-  __ΩMayReturnError,
-  __ΩMiddleFnsCollection,
-  __ΩPrivateDef,
-  __ΩPrivateMiddleFnDef,
-  __ΩPublicApi,
-  __ΩPublicHandler,
-  __ΩPublicHeadersFn,
-  __ΩPublicMiddleFn,
-  __ΩPublicRoute,
-  __ΩRemoteApi
-};
-//# sourceMappingURL=publicMethods.js.map

package/.dist/esm/src/types/remoteMethods.d.ts

@@ -1,45 +1,65 @@
-import { HeadersMethodWithJitFns, MethodWithJitFns, RemoteMethodOpts, RouteOnlyOptions, SerializerCode, HandlerType } from '@mionjs/core';
-import { AnyHandler, Handler, HeaderHandler, RawMiddleFnHandler } from './handlers.ts';
+import { ParserOption, HeadersMethodWithJitFns, MethodWithJitFns, RemoteMethodOpts, RouteOnlyOptions, HandlerType } from '@mionjs/core';
+import { AnyHandler, Handler, HeaderHandler, RawMiddlewareHandler } from './handlers.ts';
 export interface RemoteMethod<H extends AnyHandler = AnyHandler> extends MethodWithJitFns {
     options: RemoteMethodOpts;
     handler: H;
-    methodCaller?: (...args: any[]) => any;
+    methodCaller: (...args: any[]) => any;
+    alwaysRun: boolean;
+    quotedId: string;
+    asyncChecked?: boolean;
 }
 export interface RouteMethod<H extends Handler = any> extends RemoteMethod<H> {
     type: typeof HandlerType.route;
     options: RouteOnlyOptions;
 }
-export interface MiddleFnMethod<H extends Handler = any> extends RemoteMethod<H> {
-    type: typeof HandlerType.middleFn;
+export interface MiddlewareMethod<H extends Handler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.middleware;
 }
 export interface HeadersMethod<H extends HeaderHandler = any> extends RemoteMethod<H> {
-    type: typeof HandlerType.headersMiddleFn;
+    type: typeof HandlerType.headersMiddleware;
     headersParam: HeadersMethodWithJitFns;
 }
-export interface RawMethod<H extends RawMiddleFnHandler = any> extends RemoteMethod<H> {
-    type: typeof HandlerType.rawMiddleFn;
-    options: RemoteMethodOpts & {
-        validateParams: false;
-        validateReturn?: false;
-    };
-}
-export type RouteOptions = Partial<Pick<RouteMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'serializer' | 'isMutation' | 'strictTypes'>>;
-export type MiddleFnOptions = Partial<Pick<MiddleFnMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError' | 'strictTypes'>>;
-export type HeadersMiddleFnOptions = Partial<Pick<HeadersMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError' | 'strictTypes'>>;
-export type RawMiddleFnOptions = Partial<Pick<RawMethod['options'], 'description' | 'runOnError'>>;
+export interface RawMethod<H extends RawMiddlewareHandler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.rawMiddleware;
+}
+interface RouteOptionsBase {
+    description?: string;
+    isMutation?: boolean | undefined;
+    sanitizeParams?: boolean;
+    maxBodySize?: number;
+}
+interface MiddlewareOptionsBase {
+    description?: string;
+    maxBodySize?: number;
+    alwaysRun?: boolean;
+    sanitizeParams?: boolean;
+}
+export interface PlainRouteOptions extends RouteOptionsBase {
+    parser?: never;
+}
+export interface RouteOptionsWithParser extends RouteOptionsBase {
+    parser: ParserOption;
+}
+export type RouteOptions = PlainRouteOptions | RouteOptionsWithParser;
+export interface PlainMiddlewareOptions extends MiddlewareOptionsBase {
+    parser?: never;
+}
+export interface MiddlewareOptionsWithParser extends MiddlewareOptionsBase {
+    parser: ParserOption;
+}
+export type MiddlewareOptions = PlainMiddlewareOptions | MiddlewareOptionsWithParser;
+export type PlainHeadersMiddlewareOptions = PlainMiddlewareOptions;
+export type HeadersMiddlewareOptions = MiddlewareOptions;
+export type RawMiddlewareOptions = Partial<Pick<RawMethod['options'], 'description' | 'alwaysRun'>>;
 export interface MethodsExecutionChain {
     routeIndex: number;
     methods: RemoteMethod[];
-    serializer: SerializerCode;
-}
-export declare type __ΩRemoteMethod = any[];
-export declare type __ΩRouteMethod = any[];
-export declare type __ΩMiddleFnMethod = any[];
-export declare type __ΩHeadersMethod = any[];
-export declare type __ΩRawMethod = any[];
-export declare type __ΩRouteOptions = any[];
-export declare type __ΩMiddleFnOptions = any[];
-export declare type __ΩHeadersMiddleFnOptions = any[];
-export declare type __ΩRawMiddleFnOptions = any[];
-export declare type __ΩMethodsExecutionChain = any[];
+    path?: string;
+    batchId?: string;
+    batchRouteIds?: string[];
+    declaredBodySize?: number;
+    maxBodySize: number;
+    readsBody: boolean;
+}
+export {};
 //# sourceMappingURL=remoteMethods.d.ts.map

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

@@ -1,25 +0,0 @@
-const __ΩPartial = ["T", "Partial", 'l+e#!e"!fRb!Pde"!gN#"w"y'];
-const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
-const __ΩRemoteMethod = ["AnyHandler", "H", "MethodWithJitFns", "RemoteMethodOpts", "options", "handler", "args", "", "methodCaller", "RemoteMethod", `"w!c"P"w#"w$4%e"!4&P"@2'"/(4)8Mw*y`];
-const __ΩRouteMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.route, "type", "RouteOnlyOptions", "options", "RouteMethod", `"c!Pe"!o""i#4$"w%4&Mw'y`];
-const __ΩMiddleFnMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.middleFn, "type", "MiddleFnMethod", '"c!Pe"!o""i#4$Mw%y'];
-const __ΩHeadersMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.headersMiddleFn, "type", "HeadersMethodWithJitFns", "headersParam", "HeadersMethod", `"c!Pe"!o""i#4$"w%4&Mw'y`];
-const __ΩRawMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.rawMiddleFn, "type", "RemoteMethodOpts", false, "validateParams", false, "validateReturn", "options", "RawMethod", `"c!Pe"!o""i#4$P"w%P.&4'.(4)8MK4*Mw+y`];
-const __ΩRouteOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩRouteMethod, "options", "description", "validateParams", "validateReturn", "serializer", "isMutation", "strictTypes", "RouteOptions", `n#.$fP.%.&.'.(.).*Jo"#o!"w+y`];
-const __ΩMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩMiddleFnMethod, "options", "description", "validateParams", "validateReturn", "runOnError", "strictTypes", "MiddleFnOptions", `n#.$fP.%.&.'.(.)Jo"#o!"w*y`];
-const __ΩHeadersMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩHeadersMethod, "options", "description", "validateParams", "validateReturn", "runOnError", "strictTypes", "HeadersMiddleFnOptions", `n#.$fP.%.&.'.(.)Jo"#o!"w*y`];
-const __ΩRawMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩRawMethod, "options", "description", "runOnError", "RawMiddleFnOptions", `n#.$fP.%.&Jo"#o!"w'y`];
-const __ΩMethodsExecutionChain = ["routeIndex", () => __ΩRemoteMethod, "methods", "SerializerCode", "serializer", "MethodsExecutionChain", `P'4!n"F4#"w$4%Mw&y`];
-export {
-  __ΩHeadersMethod,
-  __ΩHeadersMiddleFnOptions,
-  __ΩMethodsExecutionChain,
-  __ΩMiddleFnMethod,
-  __ΩMiddleFnOptions,
-  __ΩRawMethod,
-  __ΩRawMiddleFnOptions,
-  __ΩRemoteMethod,
-  __ΩRouteMethod,
-  __ΩRouteOptions
-};
-//# sourceMappingURL=remoteMethods.js.map

package/.dist/esm/src/types/resolvedOptions.d.ts

@@ -0,0 +1,28 @@
+import { ParamsStrategy, ReturnStrategy } from './parser.ts';
+type Named<Opts, K extends PropertyKey> = Opts extends {
+    [P in K]: infer V;
+} ? V : undefined;
+type PickRouteOrRouter<RouteValue, RouterValue> = [RouteValue] extends [undefined] ? RouterValue : RouteValue;
+export type ResolvedRouteOptions<RO, O> = {
+    alwaysRun: false;
+    description: Named<RO, 'description'>;
+    parser: {
+        params: ParamsStrategy<RO, O>;
+        return: ReturnStrategy<RO, O>;
+    };
+    isMutation: Named<RO, 'isMutation'>;
+    sanitizeParams: PickRouteOrRouter<Named<RO, 'sanitizeParams'>, Named<O, 'sanitizeParams'>>;
+    maxBodySize: Named<RO, 'maxBodySize'>;
+};
+export type ResolvedMiddlewareOptions<RO, O> = {
+    alwaysRun: [Named<RO, 'alwaysRun'>] extends [true] ? true : false;
+    description: Named<RO, 'description'>;
+    parser: {
+        params: ParamsStrategy<RO, O>;
+        return: ReturnStrategy<RO, O>;
+    };
+    sanitizeParams: PickRouteOrRouter<Named<RO, 'sanitizeParams'>, Named<O, 'sanitizeParams'>>;
+    maxBodySize: Named<RO, 'maxBodySize'>;
+};
+export {};
+//# sourceMappingURL=resolvedOptions.d.ts.map

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Mion
+Copyright (c) 2026 Ma Jerez
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,12 +1,12 @@
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90-dark.png">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png">
-    <img alt='mion, Typescript Full Stack APIs' src='https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png'>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/main/assets/public/bannerx90-dark.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/main/assets/public/bannerx90.png">
+    <img alt='mion, Typescript Full Stack APIs' src='https://raw.githubusercontent.com/MionKit/mion/main/assets/public/bannerx90.png'>
   </picture>
 </p>
 <p align="center">
-  <strong>RPC Like router with automatic Validation and Serialization.
+  <strong>RPC Like router with automatic Validation and JSON Round Trip.
   </strong>
 </p>
 <p align=center>
@@ -17,7 +17,7 @@
 
 # `@mionjs/router`
 
-🚀 Lightweight and fast HTTP router with automatic validation and serialization out of the box.
+🚀 Lightweight and fast HTTP router with automatic validation and JSON round trip out of the box.
 
 Thanks to it's **Remote Method Call** routing style is quite performant as there is no need to parse URLs or match regular expressions when finding a route. Just a direct mapping from url to the route handler.
 
@@ -25,7 +25,7 @@ mion's is lightweight and fast. Unlike traditional routers. The Http method is n
 
 ## Check Out The [Website And Documentation](http://mion.io) 📚
 
-[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/master/assets/public/mion-website-banner.png)](http://mion.io)
+[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/main/assets/public/mion-website-banner.png)](http://mion.io)
 
 ---