@mionjs/client 0.8.0-alpha.0 → 0.8.4-alpha.0

package/.dist/esm/_virtual/jit-fns.js.map

@@ -1 +1 @@
-{"version":3,"file":"jit-fns.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"jit-fns.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/_virtual/router-cache.js

@@ -1,4 +1,4 @@
-const routerCache = { "@thrownErrors": { paramNames: [], type: 1, id: "@thrownErrors", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "cm6MsK", pointer: ["@thrownErrors"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@notFound": { paramNames: [], type: 1, id: "mion@notFound", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "a8UQwC", pointer: ["mion@notFound"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@platformError": { paramNames: [], type: 1, id: "mion@platformError", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "zxRrbt", pointer: ["mion@platformError"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@methodsMetadataById": { paramNames: ["methodsIds", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataById", isAsync: !1, hasReturnData: !0, paramsJitHash: "JtnVhp", returnJitHash: "rFrbJx", pointer: ["mion@methodsMetadataById"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@methodsMetadataByPath": { paramNames: ["path", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataByPath", isAsync: !1, hasReturnData: !0, paramsJitHash: "hZzD9z", returnJitHash: "rFrbJx", pointer: ["mion@methodsMetadataByPath"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@mionEmptyMiddleFn": { paramNames: [], type: 2, id: "mion@mionEmptyMiddleFn", isAsync: !1, hasReturnData: !1, paramsJitHash: "", returnJitHash: "", pointer: ["mion@mionEmptyMiddleFn"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1 } } };
+const routerCache = { "@thrownErrors": { paramNames: [], type: 1, id: "@thrownErrors", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "cm6MsK", pointer: ["@thrownErrors"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@notFound": { paramNames: [], type: 1, id: "mion@notFound", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "a8UQwC", pointer: ["mion@notFound"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@platformError": { paramNames: [], type: 1, id: "mion@platformError", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "zxRrbt", pointer: ["mion@platformError"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@methodsMetadataById": { paramNames: ["methodsIds", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataById", isAsync: !1, hasReturnData: !0, paramsJitHash: "JtnVhp", returnJitHash: "BFxvvN", pointer: ["mion@methodsMetadataById"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@methodsMetadataByPath": { paramNames: ["path", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataByPath", isAsync: !1, hasReturnData: !0, paramsJitHash: "hZzD9z", returnJitHash: "BFxvvN", pointer: ["mion@methodsMetadataByPath"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@mionEmptyMiddleFn": { paramNames: [], type: 2, id: "mion@mionEmptyMiddleFn", isAsync: !1, hasReturnData: !1, paramsJitHash: "", returnJitHash: "", pointer: ["mion@mionEmptyMiddleFn"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1 } } };
 export {
   routerCache
 };

package/.dist/esm/index.d.ts

@@ -1,11 +1,12 @@
 export * from './src/types.ts';
 export * from './src/constants.ts';
-export * from './src/storage.ts';
-export * from './src/validation.ts';
-export * from './src/serializer.ts';
-export * from './src/clientMethodsMetadata.ts';
+export * from './src/lib/storage.ts';
+export * from './src/lib/validation.ts';
+export * from './src/lib/serializer.ts';
+export * from './src/lib/clientMethodsMetadata.ts';
 export * from './src/request.ts';
 export * from './src/client.ts';
-export * from './src/typedEvent.ts';
-export * from './src/handlersRegistry.ts';
+export * from './src/aot/aotCaches.ts';
+export * from './src/lib/typedEvent.ts';
+export * from './src/lib/handlersRegistry.ts';
 export * from './src/routesFlow.ts';

package/.dist/esm/index.js

@@ -1,13 +1,13 @@
-import { __ΩCallWithMiddleFnsResult, __ΩCleaned, __ΩClientMiddleFns, __ΩClientOptions, __ΩClientRoutes, __ΩErrorHandler, __ΩFailResponse, __ΩFailResponses, __ΩHSubRequest, __ΩHandlerErrors, __ΩHandlerFailResponse, __ΩHandlerResponse, __ΩHandlerSuccessResponse, __ΩHeadersParamsType, __ΩInitClientOptions, __ΩMiddleFnError, __ΩMiddleFnSuccess, __ΩNonClientMiddleFn, __ΩNonClientRoute, __ΩPrefilledMiddleFnsCache, __ΩRSubRequest, __ΩRequestBody, __ΩRequestErrors, __ΩRequestHeaders, __ΩResult, __ΩRouteParamType, __ΩRouteParamsType, __ΩRouteReturnType, __ΩSubRequest, __ΩSuccessClientResponse, __ΩSuccessHandler, __ΩSuccessResponse, __ΩSuccessResponses, __ΩUnknownErrorHandler, __ΩWorkflowResult, __ΩWorkflowRouteErrors, __ΩWorkflowRouteResults } from "./src/types.js";
 import { DEFAULT_PREFILL_OPTIONS, MAX_GET_URL_LENGTH, ROUTES_FLOW_KEY, ROUTES_FLOW_PATH, STORAGE_KEY } from "./src/constants.js";
-import { MemoryStorage, getStorage, resetStorageInstance } from "./src/storage.js";
-import { validateSubRequest, validateSubRequests } from "./src/validation.js";
-import { __ΩContentType, __ΩSerializedBody, __ΩSerializedRequest, deserializeResponseBody, serializeRequestBody } from "./src/serializer.js";
-import { fetchRemoteMethodsMetadata, getAOTCaches, restoreAllDependencies, storeDependencies, storeMethodsMetadata } from "./src/clientMethodsMetadata.js";
+import { MemoryStorage, getStorage, resetStorageInstance } from "./src/lib/storage.js";
+import { validateSubRequest, validateSubRequests } from "./src/lib/validation.js";
+import { deserializeResponseBody, serializeRequestBody } from "./src/lib/serializer.js";
+import { fetchRemoteMethodsMetadata, restoreAllDependencies, storeDependencies, storeMethodsMetadata } from "./src/lib/clientMethodsMetadata.js";
 import { MionClientRequest } from "./src/request.js";
 import { MionClient, initClient } from "./src/client.js";
-import { TypedEvent } from "./src/typedEvent.js";
-import { HandlersRegistry } from "./src/handlersRegistry.js";
+import { getAOTCaches, loadAOTCaches } from "./src/aot/aotCaches.js";
+import { TypedEvent } from "./src/lib/typedEvent.js";
+import { HandlersRegistry } from "./src/lib/handlersRegistry.js";
 import { isMapFromRef, mapFrom, mapFromSymbol, routesFlow } from "./src/routesFlow.js";
 export {
   DEFAULT_PREFILL_OPTIONS,
@@ -20,52 +20,13 @@ export {
   ROUTES_FLOW_PATH,
   STORAGE_KEY,
   TypedEvent,
-  __ΩCallWithMiddleFnsResult,
-  __ΩCleaned,
-  __ΩClientMiddleFns,
-  __ΩClientOptions,
-  __ΩClientRoutes,
-  __ΩContentType,
-  __ΩErrorHandler,
-  __ΩFailResponse,
-  __ΩFailResponses,
-  __ΩHSubRequest,
-  __ΩHandlerErrors,
-  __ΩHandlerFailResponse,
-  __ΩHandlerResponse,
-  __ΩHandlerSuccessResponse,
-  __ΩHeadersParamsType,
-  __ΩInitClientOptions,
-  __ΩMiddleFnError,
-  __ΩMiddleFnSuccess,
-  __ΩNonClientMiddleFn,
-  __ΩNonClientRoute,
-  __ΩPrefilledMiddleFnsCache,
-  __ΩRSubRequest,
-  __ΩRequestBody,
-  __ΩRequestErrors,
-  __ΩRequestHeaders,
-  __ΩResult,
-  __ΩRouteParamType,
-  __ΩRouteParamsType,
-  __ΩRouteReturnType,
-  __ΩSerializedBody,
-  __ΩSerializedRequest,
-  __ΩSubRequest,
-  __ΩSuccessClientResponse,
-  __ΩSuccessHandler,
-  __ΩSuccessResponse,
-  __ΩSuccessResponses,
-  __ΩUnknownErrorHandler,
-  __ΩWorkflowResult,
-  __ΩWorkflowRouteErrors,
-  __ΩWorkflowRouteResults,
   deserializeResponseBody,
   fetchRemoteMethodsMetadata,
   getAOTCaches,
   getStorage,
   initClient,
   isMapFromRef,
+  loadAOTCaches,
   mapFrom,
   mapFromSymbol,
   resetStorageInstance,

package/.dist/esm/src/aot/aotCaches.d.ts

@@ -0,0 +1,5 @@
+export declare function loadAOTCaches(): void;
+export declare function getAOTCaches(): {
+    jitFnsCache: Record<string, any>;
+    pureFnsCache: Record<string, Record<string, any>>;
+};

package/.dist/esm/src/aot/aotCaches.js

@@ -0,0 +1,16 @@
+import { jitFnsCache } from "../../_virtual/jit-fns.js";
+import { pureFnsCache } from "../../_virtual/pure-fns.js";
+import { routerCache } from "../../_virtual/router-cache.js";
+import { addAOTCaches, addRoutesToCache } from "@mionjs/core";
+let aotCachesLoaded = !1;
+function loadAOTCaches() {
+  aotCachesLoaded || (aotCachesLoaded = !0, addAOTCaches(jitFnsCache, pureFnsCache), addRoutesToCache(routerCache));
+}
+function getAOTCaches() {
+  return { jitFnsCache, pureFnsCache };
+}
+export {
+  getAOTCaches,
+  loadAOTCaches
+};
+//# sourceMappingURL=aotCaches.js.map

package/.dist/esm/src/aot/aotCaches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aotCaches.js","sources":["../../../../src/aot/aotCaches.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {jitFnsCache} from 'virtual:client-mion-aot/jit-fns';\nimport {pureFnsCache} from 'virtual:client-mion-aot/pure-fns';\nimport {routerCache} from 'virtual:client-mion-aot/router-cache';\nimport {addAOTCaches, addRoutesToCache} from '@mionjs/core';\n\nlet aotCachesLoaded = false;\n\n/** Loads AOT caches into the global cache. Safe to call multiple times. */\nexport function loadAOTCaches() {\n    if (aotCachesLoaded) return;\n    aotCachesLoaded = true;\n    addAOTCaches(jitFnsCache, pureFnsCache);\n    addRoutesToCache(routerCache);\n}\n\n/** Returns the AOT caches from the virtual module. Used by test utilities to filter and reset caches. */\nexport function getAOTCaches() {\n    return {jitFnsCache, pureFnsCache};\n}\n"],"names":[],"mappings":";;;;AAYA,IAAI,kBAAkB;SAGN,gBAAa;AACzB,EAAI,oBACJ,kBAAkB,IAClB,aAAa,aAAa,YAAY,GACtC,iBAAiB,WAAW;AAChC;SAGgB,eAAY;AACxB,SAAO,EAAC,aAAa,aAAA;AACzB;"}

package/.dist/esm/src/client.d.ts

@@ -1,7 +1,7 @@
 import { CallWithMiddleFnsResult, ClientOptions, HSubRequest, InitClientOptions, RSubRequest, SubRequest, ClientRoutes, ClientMiddleFns, Result, WorkflowResult } from './types.ts';
 import { RemoteApi } from '@mionjs/router';
 import { RunTypeError } from '@mionjs/core';
-import { HandlersRegistry } from './handlersRegistry.ts';
+import { HandlersRegistry } from './lib/handlersRegistry.ts';
 export declare function initClient<RM extends RemoteApi>(options: InitClientOptions): {
     client: MionClient;
     routes: ClientRoutes<RM>;

package/.dist/esm/src/client.js

@@ -1,15 +1,11 @@
 import { DEFAULT_PREFILL_OPTIONS } from "./constants.js";
-import { __ΩSubRequest as ___SubRequest, __ΩClientOptions as ___ClientOptions, __ΩResult as ___Result, __ΩRSubRequest as ___RSubRequest, __ΩCallWithMiddleFnsResult as ___CallWithMiddleFnsResult, __ΩWorkflowResult as ___WorkflowResult, __ΩHSubRequest as ___HSubRequest, __ΩRequestErrors as ___RequestErrors, __ΩInitClientOptions as ___InitClientOptions, __ΩClientRoutes as ___ClientRoutes, __ΩClientMiddleFns as ___ClientMiddleFns } from "./types.js";
 import { registerErrorDeserializers, getRouterItemId } from "@mionjs/core";
 import { MionClientRequest } from "./request.js";
-import { HandlersRegistry } from "./handlersRegistry.js";
+import { HandlersRegistry } from "./lib/handlersRegistry.js";
 import { findSubRequestError, MionSubRequest } from "./subRequest.js";
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
+import { loadAOTCaches } from "./aot/aotCaches.js";
 function initClient(options) {
-  registerErrorDeserializers();
+  loadAOTCaches(), registerErrorDeserializers();
   const clientOptions = {
     ...DEFAULT_PREFILL_OPTIONS,
     ...options
@@ -20,13 +16,12 @@ function initClient(options) {
     middleFns: rootProxy.proxy
   };
 }
-initClient.__type = [() => ___InitClientOptions, "options", () => MionClient, "client", () => ___ClientRoutes, "routes", () => ___ClientMiddleFns, "middleFns", "initClient", `Pn!2"PP7#4$"o%"4&"o'"4(M/)`];
 class MionClient {
   clientOptions;
   /** Shared registry for persistent middleFn error handlers */
   handlersRegistry = new HandlersRegistry();
   /** In-memory cache for prefilled middleFn subrequests (keyed by baseURL:middleFnId) */
-  prefilledMiddleFnsCache = (Map.Ω = [["&"], [() => ___SubRequest, '"o!"']], /* @__PURE__ */ new Map());
+  prefilledMiddleFnsCache = /* @__PURE__ */ new Map();
   /** Tracks in-flight prefill operations to avoid race conditions */
   pendingPrefills = [];
   constructor(clientOptions) {
@@ -58,12 +53,12 @@ class MionClient {
   }
   /** Get route IDs from single route or routesFlow routes */
   getRouteIds(routeSubRequest, workflowSubRequests) {
-    const routeIds = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
-    return routeSubRequest && routeIds.add(routeSubRequest.id), workflowSubRequests && workflowSubRequests.forEach(__assignType((sr) => routeIds.add(sr.id), ["sr", "", 'P"2!"/"'])), routeIds;
+    const routeIds = /* @__PURE__ */ new Set();
+    return routeSubRequest && routeIds.add(routeSubRequest.id), workflowSubRequests && workflowSubRequests.forEach((sr) => routeIds.add(sr.id)), routeIds;
   }
   /** Get all middleFns from the request's subRequestList, excluding the route(s) */
   getAllMiddleFnsFromRequest(request, excludedIds) {
-    return Object.entries(request.subRequestList).filter(__assignType(([id]) => !excludedIds.has(id), ["param0", "", 'P"2!"/"'])).map(__assignType(([, subRequest]) => subRequest, ["param0", "", 'P"2!"/"']));
+    return Object.entries(request.subRequestList).filter(([id]) => !excludedIds.has(id)).map(([, subRequest]) => subRequest);
   }
   /** Process all middleFn responses - call success or error handlers for each middleFn individually */
   processMiddleFnsResponses(middleFnSubRequests, errors) {
@@ -74,7 +69,7 @@ class MionClient {
   }
   /** Build the result 4-tuple from the request results. middleFns can be a named record or an array of subrequests */
   buildResult(routeSubRequest, workflowSubRequests, middleFns, errors) {
-    const middleFnsResults = {}, middleFnsErrors = {}, processedIds = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+    const middleFnsResults = {}, middleFnsErrors = {}, processedIds = /* @__PURE__ */ new Set();
     let routeResultPart, routeErrorPart;
     if (routeSubRequest) {
       processedIds.add(routeSubRequest.id);
@@ -87,7 +82,7 @@ class MionClient {
         const routeError = errors?.get(routeSubRequest2.id);
         routeError ? (routeResults.push(void 0), routeErrors.push(routeError)) : (routeResults.push(routeSubRequest2.resolvedValue), routeErrors.push(void 0));
       }
-      const hasAnyResult = routeResults.some(__assignType((r) => r !== void 0, ["r", "", 'P"2!"/"'])), hasAnyError = routeErrors.some(__assignType((e) => e !== void 0, ["e", "", 'P"2!"/"']));
+      const hasAnyResult = routeResults.some((r) => r !== void 0), hasAnyError = routeErrors.some((e) => e !== void 0);
       routeResultPart = hasAnyResult ? routeResults : void 0, routeErrorPart = hasAnyError ? routeErrors : void 0;
     }
     if (Array.isArray(middleFns))
@@ -124,13 +119,6 @@ class MionClient {
   destroy() {
     this.handlersRegistry.clearAll();
   }
-  static __type = ["handlersRegistry", function() {
-    return new HandlersRegistry();
-  }, "prefilledMiddleFnsCache", function() {
-    return Map.Ω = [["&"], [() => ___SubRequest, '"o!"']], /* @__PURE__ */ new Map();
-  }, "pendingPrefills", function() {
-    return [];
-  }, () => ___ClientOptions, "clientOptions", "constructor", "routeSubRequest", () => ___Result, "executeCall", () => ___RSubRequest, "middleFnsRecord", () => ___CallWithMiddleFnsResult, "executeCallWithMiddleFns", "workflowSubRequests", () => ___WorkflowResult, "executeCallWithWorkflow", () => ___RSubRequest, "executeRequest", () => ___RSubRequest, () => ___RSubRequest, "getRouteIds", () => MionClientRequest, "request", "excludedIds", () => ___HSubRequest, "getAllMiddleFnsFromRequest", () => ___HSubRequest, "middleFnSubRequests", () => ___RequestErrors, "errors", "processMiddleFnsResponses", () => ___RSubRequest, () => ___HSubRequest, "middleFns", () => ___RequestErrors, () => ___CallWithMiddleFnsResult, () => ___WorkflowResult, () => ___Result, "buildResult", "subRequest", "RunTypeError", "typeErrors", "prefill", "removePrefill", "destroy", "MionClient", '!3!9>"!3#9>$$`F3%;>&Pn\'2(;"0)P"2*""o+#`0,P"o-"2*"2."""o/$`00P"21"2.""o2#`03PP"o4"-J2*P"-J21P"-J2."`05;PP"o6"-J2*P"o7"F-J21&D08;PP""792:&D2;"o<"F0=;P"o>"F2?Pn@-J2A$0B;PP"oC"-J2*P"-J21P""oD"FJ2EPnF-J2AP"""oG$""oH#""oI#J0J;P"@2K"wLF`0MP"@2K$`0NP"@2K$`0OP$0P5wQ'];
 }
 class MethodProxy {
   parentProps;
@@ -140,17 +128,17 @@ class MethodProxy {
   handler = {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    apply: __assignType((_target, _thisArg, argArray) => {
+    apply: (_target, _thisArg, argArray) => {
       const handlerId = getRouterItemId(this.parentProps);
       return new MionSubRequest(this.parentProps, handlerId, argArray, this.client);
-    }, ["_target", "_thisArg", "argArray", () => ___RSubRequest, () => ___HSubRequest, "", 'P"2!"2""2#8P"o$""o%"K/&']),
-    get: __assignType((_target, prop) => {
+    },
+    get: (_target, prop) => {
       const existing = this.propsProxies[prop];
       if (existing)
         return existing.proxy;
       const newMethodProxy = new MethodProxy([...this.parentProps, prop], this.client, this.clientOptions);
       return this.propsProxies[prop] = newMethodProxy, newMethodProxy.proxy;
-    }, ["_target", "prop", () => Proxy, "", 'P"2!&2"i#/$'])
+    }
   };
   proxy;
   constructor(parentProps, client, clientOptions) {
@@ -158,25 +146,6 @@ class MethodProxy {
     const target = () => null;
     this.proxy = new Proxy(target, this.handler);
   }
-  static __type = [() => __ΩRecord, () => MethodProxy, "propsProxies", function() {
-    return {};
-  }, "handler", function() {
-    return {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      apply: __assignType((_target, _thisArg, argArray) => {
-        const handlerId = getRouterItemId(this.parentProps);
-        return new MionSubRequest(this.parentProps, handlerId, argArray, this.client);
-      }, ["_target", "_thisArg", "argArray", () => ___RSubRequest, () => ___HSubRequest, "", 'P"2!"2""2#8P"o$""o%"K/&']),
-      get: __assignType((_target, prop) => {
-        const existing = this.propsProxies[prop];
-        if (existing)
-          return existing.proxy;
-        const newMethodProxy = new MethodProxy([...this.parentProps, prop], this.client, this.clientOptions);
-        return this.propsProxies[prop] = newMethodProxy, newMethodProxy.proxy;
-      }, ["_target", "prop", () => Proxy, "", 'P"2!&2"i#/$'])
-    };
-  }, () => Proxy, "proxy", "parentProps", () => MionClient, "client", () => ___ClientOptions, "clientOptions", "constructor", "MethodProxy", `&P7"o!#3#>$!3%>&i'3(P&F2):P7*2+;n,2-;"0.5w/`];
 }
 export {
   MionClient,

package/.dist/esm/src/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"client.js","sources":["../../../src/client.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 {DEFAULT_PREFILL_OPTIONS} from './constants.ts';\nimport {\n    CallWithMiddleFnsResult,\n    ClientOptions,\n    HSubRequest,\n    InitClientOptions,\n    RSubRequest,\n    SubRequest,\n    RequestErrors,\n    ClientRoutes,\n    ClientMiddleFns,\n    Result,\n    WorkflowResult,\n} from './types.ts';\nimport type {RemoteApi} from '@mionjs/router';\nimport {registerErrorDeserializers} from '@mionjs/core';\nimport {getRouterItemId} from '@mionjs/core';\nimport {MionClientRequest} from './request.ts';\nimport type {RunTypeError} from '@mionjs/core';\nimport {HandlersRegistry} from './lib/handlersRegistry.ts';\nimport {MionSubRequest, findSubRequestError} from './subRequest.ts';\nimport {loadAOTCaches} from './aot/aotCaches.ts';\n\nexport function initClient<RM extends RemoteApi>(\n    options: InitClientOptions\n): {client: MionClient; routes: ClientRoutes<RM>; middleFns: ClientMiddleFns<RM>} {\n    loadAOTCaches();\n    registerErrorDeserializers();\n    const clientOptions = {\n        ...DEFAULT_PREFILL_OPTIONS,\n        ...options,\n    };\n    const client = new MionClient(clientOptions);\n    const rootProxy = new MethodProxy([], client, clientOptions);\n    return {\n        client,\n        routes: rootProxy.proxy as ClientRoutes<RM>,\n        middleFns: rootProxy.proxy as ClientMiddleFns<RM>,\n    };\n}\n\nexport class MionClient {\n    /** Shared registry for persistent middleFn error handlers */\n    readonly handlersRegistry = new HandlersRegistry();\n\n    /** In-memory cache for prefilled middleFn subrequests (keyed by baseURL:middleFnId) */\n    readonly prefilledMiddleFnsCache = new Map<string, SubRequest<any>>();\n\n    /** Tracks in-flight prefill operations to avoid race conditions */\n    private pendingPrefills: Promise<void>[] = [];\n\n    constructor(private clientOptions: ClientOptions) {}\n\n    /** Executes a route call and returns a Result 4-tuple */\n    executeCall<RR extends RSubRequest<any>>(routeSubRequest: RR): Promise<Result<any, any>> {\n        return this.executeRequest(routeSubRequest, undefined, undefined);\n    }\n\n    /** Executes a route call with middleFns and returns a typed result object */\n    executeCallWithMiddleFns<H extends Record<string, HSubRequest<any>>>(\n        routeSubRequest: RSubRequest<any>,\n        middleFnsRecord: H\n    ): Promise<CallWithMiddleFnsResult<any, any, H>> {\n        return this.executeRequest(routeSubRequest, undefined, middleFnsRecord);\n    }\n\n    /** Executes a routesFlow call with multiple routes and optional middleFns */\n    executeCallWithWorkflow<Routes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(\n        workflowSubRequests: Routes,\n        middleFnsRecord: H\n    ): Promise<WorkflowResult<Routes, H>> {\n        return this.executeRequest(undefined, workflowSubRequests, middleFnsRecord);\n    }\n\n    private async executeRequest<Routes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(\n        routeSubRequest: RSubRequest<any> | undefined,\n        workflowSubRequests: Routes | undefined,\n        middleFnsRecord: H | undefined\n    ): Promise<any> {\n        // Wait for any in-flight prefill operations to complete before executing the request\n        if (this.pendingPrefills.length > 0) await Promise.allSettled([...this.pendingPrefills]);\n\n        const middleFnSubRequests = middleFnsRecord ? Object.values(middleFnsRecord) : [];\n        const request = new MionClientRequest(\n            this.clientOptions,\n            this.prefilledMiddleFnsCache,\n            routeSubRequest,\n            middleFnSubRequests,\n            workflowSubRequests\n        );\n\n        try {\n            await request.call();\n            const routeIds = this.getRouteIds(routeSubRequest, workflowSubRequests);\n            const allMiddleFns = this.getAllMiddleFnsFromRequest(request, routeIds);\n            this.processMiddleFnsResponses(allMiddleFns, undefined);\n            return this.buildResult(routeSubRequest, workflowSubRequests, middleFnsRecord || allMiddleFns, undefined);\n        } catch (errors: any) {\n            const routeIds = this.getRouteIds(routeSubRequest, workflowSubRequests);\n            const allMiddleFns = this.getAllMiddleFnsFromRequest(request, routeIds);\n            this.processMiddleFnsResponses(allMiddleFns, errors);\n            return this.buildResult(routeSubRequest, workflowSubRequests, middleFnsRecord || allMiddleFns, errors);\n        }\n    }\n\n    /** Get route IDs from single route or routesFlow routes */\n    private getRouteIds(\n        routeSubRequest: RSubRequest<any> | undefined,\n        workflowSubRequests: RSubRequest<any>[] | undefined\n    ): Set<string> {\n        const routeIds = new Set<string>();\n        if (routeSubRequest) routeIds.add(routeSubRequest.id);\n        if (workflowSubRequests) workflowSubRequests.forEach((sr) => routeIds.add(sr.id));\n        return routeIds;\n    }\n\n    /** Get all middleFns from the request's subRequestList, excluding the route(s) */\n    private getAllMiddleFnsFromRequest(request: MionClientRequest<any, any>, excludedIds: Set<string>): HSubRequest<any>[] {\n        return Object.entries(request.subRequestList)\n            .filter(([id]) => !excludedIds.has(id))\n            .map(([, subRequest]) => subRequest as HSubRequest<any>);\n    }\n\n    /** Process all middleFn responses - call success or error handlers for each middleFn individually */\n    private processMiddleFnsResponses(middleFnSubRequests: HSubRequest<any>[], errors: RequestErrors | undefined): void {\n        for (const middleFn of middleFnSubRequests) {\n            const middleFnError = errors?.get(middleFn.id);\n            if (middleFnError) {\n                this.handlersRegistry.executeHandler(middleFn.id, middleFnError);\n            } else if (middleFn.resolvedValue !== undefined) {\n                this.handlersRegistry.executeSuccessHandler(middleFn.id, middleFn.resolvedValue);\n            }\n        }\n    }\n\n    /** Build the result 4-tuple from the request results. middleFns can be a named record or an array of subrequests */\n    private buildResult<Routes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(\n        routeSubRequest: RSubRequest<any> | undefined,\n        workflowSubRequests: Routes | undefined,\n        middleFns: H | HSubRequest<any>[],\n        errors: RequestErrors | undefined\n    ): CallWithMiddleFnsResult<any, any, H> | WorkflowResult<Routes, H> | Result<any, any> {\n        const middleFnsResults = {} as Record<string, any>;\n        const middleFnsErrors = {} as Record<string, any>;\n        const processedIds = new Set<string>();\n\n        let routeResultPart: any;\n        let routeErrorPart: any;\n\n        if (routeSubRequest) {\n            processedIds.add(routeSubRequest.id);\n            const routeError =\n                errors?.get(routeSubRequest.id) || (errors ? findSubRequestError(routeSubRequest, errors) : undefined);\n            routeResultPart = routeError ? undefined : routeSubRequest.resolvedValue;\n            routeErrorPart = routeError;\n        } else if (workflowSubRequests) {\n            const routeResults: (any | undefined)[] = [];\n            const routeErrors: (any | undefined)[] = [];\n            for (const routeSubRequest of workflowSubRequests) {\n                processedIds.add(routeSubRequest.id);\n                const routeError = errors?.get(routeSubRequest.id);\n                if (routeError) {\n                    routeResults.push(undefined);\n                    routeErrors.push(routeError);\n                } else {\n                    routeResults.push(routeSubRequest.resolvedValue);\n                    routeErrors.push(undefined);\n                }\n            }\n            const hasAnyResult = routeResults.some((r) => r !== undefined);\n            const hasAnyError = routeErrors.some((e) => e !== undefined);\n            routeResultPart = hasAnyResult ? routeResults : undefined;\n            routeErrorPart = hasAnyError ? routeErrors : undefined;\n        }\n\n        // middleFns can be a named record (from callWithMiddleFns/routesFlow) or an array (from executeCall)\n        if (Array.isArray(middleFns)) {\n            // Array of subrequests - use IDs as keys\n            for (const middleFn of middleFns) {\n                processedIds.add(middleFn.id);\n                const middleFnError = errors?.get(middleFn.id);\n                if (middleFnError) {\n                    middleFnsErrors[middleFn.id] = middleFnError;\n                } else if (middleFn.resolvedValue !== undefined) {\n                    middleFnsResults[middleFn.id] = middleFn.resolvedValue;\n                }\n            }\n        } else {\n            // Named record - use names as keys\n            for (const [name, middleFn] of Object.entries(middleFns)) {\n                processedIds.add(middleFn.id);\n                const middleFnError = errors?.get(middleFn.id);\n                if (middleFnError) {\n                    middleFnsErrors[name] = middleFnError;\n                } else if (middleFn.resolvedValue !== undefined) {\n                    middleFnsResults[name] = middleFn.resolvedValue;\n                }\n            }\n        }\n\n        if (errors) {\n            for (const [id, error] of errors) {\n                if (!processedIds.has(id)) {\n                    middleFnsErrors[id] = error;\n                }\n            }\n        }\n\n        return [routeResultPart, routeErrorPart, middleFnsResults, middleFnsErrors] as any;\n    }\n\n    typeErrors<List extends SubRequest<any>[]>(...subRequest: List): Promise<RunTypeError[]> {\n        const request = new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache);\n        return request.validateParams(subRequest);\n    }\n\n    prefill<List extends HSubRequest<any>[]>(...subRequest: List): Promise<void> {\n        const request = new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache);\n        const promise = request.prefill(subRequest);\n        this.pendingPrefills.push(promise);\n        promise.finally(() => {\n            const index = this.pendingPrefills.indexOf(promise);\n            if (index >= 0) this.pendingPrefills.splice(index, 1);\n        });\n        return promise;\n    }\n\n    removePrefill<List extends HSubRequest<any>[]>(...subRequest: List): Promise<void> {\n        const request = new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache);\n        return request.removePrefill(subRequest);\n    }\n\n    /** Clear all error handlers from the registry */\n    destroy(): void {\n        this.handlersRegistry.clearAll();\n    }\n}\n\nclass MethodProxy {\n    propsProxies: Record<string, MethodProxy> = {};\n    handler = {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        apply: (_target: any, _thisArg: any, argArray?: any): RSubRequest<any> & HSubRequest<any> => {\n            const handlerId = getRouterItemId(this.parentProps);\n            return new MionSubRequest(this.parentProps, handlerId, argArray, this.client);\n        },\n\n        get: (_target: any, prop: string): typeof Proxy => {\n            const existing = this.propsProxies[prop];\n            if (existing) return existing.proxy;\n            const newMethodProxy = new MethodProxy([...this.parentProps, prop], this.client, this.clientOptions);\n            this.propsProxies[prop] = newMethodProxy;\n            return newMethodProxy.proxy;\n        },\n    };\n\n    proxy: typeof Proxy;\n\n    constructor(\n        public parentProps: string[],\n        private client: MionClient,\n        private clientOptions: ClientOptions\n    ) {\n        const target = () => null;\n        this.proxy = new Proxy(target, this.handler);\n    }\n}\n"],"names":["routeSubRequest"],"mappings":"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"}

package/.dist/esm/src/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"constants.js","sources":["../../../src/constants.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 {ClientOptions} from './types.ts';\n\nexport const DEFAULT_PREFILL_OPTIONS: ClientOptions = {\n    baseURL: '',\n    fetchOptions: {\n        method: 'PUT',\n        headers: {'Content-Type': 'application/json'},\n    },\n    /** Prefix for all routes, i.e: api/v1 */\n    basePath: '',\n    /** Suffix for all routes, i.e: .json */\n    suffix: '',\n    /** Enables automatic parameter validation */\n    validateParams: true,\n    /** Set true to automatically generate and id for every error */\n    autoGenerateErrorId: false,\n    /** Default serializer mode - stringifyJson as default native serializer */\n    serializer: 'stringifyJson',\n};\n\n/** Maximum safe URL length for GET requests with ?data= query param */\nexport const MAX_GET_URL_LENGTH = 4096;\n\nexport const STORAGE_KEY = 'mionkit:client';\n\n/** RoutesFlow route key - matches router constant */\nexport const ROUTES_FLOW_KEY = 'mion-routes-flow';\n\n/** RoutesFlow route path - matches router constant */\nexport const ROUTES_FLOW_PATH = `/${ROUTES_FLOW_KEY}`;\n"],"names":[],"mappings":"AASO,MAAM,0BAAyC;AAAA,EAClD,SAAS;AAAA,EACT,cAAc;AAAA,IACV,QAAQ;AAAA,IACR,SAAS,EAAC,gBAAgB,mBAAA;AAAA,EAAkB;AAAA;AAAA,EAGhD,UAAU;AAAA;AAAA,EAEV,QAAQ;AAAA;AAAA,EAER,gBAAgB;AAAA;AAAA,EAEhB,qBAAqB;AAAA;AAAA,EAErB,YAAY;GAIH,qBAAqB,MAErB,cAAc,kBAGd,kBAAkB,oBAGlB,mBAAmB,IAAI,eAAe;"}

package/.dist/esm/src/{clientMethodsMetadata.d.ts → lib/clientMethodsMetadata.d.ts}

@@ -1,10 +1,6 @@
-import { ClientOptions } from './types.ts';
+import { ClientOptions } from '../types.ts';
 import { JitCompiledFnData, MethodsCache, PureFnsDataCache } from '@mionjs/core';
 export declare function fetchRemoteMethodsMetadata(methodIds: string[], options: ClientOptions): Promise<void>;
 export declare function storeDependencies(deps: Record<string, JitCompiledFnData>, pureFnDeps: PureFnsDataCache, options: ClientOptions): void;
 export declare function storeMethodsMetadata(methods: MethodsCache, options: ClientOptions): void;
 export declare function restoreAllDependencies(options: ClientOptions): void;
-export declare function getAOTCaches(): {
-    jitFnsCache: Record<string, any>;
-    pureFnsCache: Record<string, Record<string, any>>;
-};

package/.dist/esm/src/{clientMethodsMetadata.js → lib/clientMethodsMetadata.js}

@@ -1,16 +1,11 @@
-import { pureFnsCache, jitFnsCache } from "virtual:mion-aot/caches";
-import { MION_ROUTES, getRoutePath, isRpcError, RpcError, addSerializedJitCaches, isTestEnv, routesCache, addRoutesToCache } from "@mionjs/core";
-import { __ΩClientOptions as ___ClientOptions } from "./types.js";
-import { STORAGE_KEY } from "./constants.js";
+import { routesCache, MION_ROUTES, getRoutePath, isRpcError, RpcError, addSerializedJitCaches, isTestEnv, addRoutesToCache } from "@mionjs/core";
+import { loadAOTCaches } from "../aot/aotCaches.js";
+import { STORAGE_KEY } from "../constants.js";
 import { deserializeResponseBody } from "./serializer.js";
 import { getStorage } from "./storage.js";
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
 async function fetchRemoteMethodsMetadata(methodIds, options) {
-  validateClientCaches(), restoreFromLocalStorage(methodIds, options);
-  const missingAfterLocal = methodIds.filter(__assignType((path) => !routesCache.hasMetadata(path), ["path", "", 'P"2!"/"']));
+  loadAOTCaches(), validateClientCaches(), restoreFromLocalStorage(methodIds, options);
+  const missingAfterLocal = methodIds.filter((path) => !routesCache.hasMetadata(path));
   if (!missingAfterLocal.length)
     return;
   const shouldReturnAllMethods = !0, body = {
@@ -37,50 +32,44 @@ async function fetchRemoteMethodsMetadata(methodIds, options) {
     throw new Error(`Error fetching validation and serialization metadata: ${error?.message}`);
   }
 }
-fetchRemoteMethodsMetadata.__type = ["methodIds", () => ___ClientOptions, "options", "fetchRemoteMethodsMetadata", 'P&F2!n"2#"/$'];
 function getSerializedMethodDataKey(methodId, options) {
   return `${STORAGE_KEY}:serialized-method-data:${options.baseURL}:${methodId}`;
 }
-getSerializedMethodDataKey.__type = ["methodId", () => ___ClientOptions, "options", "getSerializedMethodDataKey", 'P&2!n"2#"/$'];
 function getJitCompiledFnKey(jitFnHash, options) {
   return `${STORAGE_KEY}:jit-compiled-fn:${options.baseURL}:${jitFnHash}`;
 }
-getJitCompiledFnKey.__type = ["jitFnHash", () => ___ClientOptions, "options", "getJitCompiledFnKey", 'P&2!n"2#"/$'];
 function getJitPureFnKey(namespace, pureFnHash, options) {
   return `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:${namespace}:${pureFnHash}`;
 }
-getJitPureFnKey.__type = ["namespace", "pureFnHash", () => ___ClientOptions, "options", "getJitPureFnKey", 'P&2!&2"n#2$"/%'];
 function storeDependencies(deps, pureFnDeps, options) {
-  Object.entries(deps).forEach(__assignType(([hash, jitFnData]) => {
+  Object.entries(deps).forEach(([hash, jitFnData]) => {
     const key = getJitCompiledFnKey(hash, options);
     try {
       getStorage().setItem(key, JSON.stringify(jitFnData));
     } catch (error) {
       console.warn(`Failed to store JIT function dependency ${hash}:`, error);
     }
-  }, ["JitCompiledFnData", "param0", "", 'PP&"w!G2""/#'])), Object.entries(pureFnDeps).forEach(__assignType(([namespace, nsPureFns]) => {
-    Object.entries(nsPureFns).forEach(__assignType(([fnHash, pureFnData]) => {
+  }), Object.entries(pureFnDeps).forEach(([namespace, nsPureFns]) => {
+    Object.entries(nsPureFns).forEach(([fnHash, pureFnData]) => {
       const key = getJitPureFnKey(namespace, fnHash, options);
       try {
         getStorage().setItem(key, JSON.stringify(pureFnData));
       } catch (error) {
         console.warn(`Failed to store pure function dependency ${namespace}::${fnHash}:`, error);
       }
-    }, ["PureFunctionData", "param0", "", 'PP&"w!G2""/#']));
-  }, ["param0", "", 'P"2!"/"']));
+    });
+  });
 }
-storeDependencies.__type = [() => __ΩRecord, "JitCompiledFnData", "deps", "PureFnsDataCache", "pureFnDeps", () => ___ClientOptions, "options", "storeDependencies", `P&"w"o!#2#"w$2%n&2'"/(`];
 function storeMethodsMetadata(methods, options) {
-  Object.entries(methods).forEach(__assignType(([methodId, methodData]) => {
+  Object.entries(methods).forEach(([methodId, methodData]) => {
     const key = getSerializedMethodDataKey(methodId, options);
     try {
       getStorage().setItem(key, JSON.stringify(methodData));
     } catch (error) {
       console.warn(`Failed to store method metadata ${methodId}:`, error);
     }
-  }, ["param0", "", 'P"2!"/"']));
+  });
 }
-storeMethodsMetadata.__type = ["MethodsCache", "methods", () => ___ClientOptions, "options", "storeMethodsMetadata", 'P"w!2"n#2$"/%'];
 function restoreAllDependencies(options) {
   const deps = {}, pureFnDeps = {}, pureFnKeyPrefix = `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:`;
   for (let i = 0; i < getStorage().length; i++) {
@@ -111,12 +100,11 @@ function restoreAllDependencies(options) {
   }
   (Object.keys(deps).length > 0 || Object.keys(pureFnDeps).length > 0) && addSerializedJitCaches(deps, pureFnDeps);
 }
-restoreAllDependencies.__type = [() => ___ClientOptions, "options", "restoreAllDependencies", 'Pn!2""/#'];
 function restoreFromLocalStorage(methodIds, options) {
   restoreAllDependencies(options);
   const methods = {};
   let anyMethodsRestored = !1;
-  methodIds.forEach(__assignType((id) => {
+  methodIds.forEach((id) => {
     if (routesCache.hasMetadata(id))
       return;
     const methodKey = getSerializedMethodDataKey(id, options), methodMetaJson = getStorage().getItem(methodKey);
@@ -127,34 +115,26 @@ function restoreFromLocalStorage(methodIds, options) {
       } catch (error) {
         console.warn(`Failed to restore method metadata for ${id}:`, error), getStorage().removeItem(methodKey);
       }
-  }, ["id", "", 'P"2!"/"'])), anyMethodsRestored && addToCaches({
+  }), anyMethodsRestored && addToCaches({
     methods,
     deps: {},
     purFnDeps: {}
   });
 }
-restoreFromLocalStorage.__type = ["methodIds", () => ___ClientOptions, "options", "restoreFromLocalStorage", 'P&F2!n"2#"/$'];
 function addToCaches(serializableMethodsData) {
   addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps), addRoutesToCache(serializableMethodsData.methods);
 }
-addToCaches.__type = ["SerializableMethodsData", "serializableMethodsData", "addToCaches", 'P"w!2""/#'];
-function getAOTCaches() {
-  return { jitFnsCache, pureFnsCache };
-}
-getAOTCaches.__type = ["getAOTCaches", 'P"/!'];
 let clientCachesValidated = !1;
 function validateClientCaches() {
   if (clientCachesValidated || isTestEnv())
     return;
   clientCachesValidated = !0;
-  const missingRoutes = Object.values(MION_ROUTES).filter(__assignType((routeId) => !routesCache.hasMetadata(routeId), ["routeId", "", 'P"2!"/"']));
+  const missingRoutes = Object.values(MION_ROUTES).filter((routeId) => !routesCache.hasMetadata(routeId));
   if (missingRoutes.length > 0)
-    throw new Error(`AOT cache not loaded: Required MION_ROUTES not found in router cache: ${missingRoutes.join(", ")}. Make sure to import '@mionjs/client/aot' or 'virtual:mion-aot/caches' before using the client.`);
+    throw new Error(`AOT cache not loaded: Required MION_ROUTES not found in router cache: ${missingRoutes.join(", ")}. Make sure the AOT caches are generated and bundled correctly.`);
 }
-validateClientCaches.__type = ["validateClientCaches", 'P"/!'];
 export {
   fetchRemoteMethodsMetadata,
-  getAOTCaches,
   restoreAllDependencies,
   storeDependencies,
   storeMethodsMetadata

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

@@ -0,0 +1 @@
+{"version":3,"file":"clientMethodsMetadata.js","sources":["../../../../src/lib/clientMethodsMetadata.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 {RpcError, isRpcError, addRoutesToCache, isTestEnv} from '@mionjs/core';\nimport {MION_ROUTES, getRoutePath} from '@mionjs/core';\nimport {loadAOTCaches} from '../aot/aotCaches.ts';\nimport {ClientOptions, RequestBody} from '../types.ts';\nimport type {\n    JitCompiledFnData,\n    MethodsCache,\n    MethodWithOptions,\n    PureFunctionData,\n    SerializableMethodsData,\n    PureFnsDataCache,\n} from '@mionjs/core';\nimport {routesCache, addSerializedJitCaches} from '@mionjs/core';\nimport {STORAGE_KEY} from '../constants.ts';\n\nimport {deserializeResponseBody} from './serializer.ts';\nimport {getStorage} from './storage.ts';\nimport type {MionRoutes} from '@mionjs/router';\n\ntype GetRemoteMethodsMetadataById = MionRoutes[typeof MION_ROUTES.methodsMetadataById]['handler'];\ntype MethodsMetadataResponse = Awaited<ReturnType<GetRemoteMethodsMetadataById>>;\ntype GlobalErrorRoute = MionRoutes[typeof MION_ROUTES.platformError]['handler'];\ntype GlobalErrorResponse = Awaited<ReturnType<GlobalErrorRoute>>;\n\n/** Manually calls mionGetRemoteMethodsInfoById to get Remote Api Metadata */\nexport async function fetchRemoteMethodsMetadata(methodIds: string[], options: ClientOptions) {\n    loadAOTCaches();\n    validateClientCaches();\n    restoreFromLocalStorage(methodIds, options);\n    const missingAfterLocal = methodIds.filter((path) => !routesCache.hasMetadata(path));\n    if (!missingAfterLocal.length) return;\n    const shouldReturnAllMethods = true;\n    const body: RequestBody = {\n        [MION_ROUTES.methodsMetadataById]: [missingAfterLocal, shouldReturnAllMethods],\n    };\n    try {\n        const path = getRoutePath([MION_ROUTES.methodsMetadataById], options);\n        const url = new URL(path, options.baseURL);\n        const response = await fetch(url, {\n            method: 'POST',\n            headers: {'Content-Type': 'application/json'},\n            body: JSON.stringify(body),\n        });\n\n        const deserialized = await deserializeResponseBody(response);\n        const platformError = deserialized[MION_ROUTES.platformError] as GlobalErrorResponse | undefined;\n        const serializableMethodsData = deserialized[MION_ROUTES.methodsMetadataById] as MethodsMetadataResponse;\n\n        if (isRpcError(platformError)) throw platformError;\n        if (isRpcError(serializableMethodsData)) throw serializableMethodsData;\n        if (!serializableMethodsData)\n            throw new RpcError({\n                type: 'cant-fetch-remote-methods-metadata',\n                publicMessage: 'Failed to fetch remote methods metadata',\n                errorData: {response},\n            });\n\n        storeDependencies(serializableMethodsData.deps, serializableMethodsData.purFnDeps, options);\n        storeMethodsMetadata(serializableMethodsData.methods, options);\n        addToCaches(serializableMethodsData);\n    } catch (error: any) {\n        throw new Error(`Error fetching validation and serialization metadata: ${error?.message}`);\n    }\n}\n\nfunction getSerializedMethodDataKey(methodId: string, options: ClientOptions) {\n    return `${STORAGE_KEY}:serialized-method-data:${options.baseURL}:${methodId}`;\n}\n\nfunction getJitCompiledFnKey(jitFnHash: string, options: ClientOptions) {\n    return `${STORAGE_KEY}:jit-compiled-fn:${options.baseURL}:${jitFnHash}`;\n}\n\nfunction getJitPureFnKey(namespace: string, pureFnHash: string, options: ClientOptions) {\n    return `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:${namespace}:${pureFnHash}`;\n}\n\n/** Stores JIT compiled functions and pure functions globally in localStorage */\nexport function storeDependencies(deps: Record<string, JitCompiledFnData>, pureFnDeps: PureFnsDataCache, options: ClientOptions) {\n    Object.entries(deps).forEach(([hash, jitFnData]: [string, JitCompiledFnData]) => {\n        const key = getJitCompiledFnKey(hash, options);\n        try {\n            getStorage().setItem(key, JSON.stringify(jitFnData));\n        } catch (error) {\n            console.warn(`Failed to store JIT function dependency ${hash}:`, error);\n        }\n    });\n\n    // Store namespaced pure functions\n    Object.entries(pureFnDeps).forEach(([namespace, nsPureFns]) => {\n        Object.entries(nsPureFns).forEach(([fnHash, pureFnData]: [string, PureFunctionData]) => {\n            const key = getJitPureFnKey(namespace, fnHash, options);\n            try {\n                getStorage().setItem(key, JSON.stringify(pureFnData));\n            } catch (error) {\n                console.warn(`Failed to store pure function dependency ${namespace}::${fnHash}:`, error);\n            }\n        });\n    });\n}\n\n/** Stores method metadata in localStorage using the new storage format */\nexport function storeMethodsMetadata(methods: MethodsCache, options: ClientOptions) {\n    Object.entries(methods).forEach(([methodId, methodData]) => {\n        const key = getSerializedMethodDataKey(methodId, options);\n        try {\n            getStorage().setItem(key, JSON.stringify(methodData));\n        } catch (error) {\n            console.warn(`Failed to store method metadata ${methodId}:`, error);\n        }\n    });\n}\n\n/** Restores all JIT compiled functions and pure functions from localStorage and deserializes them */\nexport function restoreAllDependencies(options: ClientOptions) {\n    const deps: Record<string, JitCompiledFnData> = {};\n    const pureFnDeps: PureFnsDataCache = {};\n    const pureFnKeyPrefix = `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:`;\n\n    for (let i = 0; i < getStorage().length; i++) {\n        const key = getStorage().key(i);\n        if (key?.startsWith(`${STORAGE_KEY}:jit-compiled-fn:${options.baseURL}:`)) {\n            try {\n                const data = getStorage().getItem(key);\n                if (data) {\n                    const parsedData = JSON.parse(data);\n                    deps[parsedData.jitFnHash] = parsedData;\n                }\n            } catch (error) {\n                console.warn(`Failed to restore JIT function from key ${key}:`, error);\n            }\n        }\n    }\n\n    for (let i = 0; i < getStorage().length; i++) {\n        const key = getStorage().key(i);\n        if (key?.startsWith(pureFnKeyPrefix)) {\n            try {\n                const data = getStorage().getItem(key);\n                if (data) {\n                    const parsedData = JSON.parse(data);\n                    // Extract namespace from key: \"mion:jit-pure-fn:baseURL:namespace:fnHash\"\n                    const keyParts = key.slice(pureFnKeyPrefix.length).split(':');\n                    const namespace = keyParts[0] || parsedData.namespace;\n                    if (!pureFnDeps[namespace]) pureFnDeps[namespace] = {};\n                    pureFnDeps[namespace][parsedData.fnName] = parsedData;\n                }\n            } catch (error) {\n                console.warn(`Failed to restore pure function from key ${key}:`, error);\n            }\n        }\n    }\n\n    if (Object.keys(deps).length > 0 || Object.keys(pureFnDeps).length > 0) {\n        addSerializedJitCaches(deps, pureFnDeps);\n    }\n}\n\n/** Restores method metadata from localStorage using the new storage format */\nfunction restoreFromLocalStorage(methodIds: string[], options: ClientOptions) {\n    restoreAllDependencies(options);\n\n    const methods: MethodsCache = {};\n    let anyMethodsRestored = false;\n\n    methodIds.forEach((id) => {\n        if (routesCache.hasMetadata(id)) return;\n        const methodKey = getSerializedMethodDataKey(id, options);\n        const methodMetaJson = getStorage().getItem(methodKey);\n        if (methodMetaJson) {\n            try {\n                const methodMeta: MethodWithOptions = JSON.parse(methodMetaJson);\n                methods[id] = methodMeta;\n                anyMethodsRestored = true;\n            } catch (error) {\n                console.warn(`Failed to restore method metadata for ${id}:`, error);\n                getStorage().removeItem(methodKey);\n            }\n        }\n    });\n\n    if (anyMethodsRestored) {\n        const serializableMethodsData: SerializableMethodsData = {\n            methods,\n            deps: {},\n            purFnDeps: {},\n        };\n        addToCaches(serializableMethodsData);\n    }\n}\n\nfunction addToCaches(serializableMethodsData: SerializableMethodsData) {\n    addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps);\n    addRoutesToCache(serializableMethodsData.methods);\n}\n\n/** Validates that required MION_ROUTES are loaded in the cache. Skipped in test environments. */\nlet clientCachesValidated = false;\nfunction validateClientCaches() {\n    if (clientCachesValidated || isTestEnv()) return;\n    clientCachesValidated = true;\n\n    const requiredRoutes = Object.values(MION_ROUTES);\n    const missingRoutes = requiredRoutes.filter((routeId) => !routesCache.hasMetadata(routeId));\n    if (missingRoutes.length > 0) {\n        throw new Error(\n            `AOT cache not loaded: Required MION_ROUTES not found in router cache: ${missingRoutes.join(', ')}. ` +\n                `Make sure the AOT caches are generated and bundled correctly.`\n        );\n    }\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/{handlersRegistry.d.ts → lib/handlersRegistry.d.ts}

@@ -1,5 +1,5 @@
 import { RpcError } from '@mionjs/core';
-import { ErrorHandler, SuccessHandler } from './types';
+import { ErrorHandler, SuccessHandler } from '../types.ts';
 export declare class HandlersRegistry {
     private errorHandlers;
     private successHandlers;

package/.dist/esm/src/{handlersRegistry.js → lib/handlersRegistry.js}

@@ -58,11 +58,6 @@ class HandlersRegistry {
     const handlerMap = this.errorHandlers.get(handlerId);
     return handlerMap ? Array.from(handlerMap.keys()) : [];
   }
-  static __type = ["ErrorHandler", "errorHandlers", function() {
-    return /* @__PURE__ */ new Map();
-  }, "SuccessHandler", "successHandlers", function() {
-    return /* @__PURE__ */ new Map();
-  }, "handlerId", "errorType", "handler", "register", "unregister", "hasHandler", "RpcError", "error", "executeHandler", "registerSuccess", "unregisterSuccess", "hasSuccessHandler", "result", "executeSuccessHandler", "clearHandlers", "clearAll", "getHandlerIds", "getErrorTypes", "HandlersRegistry", `&&"w!EE3";>#&"w$E3%;>&P&2'&2("w!2)$0*P&2'&2($0+P&2'&2()0,P&2'"w-2.)0/P&2'"w$2)$00P&2'$01P&2')02P&2'"23)04P&2'$05P$06P&F07P&2'&F085w9`];
 }
 export {
   HandlersRegistry

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

@@ -0,0 +1 @@
+{"version":3,"file":"handlersRegistry.js","sources":["../../../../src/lib/handlersRegistry.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 type {RpcError} from '@mionjs/core';\nimport type {ErrorHandler, SuccessHandler} from '../types.ts';\n\n/** Central registry for persistent middleFn handlers (both success and error) */\nexport class HandlersRegistry {\n    private errorHandlers: Map<string, Map<string, ErrorHandler<any>>> = new Map();\n    private successHandlers: Map<string, SuccessHandler<any>> = new Map();\n\n    /** Register an error handler for a specific handler (middleFn) and error type */\n    register(handlerId: string, errorType: string, handler: ErrorHandler<any>): void {\n        let handlerMap = this.errorHandlers.get(handlerId);\n        if (!handlerMap) {\n            handlerMap = new Map();\n            this.errorHandlers.set(handlerId, handlerMap);\n        }\n        handlerMap.set(errorType, handler);\n    }\n\n    /** Unregister an error handler for a specific handler and error type */\n    unregister(handlerId: string, errorType: string): void {\n        const handlerMap = this.errorHandlers.get(handlerId);\n        if (handlerMap) {\n            handlerMap.delete(errorType);\n            if (handlerMap.size === 0) this.errorHandlers.delete(handlerId);\n        }\n    }\n\n    /** Check if an error handler exists for a specific handler ID and error type */\n    hasHandler(handlerId: string, errorType: string): boolean {\n        const handlerMap = this.errorHandlers.get(handlerId);\n        return handlerMap?.has(errorType) ?? false;\n    }\n\n    /** Get and execute the handler for an error, if it exists */\n    executeHandler(handlerId: string, error: RpcError<string>): boolean {\n        const handlerMap = this.errorHandlers.get(handlerId);\n        if (!handlerMap) return false;\n\n        const handler = handlerMap.get(error.type);\n        if (!handler) return false;\n\n        handler(error);\n        return true;\n    }\n\n    /** Register a success handler for a specific middleFn */\n    registerSuccess(handlerId: string, handler: SuccessHandler<any>): void {\n        this.successHandlers.set(handlerId, handler);\n    }\n\n    /** Unregister a success handler for a specific middleFn */\n    unregisterSuccess(handlerId: string): void {\n        this.successHandlers.delete(handlerId);\n    }\n\n    /** Check if a success handler exists for a specific handler ID */\n    hasSuccessHandler(handlerId: string): boolean {\n        return this.successHandlers.has(handlerId);\n    }\n\n    /** Get and execute the success handler for a middleFn result, if it exists */\n    executeSuccessHandler(handlerId: string, result: any): boolean {\n        const handler = this.successHandlers.get(handlerId);\n        if (!handler) return false;\n\n        handler(result);\n        return true;\n    }\n\n    /** Clear all handlers (both error and success) for a specific handler ID */\n    clearHandlers(handlerId: string): void {\n        this.errorHandlers.delete(handlerId);\n        this.successHandlers.delete(handlerId);\n    }\n\n    /** Clear all registered handlers (both error and success) */\n    clearAll(): void {\n        this.errorHandlers.clear();\n        this.successHandlers.clear();\n    }\n\n    /** Get all registered handler IDs */\n    getHandlerIds(): string[] {\n        const errorIds = Array.from(this.errorHandlers.keys());\n        const successIds = Array.from(this.successHandlers.keys());\n        return [...new Set([...errorIds, ...successIds])];\n    }\n\n    /** Get all error types registered for a handler ID */\n    getErrorTypes(handlerId: string): string[] {\n        const handlerMap = this.errorHandlers.get(handlerId);\n        return handlerMap ? Array.from(handlerMap.keys()) : [];\n    }\n}\n"],"names":[],"mappings":"MAWa,iBAAgB;AAAA,EACjB,oCAAiE,IAAA;AAAA,EACjE,sCAAwD,IAAA;AAAA;AAAA,EAGhE,SAAS,WAAmB,WAAmB,SAA0B;AACrE,QAAI,aAAa,KAAK,cAAc,IAAI,SAAS;AACjD,IAAK,eACD,iCAAiB,IAAA,GACjB,KAAK,cAAc,IAAI,WAAW,UAAU,IAEhD,WAAW,IAAI,WAAW,OAAO;AAAA,EACrC;AAAA;AAAA,EAGA,WAAW,WAAmB,WAAiB;AAC3C,UAAM,aAAa,KAAK,cAAc,IAAI,SAAS;AACnD,IAAI,eACA,WAAW,OAAO,SAAS,GACvB,WAAW,SAAS,KAAG,KAAK,cAAc,OAAO,SAAS;AAAA,EAEtE;AAAA;AAAA,EAGA,WAAW,WAAmB,WAAiB;AAE3C,WADmB,KAAK,cAAc,IAAI,SAAS,GAChC,IAAI,SAAS,KAAK;AAAA,EACzC;AAAA;AAAA,EAGA,eAAe,WAAmB,OAAuB;AACrD,UAAM,aAAa,KAAK,cAAc,IAAI,SAAS;AACnD,QAAI,CAAC;AAAY,aAAO;AAExB,UAAM,UAAU,WAAW,IAAI,MAAM,IAAI;AACzC,WAAK,WAEL,QAAQ,KAAK,GACN,MAHc;AAAA,EAIzB;AAAA;AAAA,EAGA,gBAAgB,WAAmB,SAA4B;AAC3D,SAAK,gBAAgB,IAAI,WAAW,OAAO;AAAA,EAC/C;AAAA;AAAA,EAGA,kBAAkB,WAAiB;AAC/B,SAAK,gBAAgB,OAAO,SAAS;AAAA,EACzC;AAAA;AAAA,EAGA,kBAAkB,WAAiB;AAC/B,WAAO,KAAK,gBAAgB,IAAI,SAAS;AAAA,EAC7C;AAAA;AAAA,EAGA,sBAAsB,WAAmB,QAAW;AAChD,UAAM,UAAU,KAAK,gBAAgB,IAAI,SAAS;AAClD,WAAK,WAEL,QAAQ,MAAM,GACP,MAHc;AAAA,EAIzB;AAAA;AAAA,EAGA,cAAc,WAAiB;AAC3B,SAAK,cAAc,OAAO,SAAS,GACnC,KAAK,gBAAgB,OAAO,SAAS;AAAA,EACzC;AAAA;AAAA,EAGA,WAAQ;AACJ,SAAK,cAAc,MAAA,GACnB,KAAK,gBAAgB,MAAA;AAAA,EACzB;AAAA;AAAA,EAGA,gBAAa;AACT,UAAM,WAAW,MAAM,KAAK,KAAK,cAAc,MAAM,GAC/C,aAAa,MAAM,KAAK,KAAK,gBAAgB,MAAM;AACzD,WAAO,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAG,UAAU,GAAG,UAAU,CAAC,CAAC;AAAA,EACpD;AAAA;AAAA,EAGA,cAAc,WAAiB;AAC3B,UAAM,aAAa,KAAK,cAAc,IAAI,SAAS;AACnD,WAAO,aAAa,MAAM,KAAK,WAAW,KAAA,CAAM,IAAI,CAAA;AAAA,EACxD;AACH;"}

package/.dist/{cjs/src → esm/src/lib}/serializer.d.ts

@@ -1,5 +1,5 @@
 import { ResponseBody } from '@mionjs/router';
-import { MionClientRequest } from './request.ts';
+import { MionClientRequest } from '../request.ts';
 export type SerializedBody = string | Uint8Array;
 export type ContentType = 'application/json; charset=utf-8' | 'application/octet-stream';
 export interface SerializedRequest {
@@ -8,6 +8,3 @@ export interface SerializedRequest {
 }
 export declare function serializeRequestBody(req: MionClientRequest<any, any>): SerializedRequest;
 export declare function deserializeResponseBody(response: Response): Promise<ResponseBody>;
-export declare type __ΩSerializedBody = any[];
-export declare type __ΩContentType = any[];
-export declare type __ΩSerializedRequest = any[];