@mionjs/router 0.8.0-alpha.0

package/.dist/cjs/src/lib/aotEmitter.cjs

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const src_lib_methodsCache = require("./methodsCache.cjs");
+const runTypes = require("@mionjs/run-types");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const __ΩAOTCacheMessage = ["mion-aot-caches", "type", "jitFnsCode", "pureFnsCode", "routerCacheCode", "AOTCacheMessage", 'P.!4"&4#&4$&4%Mw&y'];
+const __ΩSerializedCaches = ["jitFnsCode", "pureFnsCode", "routerCacheCode", "SerializedCaches", 'P&4!&4"&4#Mw$y'];
+const EXCLUDED_JIT_FN_IDS = [core.JIT_FUNCTION_IDS.toJSCode];
+const EXCLUDED_PURE_FN_NAMES = ["sanitizeCompiledFn"];
+async function getSerializedCaches() {
+  const { jitFnsCache, pureFnsCache } = core.getJitFnCaches();
+  const routerCache = src_lib_methodsCache.getPersistedMethods();
+  return serializeCachesToCode(jitFnsCache, pureFnsCache, routerCache);
+}
+getSerializedCaches.__type = [() => __ΩSerializedCaches, "getSerializedCaches", 'Pn!`/"'];
+async function emitAOTCaches() {
+  if (!core.isMionAOTEmitMode())
+    return;
+  if (core.getENV("MION_COMPILE") === "viteSSR")
+    return;
+  if (typeof process.send !== "function")
+    return;
+  const { jitFnsCache, pureFnsCache } = core.getJitFnCaches();
+  const routerCache = src_lib_methodsCache.getPersistedMethods();
+  const serialized = await serializeCachesToCode(jitFnsCache, pureFnsCache, routerCache);
+  const message = {
+    type: "mion-aot-caches",
+    ...serialized
+  };
+  process.send(message);
+}
+emitAOTCaches.__type = ["emitAOTCaches", "P$`/!"];
+async function serializeCachesToCode(jitFnsCache, pureFnsCache, routerCache) {
+  const jitToJSCode = (runTypes.createToJavascriptFn.Ω = [[() => core.__ΩSrcCodeJITCompiledFnsCache, "n!"]], runTypes.createToJavascriptFn());
+  const pureToJSCode = (runTypes.createToJavascriptFn.Ω = [[() => core.__ΩSrcCodePureFunctionsCache, "n!"]], runTypes.createToJavascriptFn());
+  const routerToJSCode = (runTypes.createToJavascriptFn.Ω = [[() => core.__ΩMethodsCache, "n!"]], runTypes.createToJavascriptFn());
+  const finalJitFns = filterExcludedJitFns(jitFnsCache, EXCLUDED_JIT_FN_IDS);
+  const finalPureFns = filterExcludedPureFns(pureFnsCache, EXCLUDED_PURE_FN_NAMES);
+  return {
+    jitFnsCode: jitToJSCode(finalJitFns),
+    pureFnsCode: pureToJSCode(finalPureFns),
+    routerCacheCode: routerToJSCode(routerCache)
+  };
+}
+serializeCachesToCode.__type = [() => core.__ΩJitFunctionsCache, "jitFnsCache", () => core.__ΩPureFunctionsCache, "pureFnsCache", () => core.__ΩMethodsCache, "routerCache", () => __ΩSerializedCaches, "serializeCachesToCode", "Pn!2\"n#2$n%2&n'`/("];
+function filterExcludedJitFns(jitFnsCache, excludedFnIds) {
+  if (!excludedFnIds.length)
+    return jitFnsCache;
+  return Object.fromEntries(Object.entries(jitFnsCache).filter(__assignType(([, value]) => !excludedFnIds.includes(value.fnID), ["param0", "", 'P"2!"/"'])));
+}
+filterExcludedJitFns.__type = [() => core.__ΩJitFunctionsCache, "jitFnsCache", "excludedFnIds", () => core.__ΩJitFunctionsCache, "filterExcludedJitFns", 'Pn!2"&F2#n$/%'];
+function filterExcludedPureFns(pureFnsCache, excludedFnNames) {
+  if (!excludedFnNames.length)
+    return pureFnsCache;
+  return Object.fromEntries(Object.entries(pureFnsCache).map(__assignType(([namespace, nsCache]) => [
+    namespace,
+    Object.fromEntries(Object.entries(nsCache).filter(__assignType(([, value]) => !excludedFnNames.includes(value.fnName), ["param0", "", 'P"2!"/"'])))
+  ], ["param0", "", 'P"2!"/"'])));
+}
+filterExcludedPureFns.__type = [() => core.__ΩPureFunctionsCache, "pureFnsCache", "excludedFnNames", () => core.__ΩPureFunctionsCache, "filterExcludedPureFns", 'Pn!2"&F2#n$/%'];
+exports.__ΩAOTCacheMessage = __ΩAOTCacheMessage;
+exports.__ΩSerializedCaches = __ΩSerializedCaches;
+exports.emitAOTCaches = emitAOTCaches;
+exports.getSerializedCaches = getSerializedCaches;
+exports.serializeCachesToCode = serializeCachesToCode;
+//# sourceMappingURL=aotEmitter.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aotEmitter.cjs","sources":["../../../../src/lib/aotEmitter.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 {\n    getJitFnCaches,\n    getENV,\n    isMionAOTEmitMode,\n    JitFunctionsCache,\n    PureFunctionsCache,\n    MethodsCache,\n    SrcCodeJITCompiledFnsCache,\n    SrcCodePureFunctionsCache,\n    JIT_FUNCTION_IDS,\n} from '@mionjs/core';\nimport {getPersistedMethods} from './methodsCache.ts';\nimport {createToJavascriptFn} from '@mionjs/run-types';\n\n/** IPC message type for AOT cache emission */\nexport interface AOTCacheMessage {\n    type: 'mion-aot-caches';\n    jitFnsCode: string;\n    pureFnsCode: string;\n    routerCacheCode: string;\n}\n\n/** Serialized cache data before converting to JS code */\nexport interface SerializedCaches {\n    jitFnsCode: string;\n    pureFnsCode: string;\n    routerCacheCode: string;\n}\n\n/** JIT function IDs to exclude from AOT caches (toJSCode is only needed at compile time) */\nconst EXCLUDED_JIT_FN_IDS = [JIT_FUNCTION_IDS.toJSCode];\n\n/** Pure function names to exclude from AOT caches */\nconst EXCLUDED_PURE_FN_NAMES = ['sanitizeCompiledFn'];\n\n/** Returns serialized caches for in-process AOT generation (no IPC needed). Call after initMionRouter(). */\nexport async function getSerializedCaches(): Promise<SerializedCaches> {\n    const {jitFnsCache, pureFnsCache} = getJitFnCaches();\n    const routerCache = getPersistedMethods();\n    return serializeCachesToCode(jitFnsCache, pureFnsCache, routerCache);\n}\n\n/**\n * Emits AOT caches to the parent process via IPC when running in MION_COMPILE mode.\n * This function is called automatically at the end of initMionRouter() and can also\n * be called manually for multi-step route registration patterns.\n */\nexport async function emitAOTCaches(): Promise<void> {\n    // Only emit in AOT generation mode (compile, SSR, or serve)\n    if (!isMionAOTEmitMode()) return;\n    // viteSSR mode: caches remain in global state, read directly via getSerializedCaches()\n    if (getENV('MION_COMPILE') === 'viteSSR') return;\n\n    // IPC mode: send to parent process\n    if (typeof process.send !== 'function') return;\n\n    // Get the caches\n    const {jitFnsCache, pureFnsCache} = getJitFnCaches();\n    const routerCache = getPersistedMethods();\n\n    // Serialize caches to JS code (filtering happens inside, after createToJavascriptFn)\n    const serialized = await serializeCachesToCode(jitFnsCache, pureFnsCache, routerCache);\n\n    // Send to parent process\n    const message: AOTCacheMessage = {\n        type: 'mion-aot-caches',\n        ...serialized,\n    };\n\n    process.send(message);\n}\n\n/**\n * Serializes the caches to JavaScript code strings using run-types toJSCode.\n * Filtering is done AFTER createToJavascriptFn because it adds compile-time-only JIT functions\n * to the global caches that should be excluded from the serialized output.\n */\nexport async function serializeCachesToCode(\n    jitFnsCache: JitFunctionsCache,\n    pureFnsCache: PureFunctionsCache,\n    routerCache: MethodsCache\n): Promise<SerializedCaches> {\n    const jitToJSCode = createToJavascriptFn<SrcCodeJITCompiledFnsCache>();\n    const pureToJSCode = createToJavascriptFn<SrcCodePureFunctionsCache>();\n    const routerToJSCode = createToJavascriptFn<MethodsCache>();\n    // Filter AFTER createToJavascriptFn to exclude compile-time-only items (including those just added)\n    const finalJitFns = filterExcludedJitFns(jitFnsCache, EXCLUDED_JIT_FN_IDS);\n    const finalPureFns = filterExcludedPureFns(pureFnsCache, EXCLUDED_PURE_FN_NAMES);\n    return {\n        jitFnsCode: jitToJSCode(finalJitFns as unknown as SrcCodeJITCompiledFnsCache),\n        pureFnsCode: pureToJSCode(finalPureFns as unknown as SrcCodePureFunctionsCache),\n        routerCacheCode: routerToJSCode(routerCache),\n    };\n}\n\n/**\n * Filters out excluded JIT functions by their function ID.\n * toJSCode is excluded because it's only needed at compile time.\n */\nfunction filterExcludedJitFns(jitFnsCache: JitFunctionsCache, excludedFnIds: string[]): JitFunctionsCache {\n    if (!excludedFnIds.length) return jitFnsCache;\n    return Object.fromEntries(\n        Object.entries(jitFnsCache).filter(([, value]) => !excludedFnIds.includes(value.fnID as string))\n    ) as JitFunctionsCache;\n}\n\n/**\n * Filters out excluded pure functions by their function name.\n * sanitizeCompiledFn is excluded because it's only needed at compile time.\n */\nfunction filterExcludedPureFns(pureFnsCache: PureFunctionsCache, excludedFnNames: string[]): PureFunctionsCache {\n    if (!excludedFnNames.length) return pureFnsCache;\n    return Object.fromEntries(\n        Object.entries(pureFnsCache).map(([namespace, nsCache]) => [\n            namespace,\n            Object.fromEntries(Object.entries(nsCache).filter(([, value]) => !excludedFnNames.includes(value.fnName))),\n        ])\n    ) as PureFunctionsCache;\n}\n"],"names":["JIT_FUNCTION_IDS","getJitFnCaches","getPersistedMethods","isMionAOTEmitMode","getENV","createToJavascriptFn"],"mappings":";;;;;;;;;;;AAqCA,MAAM,sBAAsB,CAACA,KAAAA,iBAAiB,QAAQ;AAGtD,MAAM,yBAAyB,CAAC,oBAAoB;AAGpD,eAAsB,sBAAmB;AACrC,QAAM,EAAC,aAAa,aAAA,IAAgBC,oBAAA;AACpC,QAAM,cAAcC,qBAAAA,oBAAA;AACpB,SAAO,sBAAsB,aAAa,cAAc,WAAW;AACvE;;AAOA,eAAsB,gBAAa;AAE/B,MAAI,CAACC,KAAAA,kBAAA;AAAqB;AAE1B,MAAIC,KAAAA,OAAO,cAAc,MAAM;AAAW;AAG1C,MAAI,OAAO,QAAQ,SAAS;AAAY;AAGxC,QAAM,EAAC,aAAa,aAAA,IAAgBH,oBAAA;AACpC,QAAM,cAAcC,qBAAAA,oBAAA;AAGpB,QAAM,aAAa,MAAM,sBAAsB,aAAa,cAAc,WAAW;AAGrF,QAAM,UAA2B;AAAA,IAC7B,MAAM;AAAA,IACN,GAAG;AAAA,EAAA;AAGP,UAAQ,KAAK,OAAO;AACxB;;AAOA,eAAsB,sBAClB,aACA,cACA,aAAyB;AAEzB,QAAM,eAAcG,sFAAAA,SAAAA;AACpB,QAAM,gBAAeA,qFAAAA,SAAAA;AACrB,QAAM,kBAAiBA,wEAAAA,SAAAA;AAEvB,QAAM,cAAc,qBAAqB,aAAa,mBAAmB;AACzE,QAAM,eAAe,sBAAsB,cAAc,sBAAsB;AAC/E,SAAO;AAAA,IACH,YAAY,YAAY,WAAoD;AAAA,IAC5E,aAAa,aAAa,YAAoD;AAAA,IAC9E,iBAAiB,eAAe,WAAW;AAAA,EAAA;AAEnD;;AAMA,SAAS,qBAAqB,aAAgC,eAAuB;AACjF,MAAI,CAAC,cAAc;AAAQ,WAAO;AAClC,SAAO,OAAO,YACV,OAAO,QAAQ,WAAW,EAAE,OAAM,aAAC,CAAC,GAAG,KAAK,MAAM,CAAC,cAAc,SAAS,MAAM,IAAc,GAAC,CAAA,UAAA,IAAA,SAAA,CAAA,CAAA,CAAC;AAExG;;AAMA,SAAS,sBAAsB,cAAkC,iBAAyB;AACtF,MAAI,CAAC,gBAAgB;AAAQ,WAAO;AACpC,SAAO,OAAO,YACV,OAAO,QAAQ,YAAY,EAAE,IAAG,aAAC,CAAC,CAAC,WAAW,OAAO,MAAM;AAAA,IACvD;AAAA,IACA,OAAO,YAAY,OAAO,QAAQ,OAAO,EAAE,OAAM,aAAC,CAAC,GAAG,KAAK,MAAM,CAAC,gBAAgB,SAAS,MAAM,MAAM,8BAAE;AAAA,EAAA,GAC5G,CAAA,UAAA,IAAA,SAAA,CAAA,CAAA,CAAC;AAEV;;;;;;;"}

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

@@ -0,0 +1,17 @@
+import { JitFunctionsCache, PureFunctionsCache, MethodsCache } from '@mionjs/core';
+export interface AOTCacheMessage {
+    type: 'mion-aot-caches';
+    jitFnsCode: string;
+    pureFnsCode: string;
+    routerCacheCode: string;
+}
+export interface SerializedCaches {
+    jitFnsCode: string;
+    pureFnsCode: string;
+    routerCacheCode: string;
+}
+export declare function getSerializedCaches(): Promise<SerializedCaches>;
+export declare function emitAOTCaches(): Promise<void>;
+export declare function serializeCachesToCode(jitFnsCache: JitFunctionsCache, pureFnsCache: PureFunctionsCache, routerCache: MethodsCache): Promise<SerializedCaches>;
+export declare type __ΩAOTCacheMessage = any[];
+export declare type __ΩSerializedCaches = any[];

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+function getRouterFatalErrorResponse(returnErr, respHeaders) {
+  const body = {
+    "@thrownErrors": { [core.MION_ROUTES.platformError]: returnErr }
+  };
+  respHeaders.set("content-type", "application/json; charset=utf-8");
+  const response = {
+    statusCode: returnErr.statusCode || core.StatusCodes.SERVER_ERROR,
+    // Global errors are always unexpected
+    hasErrors: true,
+    headers: respHeaders,
+    body,
+    rawBody: JSON.stringify(body),
+    serializer: core.SerializerModes.json
+    // global errors are always json
+  };
+  return response;
+}
+function onExecutableError(context, executable, err) {
+  const response = context.response;
+  const path = executable.id;
+  const rpcError = err instanceof core.RpcError ? err : new core.RpcError({
+    statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+    publicMessage: `Unknown error in handler "${path}" of route ExecutionChain.`,
+    originalError: err,
+    type: "unknown-error"
+  });
+  if (!response.hasErrors) response.headers.set("x-rpc-error", rpcError.type);
+  response.statusCode = rpcError.statusCode ?? core.StatusCodes.UNEXPECTED_ERROR;
+  response.hasErrors = true;
+  const thrownErrors = context.request.thrownErrors || {};
+  thrownErrors[path] = rpcError;
+  context.request.thrownErrors = thrownErrors;
+}
+exports.getRouterFatalErrorResponse = getRouterFatalErrorResponse;
+exports.onExecutableError = onExecutableError;
+//# sourceMappingURL=dispatchError.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchError.cjs","sources":["../../../../src/lib/dispatchError.ts"],"sourcesContent":["import {RpcError, MION_ROUTES, Mutable, StatusCodes, SerializerModes} from '@mionjs/core';\nimport type {CallContext, MionHeaders, MionRequest, MionResponse, ResponseBody} from '../types/context.ts';\nimport type {RemoteMethod} from '../types/remoteMethods.ts';\n\n/**\n * Return a Response mion response for any error that happens before or outside the router.\n * to be used by any adapter layer. ie: node/http, aws/lambda, bun, etc.\n * Uses thrownErrors with a special platformError key to maintain consistency with route errors.\n * @param returnErr\n * @param respHeaders\n * @returns\n */\n\nexport function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse {\n    // Store platform error in thrownErrors with special platformError key\n    const body: ResponseBody = {\n        '@thrownErrors': {[MION_ROUTES.platformError]: returnErr},\n    };\n    respHeaders.set('content-type', 'application/json; charset=utf-8');\n    const response: Mutable<MionResponse> = {\n        statusCode: returnErr.statusCode || StatusCodes.SERVER_ERROR, // Global errors are always unexpected\n        hasErrors: true,\n        headers: respHeaders,\n        body,\n        rawBody: JSON.stringify(body),\n        serializer: SerializerModes.json, // global errors are always json\n    };\n    return response;\n}\n\n/**\n * Handles errors during route dispatch.\n * All errors passed to this function are unexpected (thrown errors).\n * Expected errors are returned from handlers and added directly to response.body.\n * @param context\n * @param executable\n * @param err\n * @returns\n */\nexport function onExecutableError(context: CallContext, executable: RemoteMethod, err: any | RpcError<string> | Error) {\n    const response = context.response as Mutable<MionResponse>;\n    const path = executable.id;\n    const rpcError: RpcError<string> =\n        err instanceof RpcError\n            ? err\n            : new RpcError({\n                  statusCode: StatusCodes.UNEXPECTED_ERROR,\n                  publicMessage: `Unknown error in handler \"${path}\" of route ExecutionChain.`,\n                  originalError: err,\n                  type: 'unknown-error',\n              });\n    // only first error sets the error header\n    if (!response.hasErrors) response.headers.set('x-rpc-error', rpcError.type);\n    response.statusCode = rpcError.statusCode ?? StatusCodes.UNEXPECTED_ERROR;\n    response.hasErrors = true;\n    // Store unexpected errors for serialization\n    const thrownErrors = context.request.thrownErrors || ({} as Record<string, RpcError<string>>);\n    thrownErrors[path] = rpcError;\n    (context.request as Mutable<MionRequest>).thrownErrors = thrownErrors;\n}\n"],"names":["MION_ROUTES","StatusCodes","SerializerModes","RpcError"],"mappings":";;;AAaO,SAAS,4BAA4B,WAA6B,aAAwC;AAE7G,QAAM,OAAqB;AAAA,IACvB,iBAAiB,EAAC,CAACA,iBAAY,aAAa,GAAG,UAAA;AAAA,EAAS;AAE5D,cAAY,IAAI,gBAAgB,iCAAiC;AACjE,QAAM,WAAkC;AAAA,IACpC,YAAY,UAAU,cAAcC,KAAAA,YAAY;AAAA;AAAA,IAChD,WAAW;AAAA,IACX,SAAS;AAAA,IACT;AAAA,IACA,SAAS,KAAK,UAAU,IAAI;AAAA,IAC5B,YAAYC,KAAAA,gBAAgB;AAAA;AAAA,EAAA;AAEhC,SAAO;AACX;AAWO,SAAS,kBAAkB,SAAsB,YAA0B,KAAqC;AACnH,QAAM,WAAW,QAAQ;AACzB,QAAM,OAAO,WAAW;AACxB,QAAM,WACF,eAAeC,KAAAA,WACT,MACA,IAAIA,KAAAA,SAAS;AAAA,IACT,YAAYF,KAAAA,YAAY;AAAA,IACxB,eAAe,6BAA6B,IAAI;AAAA,IAChD,eAAe;AAAA,IACf,MAAM;AAAA,EAAA,CACT;AAEX,MAAI,CAAC,SAAS,UAAW,UAAS,QAAQ,IAAI,eAAe,SAAS,IAAI;AAC1E,WAAS,aAAa,SAAS,cAAcA,KAAAA,YAAY;AACzD,WAAS,YAAY;AAErB,QAAM,eAAe,QAAQ,QAAQ,gBAAiB,CAAA;AACtD,eAAa,IAAI,IAAI;AACpB,UAAQ,QAAiC,eAAe;AAC7D;;;"}

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

@@ -0,0 +1,5 @@
+import { RpcError } from '@mionjs/core';
+import { CallContext, MionHeaders, MionResponse } from '../types/context.ts';
+import { RemoteMethod } from '../types/remoteMethods.ts';
+export declare function getRouterFatalErrorResponse(returnErr: RpcError<string>, respHeaders: MionHeaders): MionResponse;
+export declare function onExecutableError(context: CallContext, executable: RemoteMethod, err: any | RpcError<string> | Error): void;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+function route(handler, opts) {
+  return {
+    type: core.HandlerType.route,
+    handler,
+    options: opts
+  };
+}
+function query(handler, opts) {
+  return {
+    type: core.HandlerType.route,
+    handler,
+    options: { ...opts, isMutation: false }
+  };
+}
+function mutation(handler, opts) {
+  return {
+    type: core.HandlerType.route,
+    handler,
+    options: { ...opts, isMutation: true }
+  };
+}
+function middleFn(handler, opts) {
+  return {
+    type: core.HandlerType.middleFn,
+    handler,
+    options: opts
+  };
+}
+function headersFn(handler, opts) {
+  return {
+    type: core.HandlerType.headersMiddleFn,
+    handler,
+    options: opts
+  };
+}
+function rawMiddleFn(handler, opts) {
+  return {
+    type: core.HandlerType.rawMiddleFn,
+    handler,
+    options: opts
+  };
+}
+exports.headersFn = headersFn;
+exports.middleFn = middleFn;
+exports.mutation = mutation;
+exports.query = query;
+exports.rawMiddleFn = rawMiddleFn;
+exports.route = route;
+//# sourceMappingURL=handlers.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.cjs","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 {HeadersMiddleFnOptions, MiddleFnOptions, RawMiddleFnOptions, RouteOptions} from '../types/remoteMethods.ts';\nimport {HandlerType} from '@mionjs/core';\nimport {Handler, HeaderHandler, RawMiddleFnHandler} from '../types/handlers.ts';\nimport {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from '../types/definitions.ts';\n\n// ############# Route & MiddleFns initialization #############\n// these functions are just helpers to initialize the route & middleFns objects and keep route definitions clean\n\nexport function route<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H> {\n    return {\n        type: HandlerType.route,\n        handler,\n        options: opts,\n    };\n}\n\n/** Route handler for read-only queries. Uses GET with ?data=base64url on the client when payload fits. */\nexport function query<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H> {\n    return {\n        type: HandlerType.route,\n        handler,\n        options: {...opts, isMutation: false},\n    };\n}\n\n/** Route handler for mutations. Explicit alias for route() with isMutation: true. */\nexport function mutation<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H> {\n    return {\n        type: HandlerType.route,\n        handler,\n        options: {...opts, isMutation: true},\n    };\n}\n\nexport function middleFn<H extends Handler>(handler: H, opts?: MiddleFnOptions): MiddleFnDef<H> {\n    return {\n        type: HandlerType.middleFn,\n        handler,\n        options: opts,\n    };\n}\n\n/**\n * MiddleFn for handling HTTP header parameters\n * Used to define middleFns that receive values from HTTP headers\n *\n * @example\n * ```ts\n * headersFn(['authorization'], (ctx, token: string): void => {\n *   // token contains the value of the 'authorization' header\n * })\n * ```\n */\nexport function headersFn<H extends HeaderHandler>(handler: H, opts?: HeadersMiddleFnOptions): HeadersMiddleFnDef<H> {\n    return {\n        type: HandlerType.headersMiddleFn,\n        handler,\n        options: opts,\n    };\n}\n\nexport function rawMiddleFn<H extends RawMiddleFnHandler>(handler: H, opts?: RawMiddleFnOptions): RawMiddleFnDef<H> {\n    return {\n        type: HandlerType.rawMiddleFn,\n        handler,\n        options: opts,\n    };\n}\n"],"names":["HandlerType"],"mappings":";;;AAeO,SAAS,MAAyB,SAAY,MAAkC;AACnF,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;AAGO,SAAS,MAAyB,SAAY,MAAkC;AACnF,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS,EAAC,GAAG,MAAM,YAAY,MAAA;AAAA,EAAK;AAE5C;AAGO,SAAS,SAA4B,SAAY,MAAkC;AACtF,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS,EAAC,GAAG,MAAM,YAAY,KAAA;AAAA,EAAI;AAE3C;AAEO,SAAS,SAA4B,SAAY,MAAwC;AAC5F,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;AAaO,SAAS,UAAmC,SAAY,MAAsD;AACjH,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;AAEO,SAAS,YAA0C,SAAY,MAA8C;AAChH,SAAO;AAAA,IACH,MAAMA,KAAAA,YAAY;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,EAAA;AAEjB;;;;;;;"}

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

@@ -0,0 +1,9 @@
+import { HeadersMiddleFnOptions, MiddleFnOptions, RawMiddleFnOptions, RouteOptions } from '../types/remoteMethods.ts';
+import { Handler, HeaderHandler, RawMiddleFnHandler } from '../types/handlers.ts';
+import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from '../types/definitions.ts';
+export declare function route<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H>;
+export declare function query<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H>;
+export declare function mutation<H extends Handler>(handler: H, opts?: RouteOptions): RouteDef<H>;
+export declare function middleFn<H extends Handler>(handler: H, opts?: MiddleFnOptions): MiddleFnDef<H>;
+export declare function headersFn<H extends HeaderHandler>(handler: H, opts?: HeadersMiddleFnOptions): HeadersMiddleFnDef<H>;
+export declare function rawMiddleFn<H extends RawMiddleFnHandler>(handler: H, opts?: RawMiddleFnOptions): RawMiddleFnDef<H>;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class MionHeadersImpl {
+  constructor(headers) {
+    this.headers = headers;
+  }
+  append(name, value) {
+    const nl = name.toLowerCase();
+    const existing = this.headers[nl];
+    const headerValue = toSingleHeader(value);
+    if (existing) {
+      this.headers[nl] = `${existing}, ${headerValue}`;
+    } else {
+      this.headers[nl] = headerValue;
+    }
+  }
+  delete(name) {
+    const nl = name.toLowerCase();
+    delete this.headers[nl];
+  }
+  get(name) {
+    const nl = name.toLowerCase();
+    return this.headers[nl];
+  }
+  set(name, value) {
+    const ln = name.toLowerCase();
+    this.headers[ln] = value;
+  }
+  has(name) {
+    const nl = name.toLowerCase();
+    return !!this.headers[nl];
+  }
+  entries() {
+    return new Map(Object.entries(this.headers)).entries();
+  }
+  keys() {
+    return new Map(Object.entries(this.headers)).keys();
+  }
+  values() {
+    return new Map(Object.entries(this.headers)).values();
+  }
+}
+function headersFromRecord(headersObj, skipToLower = false) {
+  const headers = parseHeaders(headersObj, skipToLower);
+  return new MionHeadersImpl(headers);
+}
+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 = {};
+  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;
+}
+exports.headersFromRecord = headersFromRecord;
+//# sourceMappingURL=headers.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headers.cjs","sources":["../../../../src/lib/headers.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {MionHeaders} from '../types/context.ts';\n\n// ############# PUBLIC METHODS #############\n\ntype HeadersRecord = Record<string, string>;\n\n/**\n * Reusable class for managing HTTP headers with case-insensitive access\n * Similar to the fetch Headers API but optimized for performance\n * https://developer.mozilla.org/en-US/docs/Web/API/Headers\n */\nclass MionHeadersImpl implements MionHeaders {\n    constructor(private headers: HeadersRecord) {}\n\n    append(name: string, value: string): void {\n        const nl = name.toLowerCase();\n        const existing = this.headers[nl];\n        const headerValue = toSingleHeader(value);\n        if (existing) {\n            this.headers[nl] = `${existing}, ${headerValue}`;\n        } else {\n            this.headers[nl] = headerValue;\n        }\n    }\n\n    delete(name: string): void {\n        const nl = name.toLowerCase();\n        delete this.headers[nl];\n    }\n\n    get(name: string): string | undefined | null {\n        const nl = name.toLowerCase();\n        return this.headers[nl];\n    }\n\n    set(name: string, value: string): void {\n        const ln = name.toLowerCase();\n        this.headers[ln] = value as string;\n    }\n\n    has(name: string): boolean {\n        const nl = name.toLowerCase();\n        return !!this.headers[nl];\n    }\n\n    entries(): IterableIterator<[string, string]> {\n        return new Map(Object.entries(this.headers)).entries();\n    }\n\n    keys(): IterableIterator<string> {\n        return new Map(Object.entries(this.headers)).keys();\n    }\n\n    values(): IterableIterator<string> {\n        return new Map(Object.entries(this.headers)).values();\n    }\n}\n\n/**\n * Return a Headers Like object from a Headers Record structure (Record<string, string | string[]>)\n * Returned Headers object is similar to the fetch Headers object but not exactly the same\n * https://developer.mozilla.org/en-US/docs/Web/API/Headers\n *\n * This is optimized to avoid creating the Headers Map if it's not strictly needed.\n * ie. for incoming header that only use get method, the Headers object is never created and instead the HeadersRecord is used directly.\n *\n * This function can be used to create a Headers object from incoming request that has the headers in an object structure.\n * ie IncomingMessage.headers or ApiGatewayEvent.headers\n *\n * @param headersObj\n * @returns\n */\nexport function headersFromRecord(headersObj: Record<string, string>, skipToLower = false): MionHeaders {\n    // lazy load headers map\n    const headers = parseHeaders(headersObj, skipToLower);\n    return new MionHeadersImpl(headers);\n}\n\nfunction toSingleHeader(value: string | number): string {\n    if (Array.isArray(value)) return value.join(', ');\n    return value as string;\n}\n\nfunction parseHeaders(headersObj: Record<string, string>, skipToLower = false): HeadersRecord {\n    if (skipToLower) return headersObj;\n    const entries = Object.entries(headersObj);\n    const headers: HeadersRecord = {};\n    for (let i = 0; i < entries.length; i++) {\n        const [name, value] = entries[i];\n        if (!value) continue;\n        const ln = name.toLowerCase();\n        headers[ln] = toSingleHeader(value);\n    }\n    return headers;\n}\n"],"names":[],"mappings":";;AAkBA,MAAM,gBAAuC;AAAA,EACzC,YAAoB,SAAwB;AAAxB,SAAA,UAAA;AAAA,EAAyB;AAAA,EAE7C,OAAO,MAAc,OAAqB;AACtC,UAAM,KAAK,KAAK,YAAA;AAChB,UAAM,WAAW,KAAK,QAAQ,EAAE;AAChC,UAAM,cAAc,eAAe,KAAK;AACxC,QAAI,UAAU;AACV,WAAK,QAAQ,EAAE,IAAI,GAAG,QAAQ,KAAK,WAAW;AAAA,IAClD,OAAO;AACH,WAAK,QAAQ,EAAE,IAAI;AAAA,IACvB;AAAA,EACJ;AAAA,EAEA,OAAO,MAAoB;AACvB,UAAM,KAAK,KAAK,YAAA;AAChB,WAAO,KAAK,QAAQ,EAAE;AAAA,EAC1B;AAAA,EAEA,IAAI,MAAyC;AACzC,UAAM,KAAK,KAAK,YAAA;AAChB,WAAO,KAAK,QAAQ,EAAE;AAAA,EAC1B;AAAA,EAEA,IAAI,MAAc,OAAqB;AACnC,UAAM,KAAK,KAAK,YAAA;AAChB,SAAK,QAAQ,EAAE,IAAI;AAAA,EACvB;AAAA,EAEA,IAAI,MAAuB;AACvB,UAAM,KAAK,KAAK,YAAA;AAChB,WAAO,CAAC,CAAC,KAAK,QAAQ,EAAE;AAAA,EAC5B;AAAA,EAEA,UAA8C;AAC1C,WAAO,IAAI,IAAI,OAAO,QAAQ,KAAK,OAAO,CAAC,EAAE,QAAA;AAAA,EACjD;AAAA,EAEA,OAAiC;AAC7B,WAAO,IAAI,IAAI,OAAO,QAAQ,KAAK,OAAO,CAAC,EAAE,KAAA;AAAA,EACjD;AAAA,EAEA,SAAmC;AAC/B,WAAO,IAAI,IAAI,OAAO,QAAQ,KAAK,OAAO,CAAC,EAAE,OAAA;AAAA,EACjD;AACJ;AAgBO,SAAS,kBAAkB,YAAoC,cAAc,OAAoB;AAEpG,QAAM,UAAU,aAAa,YAAY,WAAW;AACpD,SAAO,IAAI,gBAAgB,OAAO;AACtC;AAEA,SAAS,eAAe,OAAgC;AACpD,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,MAAM,KAAK,IAAI;AAChD,SAAO;AACX;AAEA,SAAS,aAAa,YAAoC,cAAc,OAAsB;AAC1F,MAAI,YAAa,QAAO;AACxB,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,QAAM,UAAyB,CAAA;AAC/B,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACrC,UAAM,CAAC,MAAM,KAAK,IAAI,QAAQ,CAAC;AAC/B,QAAI,CAAC,MAAO;AACZ,UAAM,KAAK,KAAK,YAAA;AAChB,YAAQ,EAAE,IAAI,eAAe,KAAK;AAAA,EACtC;AACA,SAAO;AACX;;"}

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

@@ -0,0 +1,2 @@
+import { MionHeaders } from '../types/context.ts';
+export declare function headersFromRecord(headersObj: Record<string, string>, skipToLower?: boolean): MionHeaders;

package/.dist/cjs/src/lib/methodsCache.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const src_constants = require("../constants.cjs");
+exports.persistedMethods = {};
+function addToPersistedMethods(id, method) {
+  if (!shouldCompile() || !!exports.persistedMethods[id]) return;
+  exports.persistedMethods[id] = method;
+}
+function getPersistedMethod(id, handler) {
+  const method = exports.persistedMethods?.[id];
+  if (!method) return;
+  return restorePersistedMethod(method, handler);
+}
+function getPersistedMethodMetadata(id) {
+  const method = exports.persistedMethods[id];
+  return method;
+}
+function getPersistedMethods() {
+  return exports.persistedMethods;
+}
+function setPersistedMethods(newCompiled) {
+  exports.persistedMethods = newCompiled;
+}
+function resetPersistedMethods() {
+  exports.persistedMethods = {};
+}
+function restorePersistedMethod(method, handler) {
+  const restored = method;
+  if (restored.paramsJitFns && restored.returnJitFns && restored.paramNames && !!restored.handler)
+    return method;
+  restored.handler = handler;
+  restored.paramsJitFns = core.getJitFunctionsFromHash(method.paramsJitHash);
+  restored.returnJitFns = core.getJitFunctionsFromHash(method.returnJitHash);
+  if (src_constants.IS_TEST_ENV) restored.isRestored = true;
+  return restored;
+}
+function shouldCompile() {
+  return core.isMionAOTEmitMode();
+}
+function loadCompiledMethods(compiledMethods) {
+  for (const [key, value] of Object.entries(compiledMethods)) {
+    if (!(key in exports.persistedMethods)) {
+      exports.persistedMethods[key] = value;
+    }
+  }
+}
+exports.addToPersistedMethods = addToPersistedMethods;
+exports.getPersistedMethod = getPersistedMethod;
+exports.getPersistedMethodMetadata = getPersistedMethodMetadata;
+exports.getPersistedMethods = getPersistedMethods;
+exports.loadCompiledMethods = loadCompiledMethods;
+exports.resetPersistedMethods = resetPersistedMethods;
+exports.setPersistedMethods = setPersistedMethods;
+//# sourceMappingURL=methodsCache.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"methodsCache.cjs","sources":["../../../../src/lib/methodsCache.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 {MethodsCache, MethodMetadata, isMionAOTEmitMode, getJitFunctionsFromHash} from '@mionjs/core';\nimport {RemoteMethod} from '../types/remoteMethods.ts';\nimport {AnyHandler} from '../types/handlers.ts';\nimport {IS_TEST_ENV} from '../constants.ts';\n\nexport let persistedMethods: MethodsCache = {};\n\n// ############# PUBLIC METHODS #############\n\nexport function addToPersistedMethods(id: string, method: RemoteMethod) {\n    if (!shouldCompile() || !!persistedMethods[id]) return;\n    persistedMethods[id] = method;\n}\n\nexport function getPersistedMethod(id: string, handler: AnyHandler): RemoteMethod | undefined {\n    const method = persistedMethods?.[id];\n    if (!method) return;\n    return restorePersistedMethod(method, handler);\n}\n\n/** Gets method metadata from the persisted methods cache by id. */\nexport function getPersistedMethodMetadata(id: string): MethodMetadata | undefined {\n    const method = persistedMethods[id];\n    return method;\n}\n\nexport function getPersistedMethods(): Readonly<MethodsCache> {\n    return persistedMethods;\n}\n\nexport function setPersistedMethods(newCompiled: MethodsCache) {\n    persistedMethods = newCompiled;\n}\n\nexport function resetPersistedMethods() {\n    persistedMethods = {};\n}\n\nfunction restorePersistedMethod(method: MethodMetadata, handler: AnyHandler): RemoteMethod {\n    const restored = method as any as RemoteMethod;\n    if (restored.paramsJitFns && restored.returnJitFns && restored.paramNames && !!restored.handler)\n        return method as RemoteMethod;\n    restored.handler = handler;\n    restored.paramsJitFns = getJitFunctionsFromHash(method.paramsJitHash);\n    restored.returnJitFns = getJitFunctionsFromHash(method.returnJitHash);\n    if (IS_TEST_ENV) (restored as any).isRestored = true;\n    return restored;\n}\n\nfunction shouldCompile() {\n    return isMionAOTEmitMode();\n}\n\n/**\n * Loads compiled methods data into the persistedMethods cache.\n * This function merges the provided methods data into the existing persistedMethods without overwriting existing entries.\n * @param compiledMethods - Object containing compiled methods data to merge into the cache\n */\nexport function loadCompiledMethods(compiledMethods: MethodsCache) {\n    for (const [key, value] of Object.entries(compiledMethods)) {\n        if (!(key in persistedMethods)) {\n            persistedMethods[key] = value;\n        }\n    }\n}\n"],"names":["persistedMethods","getJitFunctionsFromHash","IS_TEST_ENV","isMionAOTEmitMode"],"mappings":";;;;AAYWA,QAAAA,mBAAiC,CAAA;AAIrC,SAAS,sBAAsB,IAAY,QAAsB;AACpE,MAAI,CAAC,cAAA,KAAmB,CAAC,CAACA,QAAAA,iBAAiB,EAAE,EAAG;AAChDA,UAAAA,iBAAiB,EAAE,IAAI;AAC3B;AAEO,SAAS,mBAAmB,IAAY,SAA+C;AAC1F,QAAM,SAASA,QAAAA,mBAAmB,EAAE;AACpC,MAAI,CAAC,OAAQ;AACb,SAAO,uBAAuB,QAAQ,OAAO;AACjD;AAGO,SAAS,2BAA2B,IAAwC;AAC/E,QAAM,SAASA,QAAAA,iBAAiB,EAAE;AAClC,SAAO;AACX;AAEO,SAAS,sBAA8C;AAC1D,SAAOA,QAAAA;AACX;AAEO,SAAS,oBAAoB,aAA2B;AAC3DA,UAAAA,mBAAmB;AACvB;AAEO,SAAS,wBAAwB;AACpCA,UAAAA,mBAAmB,CAAA;AACvB;AAEA,SAAS,uBAAuB,QAAwB,SAAmC;AACvF,QAAM,WAAW;AACjB,MAAI,SAAS,gBAAgB,SAAS,gBAAgB,SAAS,cAAc,CAAC,CAAC,SAAS;AACpF,WAAO;AACX,WAAS,UAAU;AACnB,WAAS,eAAeC,6BAAwB,OAAO,aAAa;AACpE,WAAS,eAAeA,6BAAwB,OAAO,aAAa;AACpE,MAAIC,cAAAA,YAAc,UAAiB,aAAa;AAChD,SAAO;AACX;AAEA,SAAS,gBAAgB;AACrB,SAAOC,uBAAA;AACX;AAOO,SAAS,oBAAoB,iBAA+B;AAC/D,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,eAAe,GAAG;AACxD,QAAI,EAAE,OAAOH,QAAAA,mBAAmB;AAC5BA,cAAAA,iBAAiB,GAAG,IAAI;AAAA,IAC5B;AAAA,EACJ;AACJ;;;;;;;;"}

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

@@ -0,0 +1,11 @@
+import { MethodsCache, MethodMetadata } from '@mionjs/core';
+import { RemoteMethod } from '../types/remoteMethods.ts';
+import { AnyHandler } from '../types/handlers.ts';
+export declare let persistedMethods: MethodsCache;
+export declare function addToPersistedMethods(id: string, method: RemoteMethod): void;
+export declare function getPersistedMethod(id: string, handler: AnyHandler): RemoteMethod | undefined;
+export declare function getPersistedMethodMetadata(id: string): MethodMetadata | undefined;
+export declare function getPersistedMethods(): Readonly<MethodsCache>;
+export declare function setPersistedMethods(newCompiled: MethodsCache): void;
+export declare function resetPersistedMethods(): void;
+export declare function loadCompiledMethods(compiledMethods: MethodsCache): void;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const __ΩQueryBodyResult = ["rawBody", "SerializerCode", "bodyType", "QueryBodyResult", 'P&4!"w"4#Mw$y'];
+function decodeQueryBody(urlQuery, rawBody) {
+  if (rawBody)
+    return void 0;
+  if (!urlQuery)
+    return void 0;
+  const dataValue = extractDataParam(urlQuery);
+  if (!dataValue)
+    return void 0;
+  return {
+    rawBody: core.fromBase64Url(dataValue),
+    bodyType: core.SerializerModes.stringifyJson
+  };
+}
+decodeQueryBody.__type = ["urlQuery", "rawBody", () => __ΩQueryBodyResult, "decodeQueryBody", 'PP&-J2!#2"Pn#-J/$'];
+function extractDataParam(urlQuery) {
+  if (urlQuery.startsWith("data=")) {
+    const ampIndex2 = urlQuery.indexOf("&", 5);
+    return ampIndex2 === -1 ? urlQuery.slice(5) : urlQuery.slice(5, ampIndex2);
+  }
+  const idx = urlQuery.indexOf("&data=");
+  if (idx === -1)
+    return void 0;
+  const start = idx + 6;
+  const ampIndex = urlQuery.indexOf("&", start);
+  return ampIndex === -1 ? urlQuery.slice(start) : urlQuery.slice(start, ampIndex);
+}
+extractDataParam.__type = ["urlQuery", "extractDataParam", 'P&2!P&-J/"'];
+exports.__ΩQueryBodyResult = __ΩQueryBodyResult;
+exports.decodeQueryBody = decodeQueryBody;
+//# sourceMappingURL=queryBody.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryBody.cjs","sources":["../../../../src/lib/queryBody.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {fromBase64Url, SerializerModes} from '@mionjs/core';\nimport type {SerializerCode} from '@mionjs/core';\n\n/** Result of decoding a base64url query body from ?data= */\nexport interface QueryBodyResult {\n    rawBody: string;\n    bodyType: SerializerCode;\n}\n\n/** Detects and decodes base64url-encoded request body from ?data= query param.\n * Returns decoded body + bodyType if found, undefined otherwise. */\nexport function decodeQueryBody(urlQuery: string | undefined, rawBody: unknown): QueryBodyResult | undefined {\n    if (rawBody) return undefined;\n    if (!urlQuery) return undefined;\n    const dataValue = extractDataParam(urlQuery);\n    if (!dataValue) return undefined;\n    return {\n        rawBody: fromBase64Url(dataValue),\n        bodyType: SerializerModes.stringifyJson,\n    };\n}\n\nfunction extractDataParam(urlQuery: string): string | undefined {\n    if (urlQuery.startsWith('data=')) {\n        const ampIndex = urlQuery.indexOf('&', 5);\n        return ampIndex === -1 ? urlQuery.slice(5) : urlQuery.slice(5, ampIndex);\n    }\n    const idx = urlQuery.indexOf('&data=');\n    if (idx === -1) return undefined;\n    const start = idx + 6;\n    const ampIndex = urlQuery.indexOf('&', start);\n    return ampIndex === -1 ? urlQuery.slice(start) : urlQuery.slice(start, ampIndex);\n}\n"],"names":["fromBase64Url","SerializerModes","ampIndex"],"mappings":";;;;AAkBM,SAAU,gBAAgB,UAA8B,SAAgB;AAC1E,MAAI;AAAS,WAAO;AACpB,MAAI,CAAC;AAAU,WAAO;AACtB,QAAM,YAAY,iBAAiB,QAAQ;AAC3C,MAAI,CAAC;AAAW,WAAO;AACvB,SAAO;AAAA,IACH,SAASA,KAAAA,cAAc,SAAS;AAAA,IAChC,UAAUC,KAAAA,gBAAgB;AAAA,EAAA;AAElC;;AAEA,SAAS,iBAAiB,UAAgB;AACtC,MAAI,SAAS,WAAW,OAAO,GAAG;AAC9B,UAAMC,YAAW,SAAS,QAAQ,KAAK,CAAC;AACxC,WAAOA,cAAa,KAAK,SAAS,MAAM,CAAC,IAAI,SAAS,MAAM,GAAGA,SAAQ;AAAA,EAC3E;AACA,QAAM,MAAM,SAAS,QAAQ,QAAQ;AACrC,MAAI,QAAQ;AAAI,WAAO;AACvB,QAAM,QAAQ,MAAM;AACpB,QAAM,WAAW,SAAS,QAAQ,KAAK,KAAK;AAC5C,SAAO,aAAa,KAAK,SAAS,MAAM,KAAK,IAAI,SAAS,MAAM,OAAO,QAAQ;AACnF;;;;"}

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

@@ -0,0 +1,7 @@
+import { SerializerCode } from '@mionjs/core';
+export interface QueryBodyResult {
+    rawBody: string;
+    bodyType: SerializerCode;
+}
+export declare function decodeQueryBody(urlQuery: string | undefined, rawBody: unknown): QueryBodyResult | undefined;
+export declare type __ΩQueryBodyResult = any[];