@mionjs/client 0.8.0-alpha.0 → 0.8.4

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

@@ -1,13 +1,8 @@
 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;
-}
 function initClient(options) {
   registerErrorDeserializers();
   const clientOptions = {
@@ -20,33 +15,40 @@ 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 = [];
+  globalAbortController = new AbortController();
+  get globalSignal() {
+    return this.globalAbortController.signal;
+  }
   constructor(clientOptions) {
     this.clientOptions = clientOptions;
   }
-  /** Executes a route call and returns a Result 4-tuple */
-  executeCall(routeSubRequest) {
-    return this.executeRequest(routeSubRequest, void 0, void 0);
+  /** Aborts all in-flight requests. New requests after this call work normally. */
+  abort() {
+    this.globalAbortController.abort(), this.globalAbortController = new AbortController();
   }
-  /** Executes a route call with middleFns and returns a typed result object */
-  executeCallWithMiddleFns(routeSubRequest, middleFnsRecord) {
-    return this.executeRequest(routeSubRequest, void 0, middleFnsRecord);
+  /** Composes a single AbortSignal from global, per-request, and timeout signals */
+  composeSignal(signal, timeout) {
+    const signals = [this.globalSignal];
+    signal && signals.push(signal);
+    const effectiveTimeout = timeout ?? this.clientOptions.timeout;
+    return effectiveTimeout !== void 0 && signals.push(AbortSignal.timeout(effectiveTimeout)), AbortSignal.any(signals);
   }
-  /** Executes a routesFlow call with multiple routes and optional middleFns */
-  executeCallWithWorkflow(workflowSubRequests, middleFnsRecord) {
-    return this.executeRequest(void 0, workflowSubRequests, middleFnsRecord);
+  /** Executes a route call with optional workflow routes and middleFns */
+  execute(routeSubRequest, workflowSubRequests, middleFnsRecord, signal, timeout) {
+    return this.executeRequest(routeSubRequest, workflowSubRequests, middleFnsRecord, signal, timeout);
   }
-  async executeRequest(routeSubRequest, workflowSubRequests, middleFnsRecord) {
+  async executeRequest(routeSubRequest, workflowSubRequests, middleFnsRecord, signal, timeout) {
+    const composedSignal = this.composeSignal(signal, timeout);
     this.pendingPrefills.length > 0 && await Promise.allSettled([...this.pendingPrefills]);
-    const middleFnSubRequests = middleFnsRecord ? Object.values(middleFnsRecord) : [], request = new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache, routeSubRequest, middleFnSubRequests, workflowSubRequests);
+    const middleFnSubRequests = middleFnsRecord ? Object.values(middleFnsRecord) : [], request = new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache, routeSubRequest, middleFnSubRequests, workflowSubRequests, composedSignal);
     try {
       await request.call();
       const routeIds = this.getRouteIds(routeSubRequest, workflowSubRequests), allMiddleFns = this.getAllMiddleFnsFromRequest(request, routeIds);
@@ -58,12 +60,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 +76,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 +89,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))
@@ -120,17 +122,10 @@ class MionClient {
   removePrefill(...subRequest) {
     return new MionClientRequest(this.clientOptions, this.prefilledMiddleFnsCache).removePrefill(subRequest);
   }
-  /** Clear all error handlers from the registry */
+  /** Clear all error handlers from the registry and abort in-flight requests */
   destroy() {
-    this.handlersRegistry.clearAll();
+    this.abort(), 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;
@@ -138,19 +133,17 @@ class MethodProxy {
   clientOptions;
   propsProxies = {};
   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 +151,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    ClientOptions,\n    MiddlewareSubRequest,\n    InitClientOptions,\n    RouteSubRequest,\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';\n\nexport function initClient<RM extends RemoteApi>(\n    options: InitClientOptions\n): {client: MionClient; routes: ClientRoutes<RM>; middleFns: ClientMiddleFns<RM>} {\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    private globalAbortController = new AbortController();\n    private get globalSignal(): AbortSignal {\n        return this.globalAbortController.signal;\n    }\n\n    constructor(private clientOptions: ClientOptions) {}\n\n    /** Aborts all in-flight requests. New requests after this call work normally. */\n    abort(): void {\n        this.globalAbortController.abort();\n        this.globalAbortController = new AbortController();\n    }\n\n    /** Composes a single AbortSignal from global, per-request, and timeout signals */\n    private composeSignal(signal?: AbortSignal, timeout?: number): AbortSignal {\n        const signals: AbortSignal[] = [this.globalSignal];\n        if (signal) signals.push(signal);\n        const effectiveTimeout = timeout ?? this.clientOptions.timeout;\n        if (effectiveTimeout !== undefined) signals.push(AbortSignal.timeout(effectiveTimeout));\n        return AbortSignal.any(signals);\n    }\n\n    /** Executes a route call with optional workflow routes and middleFns */\n    execute(\n        routeSubRequest?: RouteSubRequest<any>,\n        workflowSubRequests?: RouteSubRequest<any>[],\n        middleFnsRecord?: Record<string, MiddlewareSubRequest<any>>,\n        signal?: AbortSignal,\n        timeout?: number\n    ): Promise<any> {\n        return this.executeRequest(routeSubRequest, workflowSubRequests, middleFnsRecord, signal, timeout);\n    }\n\n    private async executeRequest<Routes extends RouteSubRequest<any>[], H extends Record<string, MiddlewareSubRequest<any>>>(\n        routeSubRequest: RouteSubRequest<any> | undefined,\n        workflowSubRequests: Routes | undefined,\n        middleFnsRecord: H | undefined,\n        signal?: AbortSignal,\n        timeout?: number\n    ): Promise<any> {\n        // Capture the signal before any async work so abort() during prefill await is respected\n        const composedSignal = this.composeSignal(signal, timeout);\n\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            composedSignal\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: RouteSubRequest<any> | undefined,\n        workflowSubRequests: RouteSubRequest<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(\n        request: MionClientRequest<any, any>,\n        excludedIds: Set<string>\n    ): MiddlewareSubRequest<any>[] {\n        return Object.entries(request.subRequestList)\n            .filter(([id]) => !excludedIds.has(id))\n            .map(([, subRequest]) => subRequest as MiddlewareSubRequest<any>);\n    }\n\n    /** Process all middleFn responses - call success or error handlers for each middleFn individually */\n    private processMiddleFnsResponses(middleFnSubRequests: MiddlewareSubRequest<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 RouteSubRequest<any>[], H extends Record<string, MiddlewareSubRequest<any>>>(\n        routeSubRequest: RouteSubRequest<any> | undefined,\n        workflowSubRequests: Routes | undefined,\n        middleFns: H | MiddlewareSubRequest<any>[],\n        errors: RequestErrors | undefined\n    ): 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 MiddlewareSubRequest<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 MiddlewareSubRequest<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 and abort in-flight requests */\n    destroy(): void {\n        this.abort();\n        this.handlersRegistry.clearAll();\n    }\n}\n\nclass MethodProxy {\n    propsProxies: Record<string, MethodProxy> = {};\n    handler = {\n        apply: (_target: any, _thisArg: any, argArray?: any): RouteSubRequest<any> & MiddlewareSubRequest<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.d.ts

@@ -1,6 +1,6 @@
 import { ClientOptions } from './types.ts';
 export declare const DEFAULT_PREFILL_OPTIONS: ClientOptions;
 export declare const MAX_GET_URL_LENGTH = 4096;
-export declare const STORAGE_KEY = "mionkit:client";
+export declare const STORAGE_KEY = "mion:client";
 export declare const ROUTES_FLOW_KEY = "mion-routes-flow";
 export declare const ROUTES_FLOW_PATH = "/mion-routes-flow";

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

@@ -14,7 +14,7 @@ const DEFAULT_PREFILL_OPTIONS = {
   autoGenerateErrorId: !1,
   /** Default serializer mode - stringifyJson as default native serializer */
   serializer: "stringifyJson"
-}, MAX_GET_URL_LENGTH = 4096, STORAGE_KEY = "mionkit:client", ROUTES_FLOW_KEY = "mion-routes-flow", ROUTES_FLOW_PATH = `/${ROUTES_FLOW_KEY}`;
+}, MAX_GET_URL_LENGTH = 4096, STORAGE_KEY = "mion:client", ROUTES_FLOW_KEY = "mion-routes-flow", ROUTES_FLOW_PATH = `/${ROUTES_FLOW_KEY}`;
 export {
   DEFAULT_PREFILL_OPTIONS,
   MAX_GET_URL_LENGTH,

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 = 'mion: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,eAGd,kBAAkB,oBAGlB,mBAAmB,IAAI,eAAe;"}

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

@@ -0,0 +1,10 @@
+import { MION_ROUTES, JitCompiledFnData, MethodsCache, PureFnsDataCache } from '@mionjs/core';
+import { ClientOptions, SubRequest } from '../types.ts';
+type MetadataRouteKey = typeof MION_ROUTES.methodsMetadata | typeof MION_ROUTES.methodsMetadataById;
+export declare function extractAndProcessMetadata(routeKey: MetadataRouteKey, parsedBody: any, options: ClientOptions): 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 createMetadataSubRequest(methodIds: string[]): SubRequest<any>;
+export declare function restoreFromLocalStorage(methodIds: string[], options: ClientOptions): void;
+export {};

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

@@ -0,0 +1,125 @@
+import { MION_ROUTES, isRpcError, addSerializedJitCaches, routesCache, addRoutesToCache } from "@mionjs/core";
+import { STORAGE_KEY } from "../constants.js";
+import { getStorage } from "./storage.js";
+const METHOD_DATA_PREFIX = `${STORAGE_KEY}:method-data:`, JIT_FN_PREFIX = `${STORAGE_KEY}:jit-fn:`, PURE_FN_PREFIX = `${STORAGE_KEY}:pure-fn:`;
+function extractAndProcessMetadata(routeKey, parsedBody, options) {
+  if (typeof parsedBody != "object" || !(routeKey in parsedBody))
+    return;
+  const rawMetadata = parsedBody[routeKey];
+  if (delete parsedBody[routeKey], !rawMetadata)
+    return;
+  const metadataValue = Array.isArray(rawMetadata) ? rawMetadata[1] : rawMetadata;
+  metadataValue && !isRpcError(metadataValue) && metadataValue.methods && processMethodsMetadata(metadataValue, options);
+}
+function processMethodsMetadata(serializableMethodsData, options) {
+  storeDependencies(serializableMethodsData.deps, serializableMethodsData.purFnDeps, options), storeMethodsMetadata(serializableMethodsData.methods, options), addToCaches(serializableMethodsData);
+}
+function getSerializedMethodDataKey(methodId, options) {
+  return `${METHOD_DATA_PREFIX}${methodId}:${options.baseURL}`;
+}
+function getJitCompiledFnKey(jitFnHash, options) {
+  return `${JIT_FN_PREFIX}${jitFnHash}:${options.baseURL}`;
+}
+function getJitPureFnKey(namespace, pureFnHash, options) {
+  return `${PURE_FN_PREFIX}${namespace}:${pureFnHash}:${options.baseURL}`;
+}
+function storeDependencies(deps, pureFnDeps, options) {
+  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);
+    }
+  }), 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);
+      }
+    });
+  });
+}
+function storeMethodsMetadata(methods, options) {
+  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);
+    }
+  });
+}
+function restoreAllDependencies(options) {
+  const deps = {}, pureFnDeps = {}, baseURLSuffix = `:${options.baseURL}`;
+  for (let i = 0; i < getStorage().length; i++) {
+    const key = getStorage().key(i);
+    if (key?.startsWith(JIT_FN_PREFIX) && key.endsWith(baseURLSuffix))
+      try {
+        const data = getStorage().getItem(key);
+        if (data) {
+          const parsedData = JSON.parse(data);
+          deps[parsedData.jitFnHash] = parsedData;
+        }
+      } catch (error) {
+        console.warn(`Failed to restore JIT function from key ${key}:`, error);
+      }
+  }
+  for (let i = 0; i < getStorage().length; i++) {
+    const key = getStorage().key(i);
+    if (key?.startsWith(PURE_FN_PREFIX) && key.endsWith(baseURLSuffix))
+      try {
+        const data = getStorage().getItem(key);
+        if (data) {
+          const parsedData = JSON.parse(data), namespace = key.slice(PURE_FN_PREFIX.length, key.length - baseURLSuffix.length).split(":")[0] || parsedData.namespace;
+          pureFnDeps[namespace] || (pureFnDeps[namespace] = {}), pureFnDeps[namespace][parsedData.fnName] = parsedData;
+        }
+      } catch (error) {
+        console.warn(`Failed to restore pure function from key ${key}:`, error);
+      }
+  }
+  (Object.keys(deps).length > 0 || Object.keys(pureFnDeps).length > 0) && addSerializedJitCaches(deps, pureFnDeps);
+}
+function createMetadataSubRequest(methodIds) {
+  return {
+    pointer: [MION_ROUTES.methodsMetadata],
+    id: MION_ROUTES.methodsMetadata,
+    isResolved: !1,
+    params: [methodIds]
+  };
+}
+function restoreFromLocalStorage(methodIds, options) {
+  restoreAllDependencies(options);
+  const methods = {};
+  let anyMethodsRestored = !1;
+  methodIds.forEach((id) => {
+    if (routesCache.hasMetadata(id))
+      return;
+    const methodKey = getSerializedMethodDataKey(id, options), methodMetaJson = getStorage().getItem(methodKey);
+    if (methodMetaJson)
+      try {
+        const methodMeta = JSON.parse(methodMetaJson);
+        methods[id] = methodMeta, anyMethodsRestored = !0;
+      } catch (error) {
+        console.warn(`Failed to restore method metadata for ${id}:`, error), getStorage().removeItem(methodKey);
+      }
+  }), anyMethodsRestored && addToCaches({
+    methods,
+    deps: {},
+    purFnDeps: {}
+  });
+}
+function addToCaches(serializableMethodsData) {
+  addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps), addRoutesToCache(serializableMethodsData.methods);
+}
+export {
+  createMetadataSubRequest,
+  extractAndProcessMetadata,
+  restoreAllDependencies,
+  restoreFromLocalStorage,
+  storeDependencies,
+  storeMethodsMetadata
+};
+//# sourceMappingURL=clientMethodsMetadata.js.map

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 {isRpcError, addRoutesToCache} from '@mionjs/core';\nimport {MION_ROUTES} from '@mionjs/core';\nimport {ClientOptions, SubRequest} 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';\nimport {getStorage} from './storage.ts';\n\nconst METHOD_DATA_PREFIX = `${STORAGE_KEY}:method-data:`;\nconst JIT_FN_PREFIX = `${STORAGE_KEY}:jit-fn:`;\nconst PURE_FN_PREFIX = `${STORAGE_KEY}:pure-fn:`;\n\ntype MetadataRouteKey = typeof MION_ROUTES.methodsMetadata | typeof MION_ROUTES.methodsMetadataById;\n\n/** Extracts raw metadata from a parsed response body, unwraps the JIT union discriminator, and processes it. */\nexport function extractAndProcessMetadata(routeKey: MetadataRouteKey, parsedBody: any, options: ClientOptions): void {\n    if (typeof parsedBody !== 'object' || !(routeKey in parsedBody)) return;\n    const rawMetadata = parsedBody[routeKey];\n    delete parsedBody[routeKey];\n    if (!rawMetadata) return;\n    const metadataValue = Array.isArray(rawMetadata) ? rawMetadata[1] : rawMetadata;\n    if (metadataValue && !isRpcError(metadataValue) && metadataValue.methods) {\n        processMethodsMetadata(metadataValue as SerializableMethodsData, options);\n    }\n}\n\n/** Processes metadata from an optimistic response and caches it */\nfunction processMethodsMetadata(serializableMethodsData: SerializableMethodsData, options: ClientOptions): void {\n    storeDependencies(serializableMethodsData.deps, serializableMethodsData.purFnDeps, options);\n    storeMethodsMetadata(serializableMethodsData.methods, options);\n    addToCaches(serializableMethodsData);\n}\n\nfunction getSerializedMethodDataKey(methodId: string, options: ClientOptions) {\n    return `${METHOD_DATA_PREFIX}${methodId}:${options.baseURL}`;\n}\n\nfunction getJitCompiledFnKey(jitFnHash: string, options: ClientOptions) {\n    return `${JIT_FN_PREFIX}${jitFnHash}:${options.baseURL}`;\n}\n\nfunction getJitPureFnKey(namespace: string, pureFnHash: string, options: ClientOptions) {\n    return `${PURE_FN_PREFIX}${namespace}:${pureFnHash}:${options.baseURL}`;\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 baseURLSuffix = `:${options.baseURL}`;\n\n    for (let i = 0; i < getStorage().length; i++) {\n        const key = getStorage().key(i);\n        if (key?.startsWith(JIT_FN_PREFIX) && key.endsWith(baseURLSuffix)) {\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(PURE_FN_PREFIX) && key.endsWith(baseURLSuffix)) {\n            try {\n                const data = getStorage().getItem(key);\n                if (data) {\n                    const parsedData = JSON.parse(data);\n                    // Extract namespace from key: \"mion:pure-fn:namespace:fnHash:baseURL\"\n                    const inner = key.slice(PURE_FN_PREFIX.length, key.length - baseURLSuffix.length);\n                    const namespace = inner.split(':')[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/** Creates a SubRequest for the metadata middleware to piggyback on an optimistic request */\nexport function createMetadataSubRequest(methodIds: string[]): SubRequest<any> {\n    return {\n        pointer: [MION_ROUTES.methodsMetadata],\n        id: MION_ROUTES.methodsMetadata,\n        isResolved: false,\n        params: [methodIds],\n    };\n}\n\n/** Restores method metadata from localStorage using the new storage format */\nexport function 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"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+import { ClientOptions } from '../types.ts';
+export declare function fetchRemoteMethodsMetadata(methodIds: string[], options: ClientOptions, signal?: AbortSignal): Promise<void>;

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

@@ -0,0 +1,31 @@
+import { routesCache, MION_ROUTES, getRoutePath, isRpcError } from "@mionjs/core";
+import { restoreFromLocalStorage } from "./clientMethodsMetadata.js";
+import { deserializeResponseBody } from "./serializer.js";
+async function fetchRemoteMethodsMetadata(methodIds, options, signal) {
+  restoreFromLocalStorage(methodIds, options);
+  const missingAfterLocal = methodIds.filter((path) => !routesCache.hasMetadata(path));
+  if (!missingAfterLocal.length)
+    return;
+  const body = {
+    [MION_ROUTES.methodsMetadataById]: [missingAfterLocal]
+  };
+  try {
+    const path = getRoutePath([MION_ROUTES.methodsMetadataById], options), url = new URL(path, options.baseURL), response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal
+    }), platformError = (await deserializeResponseBody(response, options))[MION_ROUTES.platformError];
+    if (isRpcError(platformError))
+      throw platformError;
+    const stillMissing = missingAfterLocal.filter((id) => !routesCache.hasMetadata(id));
+    if (stillMissing.length)
+      throw new Error(`Failed to fetch metadata for: ${stillMissing.join(", ")}`);
+  } catch (error) {
+    throw signal?.aborted ? error : new Error(`Error fetching validation and serialization metadata: ${error?.message}`);
+  }
+}
+export {
+  fetchRemoteMethodsMetadata
+};
+//# sourceMappingURL=fetchRemoteMethodsMetadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchRemoteMethodsMetadata.js","sources":["../../../../src/lib/fetchRemoteMethodsMetadata.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 {isRpcError, MION_ROUTES, getRoutePath, routesCache} from '@mionjs/core';\nimport {ClientOptions, RequestBody} from '../types.ts';\nimport {restoreFromLocalStorage} from './clientMethodsMetadata.ts';\nimport {deserializeResponseBody} from './serializer.ts';\n\n/** Manually calls mionGetRemoteMethodsInfoById to get Remote Api Metadata */\nexport async function fetchRemoteMethodsMetadata(\n    methodIds: string[],\n    options: ClientOptions,\n    signal?: AbortSignal\n): Promise<void> {\n    restoreFromLocalStorage(methodIds, options);\n    const missingAfterLocal = methodIds.filter((path) => !routesCache.hasMetadata(path));\n    if (!missingAfterLocal.length) return;\n    const body: RequestBody = {\n        [MION_ROUTES.methodsMetadataById]: [missingAfterLocal],\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            signal,\n        });\n        const deserialized = await deserializeResponseBody(response, options);\n        const platformError = deserialized[MION_ROUTES.platformError];\n        if (isRpcError(platformError)) throw platformError;\n        const stillMissing = missingAfterLocal.filter((id) => !routesCache.hasMetadata(id));\n        if (stillMissing.length) throw new Error(`Failed to fetch metadata for: ${stillMissing.join(', ')}`);\n    } catch (error: any) {\n        // Preserve abort/timeout DOMException so the caller's onError can classify it correctly\n        if (signal?.aborted) throw error;\n        throw new Error(`Error fetching validation and serialization metadata: ${error?.message}`);\n    }\n}\n"],"names":[],"mappings":";;;AAaA,eAAsB,2BAClB,WACA,SACA,QAAoB;AAEpB,0BAAwB,WAAW,OAAO;AAC1C,QAAM,oBAAoB,UAAU,OAAO,CAAC,SAAS,CAAC,YAAY,YAAY,IAAI,CAAC;AACnF,MAAI,CAAC,kBAAkB;AAAQ;AAC/B,QAAM,OAAoB;AAAA,IACtB,CAAC,YAAY,mBAAmB,GAAG,CAAC,iBAAiB;AAAA,EAAA;AAEzD,MAAI;AACA,UAAM,OAAO,aAAa,CAAC,YAAY,mBAAmB,GAAG,OAAO,GAC9D,MAAM,IAAI,IAAI,MAAM,QAAQ,OAAO,GACnC,WAAW,MAAM,MAAM,KAAK;AAAA,MAC9B,QAAQ;AAAA,MACR,SAAS,EAAC,gBAAgB,mBAAA;AAAA,MAC1B,MAAM,KAAK,UAAU,IAAI;AAAA,MACzB;AAAA,IAAA,CACH,GAEK,iBADe,MAAM,wBAAwB,UAAU,OAAO,GACjC,YAAY,aAAa;AAC5D,QAAI,WAAW,aAAa;AAAG,YAAM;AACrC,UAAM,eAAe,kBAAkB,OAAO,CAAC,OAAO,CAAC,YAAY,YAAY,EAAE,CAAC;AAClF,QAAI,aAAa;AAAQ,YAAM,IAAI,MAAM,iCAAiC,aAAa,KAAK,IAAI,CAAC,EAAE;AAAA,EACvG,SAAS,OAAY;AAEjB,UAAI,QAAQ,UAAe,QACrB,IAAI,MAAM,yDAAyD,OAAO,OAAO,EAAE;AAAA,EAC7F;AACJ;"}

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,6 @@
 import { ResponseBody } from '@mionjs/router';
-import { MionClientRequest } from './request.ts';
+import { MionClientRequest } from '../request.ts';
+import { ClientOptions } from '../types.ts';
 export type SerializedBody = string | Uint8Array;
 export type ContentType = 'application/json; charset=utf-8' | 'application/octet-stream';
 export interface SerializedRequest {
@@ -7,7 +8,4 @@ export interface SerializedRequest {
     contentType: ContentType;
 }
 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[];
+export declare function deserializeResponseBody(response: Response, options: ClientOptions): Promise<ResponseBody>;