@mionjs/client 0.8.10 → 0.13.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"clientResponse.js","names":[],"sources":["../../../../src/lib/clientResponse.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 {MION_ROUTES, ROUTER_ITEM_SEPARATOR_CHAR} from '@mionjs/core';\nimport type {RpcError} from '@mionjs/core';\nimport type {RemoteApi} from '@mionjs/router';\nimport type {ClientResponse} from '../types.ts';\n\ntype ResponseNode = Record<string, unknown>;\n\nexport function addThrownError(response: ClientResponse<RemoteApi>, error: RpcError<string>): void {\n  const thrownErrors = response[MION_ROUTES.thrownErrors];\n  if (Array.isArray(thrownErrors)) thrownErrors.push(error);\n  else response[MION_ROUTES.thrownErrors] = [error];\n}\n\nexport function hasResponseValue(response: ClientResponse<RemoteApi>, id: string): boolean {\n  const {parent, key} = findParent(response, id);\n  return !!parent && Object.hasOwn(parent, key);\n}\n\nexport function getResponseValue(response: ClientResponse<RemoteApi>, id: string): unknown {\n  const {parent, key} = findParent(response, id);\n  return parent && Object.hasOwn(parent, key) ? parent[key] : undefined;\n}\n\n/** False when the id has no safe path, so the caller keeps the value somewhere else */\nexport function setResponseValue(response: ClientResponse<RemoteApi>, id: string, value: unknown): boolean {\n  const {parent, key} = findParent(response, id, true);\n  if (parent) parent[key] = value;\n  return !!parent;\n}\n\n/** Also drops every group it leaves empty: the response never holds what the body did not */\nexport function deleteResponseValue(response: ClientResponse<RemoteApi>, id: string): void {\n  const pointer = id.split(ROUTER_ITEM_SEPARATOR_CHAR);\n  for (let depth = pointer.length; depth > 0; depth--) {\n    const {parent, key} = findParent(response, pointer.slice(0, depth).join(ROUTER_ITEM_SEPARATOR_CHAR));\n    if (!parent || !Object.hasOwn(parent, key)) return;\n    const child = parent[key];\n    if (depth < pointer.length && !(isNode(child) && !Object.keys(child).length)) return;\n    delete parent[key];\n  }\n}\n\nfunction findParent(response: ClientResponse<RemoteApi>, id: string, create = false): {parent?: ResponseNode; key: string} {\n  const pointer = id.split(ROUTER_ITEM_SEPARATOR_CHAR);\n  const key = pointer[pointer.length - 1];\n  // a response key is untrusted: `__proto__` would write the prototype, and the top-level thrown list is not a group\n  if (pointer.includes('__proto__') || pointer[0] === MION_ROUTES.thrownErrors) return {key};\n  let node: ResponseNode = response;\n  for (let i = 0; i < pointer.length - 1; i++) {\n    let next = Object.hasOwn(node, pointer[i]) ? node[pointer[i]] : undefined;\n    if (next === undefined && create) next = node[pointer[i]] = {};\n    if (!isNode(next)) return {key};\n    node = next;\n  }\n  return {parent: node, key};\n}\n\nfunction isNode(value: unknown): value is ResponseNode {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n"],"mappings":";AAcA,SAAgB,eAAe,UAAqC,OAA+B;AACjG,QAAM,eAAe,SAAS,YAAY,YAAA;AAC1C,EAAI,MAAM,QAAQ,YAAY,IAAG,aAAa,KAAK,KAAK,IACnD,SAAS,YAAY,YAAA,IAAgB,CAAC,KAAK;AAClD;AAEA,SAAgB,iBAAiB,UAAqC,IAAqB;AACzF,QAAM,EAAC,QAAQ,IAAA,IAAO,WAAW,UAAU,EAAE;AAC7C,SAAO,CAAC,CAAC,UAAU,OAAO,OAAO,QAAQ,GAAG;AAC9C;AAEA,SAAgB,iBAAiB,UAAqC,IAAqB;AACzF,QAAM,EAAC,QAAQ,IAAA,IAAO,WAAW,UAAU,EAAE;AAC7C,SAAO,UAAU,OAAO,OAAO,QAAQ,GAAG,IAAI,OAAO,GAAA,IAAO;AAC9D;AAGA,SAAgB,iBAAiB,UAAqC,IAAY,OAAyB;AACzG,QAAM,EAAC,QAAQ,IAAA,IAAO,WAAW,UAAU,IAAI,EAAI;AACnD,SAAI,WAAQ,OAAO,GAAA,IAAO,QACnB,CAAC,CAAC;AACX;AAGA,SAAgB,oBAAoB,UAAqC,IAAkB;AACzF,QAAM,UAAU,GAAG,MAAM,0BAA0B;AACnD,WAAS,QAAQ,QAAQ,QAAQ,QAAQ,GAAG,SAAS;AACnD,UAAM,EAAC,QAAQ,IAAA,IAAO,WAAW,UAAU,QAAQ,MAAM,GAAG,KAAK,EAAE,KAAK,0BAA0B,CAAC;AACnG,QAAI,CAAC,UAAU,CAAC,OAAO,OAAO,QAAQ,GAAG,EAAG;AAC5C,UAAM,QAAQ,OAAO,GAAA;AACrB,QAAI,QAAQ,QAAQ,UAAU,EAAE,OAAO,KAAK,KAAK,CAAC,OAAO,KAAK,KAAK,EAAE,QAAS;AAC9E,WAAO,OAAO,GAAA;AAAA,EAChB;AACF;AAEA,SAAS,WAAW,UAAqC,IAAY,SAAS,IAA6C;AACzH,QAAM,UAAU,GAAG,MAAM,0BAA0B,GAC7C,MAAM,QAAQ,QAAQ,SAAS,CAAA;AAErC,MAAI,QAAQ,SAAS,WAAW,KAAK,QAAQ,CAAA,MAAO,YAAY,aAAc,QAAO,EAAC,IAAG;AACzF,MAAI,OAAqB;AACzB,WAAS,IAAI,GAAG,IAAI,QAAQ,SAAS,GAAG,KAAK;AAC3C,QAAI,OAAO,OAAO,OAAO,MAAM,QAAQ,CAAA,CAAE,IAAI,KAAK,QAAQ,CAAA,CAAA,IAAM;AAEhE,QADI,SAAS,UAAa,WAAQ,OAAO,KAAK,QAAQ,CAAA,CAAA,IAAM,CAAC,IACzD,CAAC,OAAO,IAAI,EAAG,QAAO,EAAC,IAAG;AAC9B,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IAAC,QAAQ;AAAA,IAAM;AAAA,EAAG;AAC3B;AAEA,SAAS,OAAO,OAAuC;AACrD,SAAO,OAAO,SAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E"}

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

@@ -1,3 +1,3 @@
 import { ClientOptions } from '../types.ts';
-export declare function fetchRemoteMethodsMetadata(methodIds: string[], options: ClientOptions, signal?: AbortSignal): Promise<void>;
+export declare function fetchRemoteMethodsMetadata(methodIds: string[], routePointer: string[], options: ClientOptions, signal?: AbortSignal, middlewareId?: string): Promise<void>;
 //# sourceMappingURL=fetchRemoteMethodsMetadata.d.ts.map

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

@@ -1,26 +1,28 @@
-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;
+import { hasMethod } from "./methods.js";
+import { hydrateMetadataCache, installMethodRows } from "./clientMethodsMetadata.js";
+import { MION_ROUTES, RpcError, getRoutePath, getRouterItemId, isRpcError } from "@mionjs/core";
+var FETCH_METADATA_ID = "mionFetchMetadata";
+async function fetchRemoteMethodsMetadata(methodIds, routePointer, options, signal, middlewareId = FETCH_METADATA_ID) {
+  await hydrateMetadataCache(options);
+  const missingAfterLocal = methodIds.filter((path) => !hasMethod(path));
+  if (!missingAfterLocal.length) return;
   const body = {
-    [MION_ROUTES.methodsMetadataById]: [missingAfterLocal]
+    [middlewareId]: [missingAfterLocal, "only"],
+    [getRouterItemId(routePointer)]: "metadata-only"
   };
   try {
-    const path = getRoutePath([MION_ROUTES.methodsMetadataById], options), url = new URL(path, options.baseURL), response = await fetch(url, {
+    const url = new URL(getRoutePath(routePointer, options), options.baseURL), parsedBody = await (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(", ")}`);
+    })).json(), platformError = parsedBody?.[MION_ROUTES.thrownErrors]?.[MION_ROUTES.platformError];
+    if (isRpcError(platformError)) throw new RpcError(platformError);
+    const slot = parsedBody?.[middlewareId], answer = Array.isArray(slot) ? slot[1] : slot;
+    if (!isRpcError(answer) || answer.type !== "metadata-only" || !answer.errorData?.metadata) throw new Error(`the server answered no metadata; place ${middlewareId} first in its routes`);
+    installMethodRows(answer.errorData.metadata, options);
+    const stillMissing = missingAfterLocal.filter((id) => !hasMethod(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}`);
   }
@@ -28,4 +30,5 @@ async function fetchRemoteMethodsMetadata(methodIds, options, signal) {
 export {
   fetchRemoteMethodsMetadata
 };
-//# sourceMappingURL=fetchRemoteMethodsMetadata.js.map
+
+//# sourceMappingURL=fetchRemoteMethodsMetadata.js.map

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

@@ -1 +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;"}
+{"version":3,"file":"fetchRemoteMethodsMetadata.js","names":[],"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, RpcError, getRouterItemId} from '@mionjs/core';\nimport type {FetchMetadataOnlyData} from '@mionjs/core/middlewares';\nimport {ClientOptions} from '../types.ts';\nimport {hydrateMetadataCache, installMethodRows} from './clientMethodsMetadata.ts';\nimport {hasMethod} from './methods.ts';\n\n/** The key `mionFetchMetadata` sits under when placed by its own name. */\nconst FETCH_METADATA_ID = 'mionFetchMetadata';\n\n/** Sent to a route's path: the metadata middleware answers and stops the call before the route runs. */\nexport async function fetchRemoteMethodsMetadata(\n  methodIds: string[],\n  routePointer: string[],\n  options: ClientOptions,\n  signal?: AbortSignal,\n  middlewareId: string = FETCH_METADATA_ID\n): Promise<void> {\n  await hydrateMetadataCache(options);\n  const missingAfterLocal = methodIds.filter((path) => !hasMethod(path));\n  if (!missingAfterLocal.length) return;\n  const body: Record<string, unknown> = {\n    [middlewareId]: [missingAfterLocal, 'only'],\n    // not params: a server without the middleware refuses this slot instead of running the route\n    [getRouterItemId(routePointer)]: 'metadata-only',\n  };\n  try {\n    const url = new URL(getRoutePath(routePointer, options), 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    // the middleware pins the built-in parser on both wires, so its answer is plain JSON\n    const parsedBody = await response.json();\n    const platformError = parsedBody?.[MION_ROUTES.thrownErrors]?.[MION_ROUTES.platformError];\n    if (isRpcError(platformError)) throw new RpcError(platformError);\n    const slot = parsedBody?.[middlewareId];\n    // a union answer rides the `[index, value]` envelope\n    const answer = (Array.isArray(slot) ? slot[1] : slot) as RpcError<string, FetchMetadataOnlyData> | undefined;\n    if (!isRpcError(answer) || answer.type !== 'metadata-only' || !answer.errorData?.metadata)\n      throw new Error(`the server answered no metadata; place ${middlewareId} first in its routes`);\n    installMethodRows(answer.errorData.metadata, options);\n    const stillMissing = missingAfterLocal.filter((id) => !hasMethod(id));\n    if (stillMissing.length) throw new Error(`Failed to fetch metadata for: ${stillMissing.join(', ')}`);\n  } catch (error: any) {\n    // Preserve the abort/timeout DOMException so the caller's onError can classify it\n    if (signal?.aborted) throw error;\n    throw new Error(`Error fetching validation and serialization metadata: ${error?.message}`);\n  }\n}\n"],"mappings":";;;AAcA,IAAM,oBAAoB;AAG1B,eAAsB,2BACpB,WACA,cACA,SACA,QACA,eAAuB,mBACR;AACf,QAAM,qBAAqB,OAAO;AAClC,QAAM,oBAAoB,UAAU,OAAA,CAAQ,SAAS,CAAC,UAAU,IAAI,CAAC;AACrE,MAAI,CAAC,kBAAkB,OAAQ;AAC/B,QAAM,OAAgC;AAAA,KACnC,YAAA,GAAe,CAAC,mBAAmB,MAAM;AAAA,KAEzC,gBAAgB,YAAY,CAAA,GAAI;AAAA,EACnC;AACA,MAAI;AACF,UAAM,MAAM,IAAI,IAAI,aAAa,cAAc,OAAO,GAAG,QAAQ,OAAO,GAQlE,aAAa,OAAM,MAPF,MAAM,KAAK;AAAA,MAChC,QAAQ;AAAA,MACR,SAAS,EAAC,gBAAgB,mBAAkB;AAAA,MAC5C,MAAM,KAAK,UAAU,IAAI;AAAA,MACzB;AAAA,IACF,CAAC,GAEiC,KAAK,GACjC,gBAAgB,aAAa,YAAY,YAAA,IAAgB,YAAY,aAAA;AAC3E,QAAI,WAAW,aAAa,EAAG,OAAM,IAAI,SAAS,aAAa;AAC/D,UAAM,OAAO,aAAa,YAAA,GAEpB,SAAU,MAAM,QAAQ,IAAI,IAAI,KAAK,CAAA,IAAK;AAChD,QAAI,CAAC,WAAW,MAAM,KAAK,OAAO,SAAS,mBAAmB,CAAC,OAAO,WAAW,SAC/E,OAAM,IAAI,MAAM,0CAA0C,YAAA,sBAAkC;AAC9F,sBAAkB,OAAO,UAAU,UAAU,OAAO;AACpD,UAAM,eAAe,kBAAkB,OAAA,CAAQ,OAAO,CAAC,UAAU,EAAE,CAAC;AACpE,QAAI,aAAa,OAAQ,OAAM,IAAI,MAAM,iCAAiC,aAAa,KAAK,IAAI,CAAA,EAAG;AAAA,EACrG,SAAS,OAAY;AAEnB,UAAI,QAAQ,UAAe,QACrB,IAAI,MAAM,yDAAyD,OAAO,OAAA,EAAS;AAAA,EAC3F;AACF"}

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

@@ -1,16 +1,25 @@
-import { RpcError } from '@mionjs/core';
-import { ErrorHandler, SuccessHandler } from '../types.ts';
+import { ErrorHandler, RequestHandler, ResponseHandler, SubRequest } from '../types.ts';
+export interface RequestHandlerEntry {
+    handler: RequestHandler<any>;
+    createSubRequest: (params: any[]) => SubRequest<any>;
+}
 export declare class HandlersRegistry {
     private errorHandlers;
-    private successHandlers;
+    private responseHandlers;
+    private requestHandlers;
     register(handlerId: string, errorType: string, handler: ErrorHandler<any>): void;
-    unregister(handlerId: string, errorType: string): void;
+    unregister(handlerId: string, errorType: string, handler: ErrorHandler<any>): void;
     hasHandler(handlerId: string, errorType: string): boolean;
-    executeHandler(handlerId: string, error: RpcError<string>): boolean;
-    registerSuccess(handlerId: string, handler: SuccessHandler<any>): void;
-    unregisterSuccess(handlerId: string): void;
-    hasSuccessHandler(handlerId: string): boolean;
-    executeSuccessHandler(handlerId: string, result: any): boolean;
+    getErrorHandlers(handlerId: string, errorType: string): ErrorHandler<any>[];
+    registerResponse(handlerId: string, handler: ResponseHandler<any>): void;
+    unregisterResponse(handlerId: string, handler: ResponseHandler<any>): void;
+    hasResponseHandler(handlerId: string): boolean;
+    getResponseHandlers(handlerId: string): ResponseHandler<any>[];
+    registerRequest(handlerId: string, handler: RequestHandler<any>, createSubRequest: RequestHandlerEntry['createSubRequest']): void;
+    unregisterRequest(handlerId: string): void;
+    hasRequestHandler(handlerId: string): boolean;
+    getRequestHandler(handlerId: string): RequestHandlerEntry | undefined;
+    getRequestHandlerIds(): string[];
     clearHandlers(handlerId: string): void;
     clearAll(): void;
     getHandlerIds(): string[];

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

@@ -1,65 +1,80 @@
-class HandlersRegistry {
+var HandlersRegistry = class {
   errorHandlers = /* @__PURE__ */ new Map();
-  successHandlers = /* @__PURE__ */ new Map();
-  /** Register an error handler for a specific handler (middleFn) and error type */
+  responseHandlers = /* @__PURE__ */ new Map();
+  requestHandlers = /* @__PURE__ */ new Map();
   register(handlerId, errorType, handler) {
     let handlerMap = this.errorHandlers.get(handlerId);
-    handlerMap || (handlerMap = /* @__PURE__ */ new Map(), this.errorHandlers.set(handlerId, handlerMap)), handlerMap.set(errorType, handler);
+    handlerMap || (handlerMap = /* @__PURE__ */ new Map(), this.errorHandlers.set(handlerId, handlerMap));
+    const handlers = handlerMap.get(errorType);
+    handlers ? handlers.push(handler) : handlerMap.set(errorType, [handler]);
   }
-  /** Unregister an error handler for a specific handler and error type */
-  unregister(handlerId, errorType) {
-    const handlerMap = this.errorHandlers.get(handlerId);
-    handlerMap && (handlerMap.delete(errorType), handlerMap.size === 0 && this.errorHandlers.delete(handlerId));
+  unregister(handlerId, errorType, handler) {
+    const handlerMap = this.errorHandlers.get(handlerId), handlers = handlerMap?.get(errorType);
+    !handlerMap || !handlers || (removeFrom(handlers, handler), handlers.length || handlerMap.delete(errorType), handlerMap.size === 0 && this.errorHandlers.delete(handlerId));
   }
-  /** Check if an error handler exists for a specific handler ID and error type */
   hasHandler(handlerId, errorType) {
     return this.errorHandlers.get(handlerId)?.has(errorType) ?? !1;
   }
-  /** Get and execute the handler for an error, if it exists */
-  executeHandler(handlerId, error) {
-    const handlerMap = this.errorHandlers.get(handlerId);
-    if (!handlerMap)
-      return !1;
-    const handler = handlerMap.get(error.type);
-    return handler ? (handler(error), !0) : !1;
+  getErrorHandlers(handlerId, errorType) {
+    return [...this.errorHandlers.get(handlerId)?.get(errorType) ?? []];
+  }
+  registerResponse(handlerId, handler) {
+    const handlers = this.responseHandlers.get(handlerId);
+    handlers ? handlers.push(handler) : this.responseHandlers.set(handlerId, [handler]);
+  }
+  unregisterResponse(handlerId, handler) {
+    const handlers = this.responseHandlers.get(handlerId);
+    handlers && (removeFrom(handlers, handler), handlers.length || this.responseHandlers.delete(handlerId));
   }
-  /** Register a success handler for a specific middleFn */
-  registerSuccess(handlerId, handler) {
-    this.successHandlers.set(handlerId, handler);
+  hasResponseHandler(handlerId) {
+    return this.responseHandlers.has(handlerId);
   }
-  /** Unregister a success handler for a specific middleFn */
-  unregisterSuccess(handlerId) {
-    this.successHandlers.delete(handlerId);
+  getResponseHandlers(handlerId) {
+    return [...this.responseHandlers.get(handlerId) ?? []];
   }
-  /** Check if a success handler exists for a specific handler ID */
-  hasSuccessHandler(handlerId) {
-    return this.successHandlers.has(handlerId);
+  registerRequest(handlerId, handler, createSubRequest) {
+    this.requestHandlers.set(handlerId, {
+      handler,
+      createSubRequest
+    });
   }
-  /** Get and execute the success handler for a middleFn result, if it exists */
-  executeSuccessHandler(handlerId, result) {
-    const handler = this.successHandlers.get(handlerId);
-    return handler ? (handler(result), !0) : !1;
+  unregisterRequest(handlerId) {
+    this.requestHandlers.delete(handlerId);
+  }
+  hasRequestHandler(handlerId) {
+    return this.requestHandlers.has(handlerId);
+  }
+  getRequestHandler(handlerId) {
+    return this.requestHandlers.get(handlerId);
+  }
+  getRequestHandlerIds() {
+    return Array.from(this.requestHandlers.keys());
   }
-  /** Clear all handlers (both error and success) for a specific handler ID */
   clearHandlers(handlerId) {
-    this.errorHandlers.delete(handlerId), this.successHandlers.delete(handlerId);
+    this.errorHandlers.delete(handlerId), this.responseHandlers.delete(handlerId), this.requestHandlers.delete(handlerId);
   }
-  /** Clear all registered handlers (both error and success) */
   clearAll() {
-    this.errorHandlers.clear(), this.successHandlers.clear();
+    this.errorHandlers.clear(), this.responseHandlers.clear(), this.requestHandlers.clear();
   }
-  /** Get all registered handler IDs */
   getHandlerIds() {
-    const errorIds = Array.from(this.errorHandlers.keys()), successIds = Array.from(this.successHandlers.keys());
-    return [.../* @__PURE__ */ new Set([...errorIds, ...successIds])];
+    const errorIds = Array.from(this.errorHandlers.keys()), responseIds = Array.from(this.responseHandlers.keys()), requestIds = Array.from(this.requestHandlers.keys());
+    return [.../* @__PURE__ */ new Set([
+      ...errorIds,
+      ...responseIds,
+      ...requestIds
+    ])];
   }
-  /** Get all error types registered for a handler ID */
   getErrorTypes(handlerId) {
     const handlerMap = this.errorHandlers.get(handlerId);
     return handlerMap ? Array.from(handlerMap.keys()) : [];
   }
+};
+function removeFrom(handlers, handler) {
+  const index = handlers.indexOf(handler);
+  index !== -1 && handlers.splice(index, 1);
 }
 export {
   HandlersRegistry
 };
-//# sourceMappingURL=handlersRegistry.js.map
+
+//# sourceMappingURL=handlersRegistry.js.map

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

@@ -1 +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;"}
+{"version":3,"file":"handlersRegistry.js","names":[],"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 {ErrorHandler, RequestHandler, ResponseHandler, SubRequest} from '../types.ts';\n\n/** A request handler plus the middleware function that turns its params into a sub request */\nexport interface RequestHandlerEntry {\n  handler: RequestHandler<any>;\n  createSubRequest: (params: any[]) => SubRequest<any>;\n}\n\n/** Central registry for persistent middleware handlers: request, response and error */\nexport class HandlersRegistry {\n  private errorHandlers: Map<string, Map<string, ErrorHandler<any>[]>> = new Map();\n  private responseHandlers: Map<string, ResponseHandler<any>[]> = new Map();\n  private requestHandlers: Map<string, RequestHandlerEntry> = new Map();\n\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    const handlers = handlerMap.get(errorType);\n    if (handlers) handlers.push(handler);\n    else handlerMap.set(errorType, [handler]);\n  }\n\n  unregister(handlerId: string, errorType: string, handler: ErrorHandler<any>): void {\n    const handlerMap = this.errorHandlers.get(handlerId);\n    const handlers = handlerMap?.get(errorType);\n    if (!handlerMap || !handlers) return;\n    removeFrom(handlers, handler);\n    if (!handlers.length) handlerMap.delete(errorType);\n    if (handlerMap.size === 0) this.errorHandlers.delete(handlerId);\n  }\n\n  hasHandler(handlerId: string, errorType: string): boolean {\n    const handlerMap = this.errorHandlers.get(handlerId);\n    return handlerMap?.has(errorType) ?? false;\n  }\n\n  /** A copy, so a handler that adds or removes one leaves this run unchanged */\n  getErrorHandlers(handlerId: string, errorType: string): ErrorHandler<any>[] {\n    return [...(this.errorHandlers.get(handlerId)?.get(errorType) ?? [])];\n  }\n\n  registerResponse(handlerId: string, handler: ResponseHandler<any>): void {\n    const handlers = this.responseHandlers.get(handlerId);\n    if (handlers) handlers.push(handler);\n    else this.responseHandlers.set(handlerId, [handler]);\n  }\n\n  unregisterResponse(handlerId: string, handler: ResponseHandler<any>): void {\n    const handlers = this.responseHandlers.get(handlerId);\n    if (!handlers) return;\n    removeFrom(handlers, handler);\n    if (!handlers.length) this.responseHandlers.delete(handlerId);\n  }\n\n  hasResponseHandler(handlerId: string): boolean {\n    return this.responseHandlers.has(handlerId);\n  }\n\n  /** A copy, so a handler that adds or removes one leaves this run unchanged */\n  getResponseHandlers(handlerId: string): ResponseHandler<any>[] {\n    return [...(this.responseHandlers.get(handlerId) ?? [])];\n  }\n\n  registerRequest(\n    handlerId: string,\n    handler: RequestHandler<any>,\n    createSubRequest: RequestHandlerEntry['createSubRequest']\n  ): void {\n    this.requestHandlers.set(handlerId, {handler, createSubRequest});\n  }\n\n  unregisterRequest(handlerId: string): void {\n    this.requestHandlers.delete(handlerId);\n  }\n\n  hasRequestHandler(handlerId: string): boolean {\n    return this.requestHandlers.has(handlerId);\n  }\n\n  getRequestHandler(handlerId: string): RequestHandlerEntry | undefined {\n    return this.requestHandlers.get(handlerId);\n  }\n\n  getRequestHandlerIds(): string[] {\n    return Array.from(this.requestHandlers.keys());\n  }\n\n  clearHandlers(handlerId: string): void {\n    this.errorHandlers.delete(handlerId);\n    this.responseHandlers.delete(handlerId);\n    this.requestHandlers.delete(handlerId);\n  }\n\n  clearAll(): void {\n    this.errorHandlers.clear();\n    this.responseHandlers.clear();\n    this.requestHandlers.clear();\n  }\n\n  getHandlerIds(): string[] {\n    const errorIds = Array.from(this.errorHandlers.keys());\n    const responseIds = Array.from(this.responseHandlers.keys());\n    const requestIds = Array.from(this.requestHandlers.keys());\n    return [...new Set([...errorIds, ...responseIds, ...requestIds])];\n  }\n\n  getErrorTypes(handlerId: string): string[] {\n    const handlerMap = this.errorHandlers.get(handlerId);\n    return handlerMap ? Array.from(handlerMap.keys()) : [];\n  }\n}\n\n/** A handler registered twice needs two removals */\nfunction removeFrom<H>(handlers: H[], handler: H): void {\n  const index = handlers.indexOf(handler);\n  if (index !== -1) handlers.splice(index, 1);\n}\n"],"mappings":"AAgBA,IAAa,mBAAb,MAA8B;AAAA,EAC5B,gBAAuE,oBAAI,IAAI;AAAA,EAC/E,mBAAgE,oBAAI,IAAI;AAAA,EACxE,kBAA4D,oBAAI,IAAI;AAAA,EAEpE,SAAS,WAAmB,WAAmB,SAAkC;AAC/E,QAAI,aAAa,KAAK,cAAc,IAAI,SAAS;AACjD,IAAK,eACH,aAAa,oBAAI,IAAI,GACrB,KAAK,cAAc,IAAI,WAAW,UAAU;AAE9C,UAAM,WAAW,WAAW,IAAI,SAAS;AACzC,IAAI,WAAU,SAAS,KAAK,OAAO,IAC9B,WAAW,IAAI,WAAW,CAAC,OAAO,CAAC;AAAA,EAC1C;AAAA,EAEA,WAAW,WAAmB,WAAmB,SAAkC;AACjF,UAAM,aAAa,KAAK,cAAc,IAAI,SAAS,GAC7C,WAAW,YAAY,IAAI,SAAS;AAC1C,IAAI,CAAC,cAAc,CAAC,aACpB,WAAW,UAAU,OAAO,GACvB,SAAS,UAAQ,WAAW,OAAO,SAAS,GAC7C,WAAW,SAAS,KAAG,KAAK,cAAc,OAAO,SAAS;AAAA,EAChE;AAAA,EAEA,WAAW,WAAmB,WAA4B;AAExD,WADmB,KAAK,cAAc,IAAI,SACnC,GAAY,IAAI,SAAS,KAAK;AAAA,EACvC;AAAA,EAGA,iBAAiB,WAAmB,WAAwC;AAC1E,WAAO,CAAC,GAAI,KAAK,cAAc,IAAI,SAAS,GAAG,IAAI,SAAS,KAAK,CAAC,CAAE;AAAA,EACtE;AAAA,EAEA,iBAAiB,WAAmB,SAAqC;AACvE,UAAM,WAAW,KAAK,iBAAiB,IAAI,SAAS;AACpD,IAAI,WAAU,SAAS,KAAK,OAAO,IAC9B,KAAK,iBAAiB,IAAI,WAAW,CAAC,OAAO,CAAC;AAAA,EACrD;AAAA,EAEA,mBAAmB,WAAmB,SAAqC;AACzE,UAAM,WAAW,KAAK,iBAAiB,IAAI,SAAS;AACpD,IAAK,aACL,WAAW,UAAU,OAAO,GACvB,SAAS,UAAQ,KAAK,iBAAiB,OAAO,SAAS;AAAA,EAC9D;AAAA,EAEA,mBAAmB,WAA4B;AAC7C,WAAO,KAAK,iBAAiB,IAAI,SAAS;AAAA,EAC5C;AAAA,EAGA,oBAAoB,WAA2C;AAC7D,WAAO,CAAC,GAAI,KAAK,iBAAiB,IAAI,SAAS,KAAK,CAAC,CAAE;AAAA,EACzD;AAAA,EAEA,gBACE,WACA,SACA,kBACM;AACN,SAAK,gBAAgB,IAAI,WAAW;AAAA,MAAC;AAAA,MAAS;AAAA,IAAgB,CAAC;AAAA,EACjE;AAAA,EAEA,kBAAkB,WAAyB;AACzC,SAAK,gBAAgB,OAAO,SAAS;AAAA,EACvC;AAAA,EAEA,kBAAkB,WAA4B;AAC5C,WAAO,KAAK,gBAAgB,IAAI,SAAS;AAAA,EAC3C;AAAA,EAEA,kBAAkB,WAAoD;AACpE,WAAO,KAAK,gBAAgB,IAAI,SAAS;AAAA,EAC3C;AAAA,EAEA,uBAAiC;AAC/B,WAAO,MAAM,KAAK,KAAK,gBAAgB,KAAK,CAAC;AAAA,EAC/C;AAAA,EAEA,cAAc,WAAyB;AACrC,SAAK,cAAc,OAAO,SAAS,GACnC,KAAK,iBAAiB,OAAO,SAAS,GACtC,KAAK,gBAAgB,OAAO,SAAS;AAAA,EACvC;AAAA,EAEA,WAAiB;AACf,SAAK,cAAc,MAAM,GACzB,KAAK,iBAAiB,MAAM,GAC5B,KAAK,gBAAgB,MAAM;AAAA,EAC7B;AAAA,EAEA,gBAA0B;AACxB,UAAM,WAAW,MAAM,KAAK,KAAK,cAAc,KAAK,CAAC,GAC/C,cAAc,MAAM,KAAK,KAAK,iBAAiB,KAAK,CAAC,GACrD,aAAa,MAAM,KAAK,KAAK,gBAAgB,KAAK,CAAC;AACzD,WAAO,CAAC,GAAG,oBAAI,IAAI;AAAA,MAAC,GAAG;AAAA,MAAU,GAAG;AAAA,MAAa,GAAG;AAAA,IAAU,CAAC,CAAC;AAAA,EAClE;AAAA,EAEA,cAAc,WAA6B;AACzC,UAAM,aAAa,KAAK,cAAc,IAAI,SAAS;AACnD,WAAO,aAAa,MAAM,KAAK,WAAW,KAAK,CAAC,IAAI,CAAC;AAAA,EACvD;AACF;AAGA,SAAS,WAAc,UAAe,SAAkB;AACtD,QAAM,QAAQ,SAAS,QAAQ,OAAO;AACtC,EAAI,UAAU,MAAI,SAAS,OAAO,OAAO,CAAC;AAC5C"}

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

@@ -0,0 +1,7 @@
+import { HeadersSubset } from '@mionjs/core';
+import { CallContext } from '../types.ts';
+export declare function hasHeadersSubsetParam(id: string, params: any[] | undefined): boolean;
+export declare function headersToRecord(headers: HeadersInit | undefined): Record<string, string>;
+export declare function extractRequestHeaders(context: CallContext): Record<string, string>;
+export declare function reconstructHeadersSubsetFromResponse(methodId: string, responseHeaders: Headers): HeadersSubset<string, string> | undefined;
+//# sourceMappingURL=headers.d.ts.map

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

@@ -0,0 +1,47 @@
+import { getMethod } from "./methods.js";
+import { HandlerType, HeadersSubset, RpcError, trustedHeadersSubset } from "@mionjs/core";
+function hasHeadersSubsetParam(id, params) {
+  const method = getMethod(id);
+  return method ? method.type === HandlerType.headersMiddleware && !!method.headersParam : params?.[0] instanceof HeadersSubset;
+}
+function headersToRecord(headers) {
+  return headers ? typeof Headers < "u" && headers instanceof Headers ? Object.fromEntries(headers.entries()) : typeof headers[Symbol.iterator] == "function" ? Object.fromEntries(headers) : { ...headers } : {};
+}
+function extractRequestHeaders(context) {
+  const headers = {}, subRequestIds = Object.keys(context.subRequestList);
+  for (let i = 0; i < subRequestIds.length; i++) {
+    const id = subRequestIds[i], subRequest = context.subRequestList[id];
+    !subRequest || !hasHeadersSubsetParam(id, subRequest.params) || Object.assign(headers, extractHeadersFromParams(subRequest.params));
+  }
+  return headers;
+}
+function extractHeadersFromParams(params) {
+  if (!params || params.length === 0) throw new RpcError({
+    type: "missing-headers-param",
+    publicMessage: "HeadersMiddleware requires a HeadersSubset parameter."
+  });
+  const firstParam = params[0];
+  if (firstParam instanceof HeadersSubset || firstParam && typeof firstParam == "object" && "headers" in firstParam && typeof firstParam.headers == "object") return firstParam.headers;
+  throw new RpcError({
+    type: "invalid-headers-param",
+    publicMessage: "HeadersMiddleware first parameter must be a HeadersSubset instance or object with headers property."
+  });
+}
+function reconstructHeadersSubsetFromResponse(methodId, responseHeaders) {
+  const method = getMethod(methodId);
+  if (!method?.headersReturn?.headerNames || method.headersReturn.headerNames.length === 0) return;
+  const headerNames = method.headersReturn.headerNames, headersMap = {};
+  for (const name of headerNames) {
+    const value = responseHeaders.get(name);
+    value != null && (headersMap[name] = value);
+  }
+  if (Object.keys(headersMap).length > 0) return trustedHeadersSubset(headersMap);
+}
+export {
+  extractRequestHeaders,
+  hasHeadersSubsetParam,
+  headersToRecord,
+  reconstructHeadersSubsetFromResponse
+};
+
+//# sourceMappingURL=headers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headers.js","names":[],"sources":["../../../../src/lib/headers.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 {HandlerType, HeadersSubset, RpcError, trustedHeadersSubset} from '@mionjs/core';\nimport {getMethod} from './methods.ts';\nimport type {CallContext} from '../types.ts';\n\n/** True when a subrequest's first param travels as HTTP headers rather than in the body; with no\n *  cached metadata yet (a route's FIRST optimistic call) the value itself answers. */\nexport function hasHeadersSubsetParam(id: string, params: any[] | undefined): boolean {\n  const method = getMethod(id);\n  if (method) return method.type === HandlerType.headersMiddleware && !!method.headersParam;\n  return params?.[0] instanceof HeadersSubset;\n}\n\n/** Spreading a `HeadersInit` only works for the plain-object form: a `Headers` instance has no own\n * enumerable properties and the `[name, value][]` form spreads as numeric indices. Internal, never exported. */\nexport function headersToRecord(headers: HeadersInit | undefined): Record<string, string> {\n  if (!headers) return {};\n  if (typeof Headers !== 'undefined' && headers instanceof Headers) return Object.fromEntries(headers.entries());\n  // Any iterable of pairs (the `[name, value][]` form, a Map): spreading gives numeric indices, not headers.\n  if (typeof (headers as Iterable<readonly [string, string]>)[Symbol.iterator] === 'function') {\n    return Object.fromEntries(headers as Iterable<readonly [string, string]>);\n  }\n  return {...(headers as Record<string, string>)};\n}\n\nexport function extractRequestHeaders(context: CallContext): Record<string, string> {\n  const headers: Record<string, string> = {};\n  const subRequestIds = Object.keys(context.subRequestList);\n\n  for (let i = 0; i < subRequestIds.length; i++) {\n    const id = subRequestIds[i];\n    const subRequest = context.subRequestList[id];\n    if (!subRequest || !hasHeadersSubsetParam(id, subRequest.params)) continue;\n    Object.assign(headers, extractHeadersFromParams(subRequest.params));\n  }\n\n  return headers;\n}\n\nfunction extractHeadersFromParams(params: any[]): Record<string, string> {\n  if (!params || params.length === 0) {\n    throw new RpcError({\n      type: 'missing-headers-param',\n      publicMessage: 'HeadersMiddleware requires a HeadersSubset parameter.',\n    });\n  }\n\n  const firstParam = params[0];\n\n  if (firstParam instanceof HeadersSubset) {\n    return firstParam.headers as Record<string, string>;\n  }\n\n  if (firstParam && typeof firstParam === 'object' && 'headers' in firstParam && typeof firstParam.headers === 'object') {\n    return firstParam.headers as Record<string, string>;\n  }\n\n  throw new RpcError({\n    type: 'invalid-headers-param',\n    publicMessage: 'HeadersMiddleware first parameter must be a HeadersSubset instance or object with headers property.',\n  });\n}\n\nexport function reconstructHeadersSubsetFromResponse(\n  methodId: string,\n  responseHeaders: Headers\n): HeadersSubset<string, string> | undefined {\n  const method = getMethod(methodId);\n\n  if (!method?.headersReturn?.headerNames || method.headersReturn.headerNames.length === 0) {\n    return undefined;\n  }\n\n  const headerNames = method.headersReturn.headerNames;\n  const headersMap: Record<string, string> = {};\n\n  for (const name of headerNames) {\n    const value = responseHeaders.get(name);\n    if (value !== undefined && value !== null) {\n      headersMap[name] = value;\n    }\n  }\n\n  if (Object.keys(headersMap).length > 0) {\n    return trustedHeadersSubset(headersMap);\n  }\n\n  return undefined;\n}\n"],"mappings":";;AAaA,SAAgB,sBAAsB,IAAY,QAAoC;AACpF,QAAM,SAAS,UAAU,EAAE;AAC3B,SAAI,SAAe,OAAO,SAAS,YAAY,qBAAqB,CAAC,CAAC,OAAO,eACtE,SAAS,CAAA,aAAc;AAChC;AAIA,SAAgB,gBAAgB,SAA0D;AACxF,SAAK,UACD,OAAO,UAAY,OAAe,mBAAmB,UAAgB,OAAO,YAAY,QAAQ,QAAQ,CAAC,IAEzG,OAAQ,QAAgD,OAAO,QAAA,KAAc,aACxE,OAAO,YAAY,OAA8C,IAEnE,EAAC,GAAI,QAAkC,IANzB,CAAC;AAOxB;AAEA,SAAgB,sBAAsB,SAA8C;AAClF,QAAM,UAAkC,CAAC,GACnC,gBAAgB,OAAO,KAAK,QAAQ,cAAc;AAExD,WAAS,IAAI,GAAG,IAAI,cAAc,QAAQ,KAAK;AAC7C,UAAM,KAAK,cAAc,CAAA,GACnB,aAAa,QAAQ,eAAe,EAAA;AAC1C,IAAI,CAAC,cAAc,CAAC,sBAAsB,IAAI,WAAW,MAAM,KAC/D,OAAO,OAAO,SAAS,yBAAyB,WAAW,MAAM,CAAC;AAAA,EACpE;AAEA,SAAO;AACT;AAEA,SAAS,yBAAyB,QAAuC;AACvE,MAAI,CAAC,UAAU,OAAO,WAAW,EAC/B,OAAM,IAAI,SAAS;AAAA,IACjB,MAAM;AAAA,IACN,eAAe;AAAA,EACjB,CAAC;AAGH,QAAM,aAAa,OAAO,CAAA;AAM1B,MAJI,sBAAsB,iBAItB,cAAc,OAAO,cAAe,YAAY,aAAa,cAAc,OAAO,WAAW,WAAY,SAC3G,QAAO,WAAW;AAGpB,QAAM,IAAI,SAAS;AAAA,IACjB,MAAM;AAAA,IACN,eAAe;AAAA,EACjB,CAAC;AACH;AAEA,SAAgB,qCACd,UACA,iBAC2C;AAC3C,QAAM,SAAS,UAAU,QAAQ;AAEjC,MAAI,CAAC,QAAQ,eAAe,eAAe,OAAO,cAAc,YAAY,WAAW,EACrF;AAGF,QAAM,cAAc,OAAO,cAAc,aACnC,aAAqC,CAAC;AAE5C,aAAW,QAAQ,aAAa;AAC9B,UAAM,QAAQ,gBAAgB,IAAI,IAAI;AACtC,IAA2B,SAAU,SACnC,WAAW,IAAA,IAAQ;AAAA,EAEvB;AAEA,MAAI,OAAO,KAAK,UAAU,EAAE,SAAS,EACnC,QAAO,qBAAqB,UAAU;AAI1C"}

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

@@ -0,0 +1,9 @@
+import { CompiledFnData, MethodWithOptions, PureFunctionData } from '@mionjs/core';
+import { MetadataRecordKey } from './storage.ts';
+export interface CacheGraph {
+    methods: Record<string, MethodWithOptions>;
+    deps: Record<string, CompiledFnData>;
+    pureFns: Record<string, PureFunctionData>;
+}
+export declare function findOrphans(graph: CacheGraph): MetadataRecordKey[];
+//# sourceMappingURL=metadataEviction.d.ts.map

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

@@ -0,0 +1,33 @@
+import { DEFAULT_PARSER, EMPTY_HASH, getJitFnHashes } from "@mionjs/core";
+function methodRootHashes(metadata) {
+  const parser = metadata.options?.parser ?? DEFAULT_PARSER, roots = [], addSet = (jitHash, strategy) => {
+    if (!(!jitHash || jitHash === EMPTY_HASH))
+      for (const hash of Object.values(getJitFnHashes(jitHash, strategy))) typeof hash == "string" && roots.push(hash);
+  };
+  return addSet(metadata.paramsJitHash, parser.params), addSet(metadata.returnJitHash, parser.return), metadata.headersParam && addSet(metadata.headersParam.jitHash, "mutate"), metadata.headersReturn && addSet(metadata.headersReturn.jitHash, "mutate"), roots;
+}
+function findOrphans(graph) {
+  const reachedDeps = /* @__PURE__ */ new Set(), reachedPureFns = /* @__PURE__ */ new Set(), pending = [];
+  for (const metadata of Object.values(graph.methods)) for (const hash of methodRootHashes(metadata)) graph.deps[hash] && !reachedDeps.has(hash) && (reachedDeps.add(hash), pending.push(hash));
+  const reachPureFn = (key) => {
+    if (!reachedPureFns.has(key)) {
+      reachedPureFns.add(key);
+      for (const nested of graph.pureFns[key]?.pureFnDependencies ?? []) reachPureFn(nested);
+    }
+  };
+  for (; pending.length; ) {
+    const entry = graph.deps[pending.pop()];
+    for (const hash of entry?.rtDependencies ?? [])
+      !graph.deps[hash] || reachedDeps.has(hash) || (reachedDeps.add(hash), pending.push(hash));
+    for (const key of entry?.pureFnDependencies ?? []) reachPureFn(key);
+  }
+  const orphans = [];
+  for (const hash of Object.keys(graph.deps)) reachedDeps.has(hash) || orphans.push(["j", hash]);
+  for (const key of Object.keys(graph.pureFns)) reachedPureFns.has(key) || orphans.push(["p", key]);
+  return orphans;
+}
+export {
+  findOrphans
+};
+
+//# sourceMappingURL=metadataEviction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadataEviction.js","names":[],"sources":["../../../../src/lib/metadataEviction.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 {DEFAULT_PARSER, EMPTY_HASH, getJitFnHashes} from '@mionjs/core';\nimport type {CompiledFnData, MethodWithOptions, PureFunctionData} from '@mionjs/core';\nimport type {MetadataRecordKey} from './storage.ts';\n\n/** The stored cache as one graph: methods point at compiled functions by hash, and those point at\n *  each other. Everything already parsed by the hydrator, so the sweep costs no extra reads. */\nexport interface CacheGraph {\n  /** by methodId */\n  methods: Record<string, MethodWithOptions>;\n  /** by compiled function hash */\n  deps: Record<string, CompiledFnData>;\n  /** by `${namespace}::${fnName}` */\n  pureFns: Record<string, PureFunctionData>;\n}\n\n/** Every compiled function hash the method itself names, across both wires and both header sets. */\nfunction methodRootHashes(metadata: MethodWithOptions): string[] {\n  const parser = metadata.options?.parser ?? DEFAULT_PARSER;\n  const roots: string[] = [];\n  // a root is anything the method COULD reach; a hash it never uses is simply absent from the store\n  const addSet = (jitHash: string, strategy: Parameters<typeof getJitFnHashes>[1]) => {\n    if (!jitHash || jitHash === EMPTY_HASH) return;\n    // the optional hashes are absent on the returned shape, so only the real strings become roots\n    for (const hash of Object.values(getJitFnHashes(jitHash, strategy)) as (string | undefined)[]) {\n      if (typeof hash === 'string') roots.push(hash);\n    }\n  };\n  addSet(metadata.paramsJitHash, parser.params);\n  addSet(metadata.returnJitHash, parser.return);\n  if (metadata.headersParam) addSet(metadata.headersParam.jitHash, 'mutate');\n  if (metadata.headersReturn) addSet(metadata.headersReturn.jitHash, 'mutate');\n  return roots;\n}\n\n/** The compiled functions no stored method can reach any more. Hashes are content addresses, so an entry is\n *  never stale, only unreachable: a deploy rewrites a method's row and leaves the old hashes behind. */\nexport function findOrphans(graph: CacheGraph): MetadataRecordKey[] {\n  const reachedDeps = new Set<string>();\n  const reachedPureFns = new Set<string>();\n  const pending: string[] = [];\n\n  for (const metadata of Object.values(graph.methods)) {\n    for (const hash of methodRootHashes(metadata)) {\n      if (graph.deps[hash] && !reachedDeps.has(hash)) {\n        reachedDeps.add(hash);\n        pending.push(hash);\n      }\n    }\n  }\n\n  const reachPureFn = (key: string) => {\n    if (reachedPureFns.has(key)) return;\n    reachedPureFns.add(key);\n    for (const nested of graph.pureFns[key]?.pureFnDependencies ?? []) reachPureFn(nested);\n  };\n\n  while (pending.length) {\n    const entry = graph.deps[pending.pop() as string];\n    for (const hash of entry?.rtDependencies ?? []) {\n      if (!graph.deps[hash] || reachedDeps.has(hash)) continue;\n      reachedDeps.add(hash);\n      pending.push(hash);\n    }\n    for (const key of entry?.pureFnDependencies ?? []) reachPureFn(key);\n  }\n\n  const orphans: MetadataRecordKey[] = [];\n  for (const hash of Object.keys(graph.deps)) if (!reachedDeps.has(hash)) orphans.push(['j', hash]);\n  for (const key of Object.keys(graph.pureFns)) if (!reachedPureFns.has(key)) orphans.push(['p', key]);\n  return orphans;\n}\n"],"mappings":";AAuBA,SAAS,iBAAiB,UAAuC;AAC/D,QAAM,SAAS,SAAS,SAAS,UAAU,gBACrC,QAAkB,CAAC,GAEnB,SAAA,CAAU,SAAiB,aAAmD;AAClF,QAAI,GAAC,WAAW,YAAY;AAE5B,iBAAW,QAAQ,OAAO,OAAO,eAAe,SAAS,QAAQ,CAAC,EAChE,CAAI,OAAO,QAAS,YAAU,MAAM,KAAK,IAAI;AAAA,EAEjD;AACA,gBAAO,SAAS,eAAe,OAAO,MAAM,GAC5C,OAAO,SAAS,eAAe,OAAO,MAAM,GACxC,SAAS,gBAAc,OAAO,SAAS,aAAa,SAAS,QAAQ,GACrE,SAAS,iBAAe,OAAO,SAAS,cAAc,SAAS,QAAQ,GACpE;AACT;AAIA,SAAgB,YAAY,OAAwC;AAClE,QAAM,cAAc,oBAAI,IAAY,GAC9B,iBAAiB,oBAAI,IAAY,GACjC,UAAoB,CAAC;AAE3B,aAAW,YAAY,OAAO,OAAO,MAAM,OAAO,EAChD,YAAW,QAAQ,iBAAiB,QAAQ,EAC1C,CAAI,MAAM,KAAK,IAAA,KAAS,CAAC,YAAY,IAAI,IAAI,MAC3C,YAAY,IAAI,IAAI,GACpB,QAAQ,KAAK,IAAI;AAKvB,QAAM,cAAA,CAAe,QAAgB;AACnC,QAAI,gBAAe,IAAI,GAAG,GAC1B;AAAA,qBAAe,IAAI,GAAG;AACtB,iBAAW,UAAU,MAAM,QAAQ,GAAA,GAAM,sBAAsB,CAAC,EAAG,aAAY,MAAM;AAAA;AAAA,EACvF;AAEA,SAAO,QAAQ,UAAQ;AACrB,UAAM,QAAQ,MAAM,KAAK,QAAQ,IAAI,CAAA;AACrC,eAAW,QAAQ,OAAO,kBAAkB,CAAC;AAC3C,MAAI,CAAC,MAAM,KAAK,IAAA,KAAS,YAAY,IAAI,IAAI,MAC7C,YAAY,IAAI,IAAI,GACpB,QAAQ,KAAK,IAAI;AAEnB,eAAW,OAAO,OAAO,sBAAsB,CAAC,EAAG,aAAY,GAAG;AAAA,EACpE;AAEA,QAAM,UAA+B,CAAC;AACtC,aAAW,QAAQ,OAAO,KAAK,MAAM,IAAI,EAAG,CAAK,YAAY,IAAI,IAAI,KAAG,QAAQ,KAAK,CAAC,KAAK,IAAI,CAAC;AAChG,aAAW,OAAO,OAAO,KAAK,MAAM,OAAO,EAAG,CAAK,eAAe,IAAI,GAAG,KAAG,QAAQ,KAAK,CAAC,KAAK,GAAG,CAAC;AACnG,SAAO;AACT"}

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

@@ -0,0 +1,29 @@
+import { RpcError } from '@mionjs/core';
+import { ClientCallContext, ClientOptions, RequestErrors } from '../types.ts';
+import { HandlersRegistry } from './handlersRegistry.ts';
+export interface MetadataFetcher {
+    fetchRows(ids: string[], routePointer: string[], options: ClientOptions, signal?: AbortSignal): Promise<void>;
+    startCall(context: ClientCallContext): MetadataCall;
+}
+export interface MetadataCall {
+    readonly id: string;
+    prepare(skipOptimistic: boolean): Promise<{
+        ids: string[];
+        optimistic: boolean;
+    }>;
+    askRows(): void;
+    fetchRows(ids: string[], signal?: AbortSignal): Promise<void>;
+    readRows(parsedBody: Record<string, unknown>): Record<string, RpcError<string>> | undefined;
+    shouldResend(errors: RequestErrors): Promise<boolean>;
+    takeError(): RpcError<string> | undefined;
+}
+export declare const MIDDLEWARE_TARGET: unique symbol;
+export interface MiddlewareTarget {
+    id: string;
+    registry: HandlersRegistry;
+}
+export declare function middlewareTargetOf(middleware: object): MiddlewareTarget;
+export declare function setMetadataFetcher(registry: HandlersRegistry, fetcher: MetadataFetcher): void;
+export declare function getMetadataFetcher(registry: HandlersRegistry | undefined): MetadataFetcher | undefined;
+export declare function metadataFetcherOf(middleware: object): MetadataFetcher | undefined;
+//# sourceMappingURL=metadataFetcher.d.ts.map

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

@@ -0,0 +1,24 @@
+var MIDDLEWARE_TARGET = /* @__PURE__ */ Symbol("mion.middlewareTarget"), fetchers = /* @__PURE__ */ new WeakMap(), readTarget = (middleware) => middleware[MIDDLEWARE_TARGET];
+function middlewareTargetOf(middleware) {
+  const target = readTarget(middleware);
+  if (!target) throw new Error("Expected a middleware from the client, like middlewares.mionFetchMetadata");
+  return target;
+}
+function setMetadataFetcher(registry, fetcher) {
+  fetchers.set(registry, fetcher);
+}
+function getMetadataFetcher(registry) {
+  return registry && fetchers.get(registry);
+}
+function metadataFetcherOf(middleware) {
+  return getMetadataFetcher(readTarget(middleware)?.registry);
+}
+export {
+  MIDDLEWARE_TARGET,
+  getMetadataFetcher,
+  metadataFetcherOf,
+  middlewareTargetOf,
+  setMetadataFetcher
+};
+
+//# sourceMappingURL=metadataFetcher.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadataFetcher.js","names":[],"sources":["../../../../src/lib/metadataFetcher.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\n// Internal hooks between the dispatch and `useFetchMetadata`. Never exported from the package: the public\n// middleware type stays hooks only, and a client that never sets metadata fetching up ships none of it.\n\nimport type {RpcError} from '@mionjs/core';\nimport type {ClientCallContext, ClientOptions, RequestErrors} from '../types.ts';\nimport type {HandlersRegistry} from './handlersRegistry.ts';\n\n/** What `useFetchMetadata` hands the dispatch, once per client. */\nexport interface MetadataFetcher {\n  /** Rows for the given ids without running any route; route sync refetches through it. */\n  fetchRows(ids: string[], routePointer: string[], options: ClientOptions, signal?: AbortSignal): Promise<void>;\n  startCall(context: ClientCallContext): MetadataCall;\n}\n\n/** One call's metadata state, driven by the dispatch attempt by attempt. */\nexport interface MetadataCall {\n  /** the metadata middleware's id: the rows a call asks for ride the request under it */\n  readonly id: string;\n  /** Before the chain is read. `ids` omits its own entry; `optimistic`: sent before rows are known, in plain wire forms. */\n  prepare(skipOptimistic: boolean): Promise<{ids: string[]; optimistic: boolean}>;\n  /** Optimistic attempt: asks the server for the rows of every id in the call. */\n  askRows(): void;\n  /** Rows for the given ids without running any route: `typeErrors()`, a body that cannot go out plain. */\n  fetchRows(ids: string[], signal?: AbortSignal): Promise<void>;\n  /** Takes this call's rows out of the raw body before anything is decoded; returns a refusal to put back. */\n  readRows(parsedBody: Record<string, unknown>): Record<string, RpcError<string>> | undefined;\n  /** After a failed attempt: true when a resend with fresh rows can fix it. Called at most once per call. */\n  shouldResend(errors: RequestErrors): Promise<boolean>;\n  /** a store write the browser refused, reported once in a later call's @thrownErrors */\n  takeError(): RpcError<string> | undefined;\n}\n\n/** A middleware's client and id, read off `middlewares.<name>` through a key no public type names. */\nexport const MIDDLEWARE_TARGET = Symbol('mion.middlewareTarget');\n\nexport interface MiddlewareTarget {\n  id: string;\n  registry: HandlersRegistry;\n}\n\nconst fetchers = new WeakMap<HandlersRegistry, MetadataFetcher>();\n\nconst readTarget = (middleware: object) => (middleware as {[MIDDLEWARE_TARGET]?: MiddlewareTarget})[MIDDLEWARE_TARGET];\n\nexport function middlewareTargetOf(middleware: object): MiddlewareTarget {\n  const target = readTarget(middleware);\n  if (!target) throw new Error('Expected a middleware from the client, like middlewares.mionFetchMetadata');\n  return target;\n}\n\nexport function setMetadataFetcher(registry: HandlersRegistry, fetcher: MetadataFetcher): void {\n  fetchers.set(registry, fetcher);\n}\n\nexport function getMetadataFetcher(registry: HandlersRegistry | undefined): MetadataFetcher | undefined {\n  return registry && fetchers.get(registry);\n}\n\n/** The fetcher of the client a middleware belongs to, if it set one up; route sync refetches through it. */\nexport function metadataFetcherOf(middleware: object): MetadataFetcher | undefined {\n  return getMetadataFetcher(readTarget(middleware)?.registry);\n}\n"],"mappings":"AAwCA,IAAa,oBAAoB,uBAAO,uBAAuB,GAOzD,WAAW,oBAAI,QAA2C,GAE1D,aAAA,CAAc,eAAwB,WAAwD,iBAAA;AAEpG,SAAgB,mBAAmB,YAAsC;AACvE,QAAM,SAAS,WAAW,UAAU;AACpC,MAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,2EAA2E;AACxG,SAAO;AACT;AAEA,SAAgB,mBAAmB,UAA4B,SAAgC;AAC7F,WAAS,IAAI,UAAU,OAAO;AAChC;AAEA,SAAgB,mBAAmB,UAAqE;AACtG,SAAO,YAAY,SAAS,IAAI,QAAQ;AAC1C;AAGA,SAAgB,kBAAkB,YAAiD;AACjF,SAAO,mBAAmB,WAAW,UAAU,GAAG,QAAQ;AAC5D"}

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

@@ -0,0 +1,4 @@
+export { forgetFetchedMetadata, hydrateMetadataCache, installMethodRows, purgeHydratedMetadata, takeMetadataCacheError, wasHydratedFromCache, } from './clientMethodsMetadata.ts';
+export { fetchRemoteMethodsMetadata } from './fetchRemoteMethodsMetadata.ts';
+export { unverifiedIds, verifyMethodRows } from './apiVersionRecovery.ts';
+//# sourceMappingURL=metadataFromServer.d.ts.map

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

@@ -0,0 +1,15 @@
+import { forgetFetchedMetadata, hydrateMetadataCache, installMethodRows, purgeHydratedMetadata, takeMetadataCacheError, wasHydratedFromCache } from "./clientMethodsMetadata.js";
+import { fetchRemoteMethodsMetadata } from "./fetchRemoteMethodsMetadata.js";
+import { unverifiedIds, verifyMethodRows } from "./apiVersionRecovery.js";
+import "@mionjs/run-types/formats";
+export {
+  fetchRemoteMethodsMetadata,
+  forgetFetchedMetadata,
+  hydrateMetadataCache,
+  installMethodRows,
+  purgeHydratedMetadata,
+  takeMetadataCacheError,
+  unverifiedIds,
+  verifyMethodRows,
+  wasHydratedFromCache
+};

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

@@ -0,0 +1,6 @@
+type MetadataFromServer = typeof import('./metadataFromServer.ts');
+export declare function loadMetadataFromServer(): Promise<MetadataFromServer>;
+export declare function loadedMetadataFromServer(): MetadataFromServer | undefined;
+export declare function resetMetadataFromServer(): void;
+export {};
+//# sourceMappingURL=metadataFromServerLoader.d.ts.map

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

@@ -0,0 +1,27 @@
+import { RpcError } from "@mionjs/core";
+var laneModule, loading;
+function loadMetadataFromServer() {
+  return laneModule ? Promise.resolve(laneModule) : (loading ??= import("#metadata-from-server").then((loaded) => (laneModule = loaded, loaded)).catch((error) => {
+    throw loading = void 0, laneLoadError(error);
+  }), loading);
+}
+function loadedMetadataFromServer() {
+  return laneModule;
+}
+function resetMetadataFromServer() {
+  laneModule = void 0, loading = void 0;
+}
+function laneLoadError(error) {
+  return new RpcError({
+    type: "metadata-load-error",
+    publicMessage: "Could not load the code that asks the server how a route works. Build with client routes bundled to ship every route the client calls, or check that the app can load its own chunks.",
+    originalError: error instanceof Error ? error : void 0
+  });
+}
+export {
+  loadMetadataFromServer,
+  loadedMetadataFromServer,
+  resetMetadataFromServer
+};
+
+//# sourceMappingURL=metadataFromServerLoader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadataFromServerLoader.js","names":[],"sources":["../../../../src/lib/metadataFromServerLoader.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 {RpcError} from '@mionjs/core';\n\n// Reaches the lane through `#metadata-from-server`, an @mionjs/client `imports` entry no consumer alias can collide with.\n\ntype MetadataFromServer = typeof import('./metadataFromServer.ts');\n\nlet laneModule: MetadataFromServer | undefined;\nlet loading: Promise<MetadataFromServer> | undefined;\n\n/** Awaited inside the request's own try, so a failed load reaches @thrownErrors; it is forgotten for a retry. */\nexport function loadMetadataFromServer(): Promise<MetadataFromServer> {\n  if (laneModule) return Promise.resolve(laneModule);\n  loading ??= (import('#metadata-from-server') as Promise<MetadataFromServer>)\n    .then((loaded) => {\n      laneModule = loaded;\n      return loaded;\n    })\n    .catch((error) => {\n      loading = undefined;\n      throw laneLoadError(error);\n    });\n  return loading;\n}\n\n/** The lane if a call already loaded it, never loading it. */\nexport function loadedMetadataFromServer(): MetadataFromServer | undefined {\n  return laneModule;\n}\n\n/** Forgets the loaded lane. Tests only: simulates a process that never reached it. */\nexport function resetMetadataFromServer(): void {\n  laneModule = undefined;\n  loading = undefined;\n}\n\nfunction laneLoadError(error: unknown): RpcError<'metadata-load-error'> {\n  return new RpcError({\n    type: 'metadata-load-error',\n    publicMessage:\n      'Could not load the code that asks the server how a route works. Build with client routes bundled to ship every route the client calls, or check that the app can load its own chunks.',\n    originalError: error instanceof Error ? error : undefined,\n  });\n}\n"],"mappings":";AAaA,IAAI,YACA;AAGJ,SAAgB,yBAAsD;AACpE,SAAI,aAAmB,QAAQ,QAAQ,UAAU,KACjD,YAAa,OAAO,uBAAA,EACjB,KAAA,CAAM,YACL,aAAa,QACN,OACR,EACA,MAAA,CAAO,UAAU;AAChB,oBAAU,QACJ,cAAc,KAAK;AAAA,EAC3B,CAAC,GACI;AACT;AAGA,SAAgB,2BAA2D;AACzE,SAAO;AACT;AAGA,SAAgB,0BAAgC;AAC9C,eAAa,QACb,UAAU;AACZ;AAEA,SAAS,cAAc,OAAiD;AACtE,SAAO,IAAI,SAAS;AAAA,IAClB,MAAM;AAAA,IACN,eACE;AAAA,IACF,eAAe,iBAAiB,QAAQ,QAAQ;AAAA,EAClD,CAAC;AACH"}

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

@@ -0,0 +1,23 @@
+import { MetadataRecord, MetadataRecordKey, MetadataStore, StorageEngine } from './storage.ts';
+export declare class MemoryMetadataStore implements MetadataStore {
+    readonly kind: "memory";
+    private readonly records;
+    readAll(baseURL: string): Promise<MetadataRecord[]>;
+    write(records: MetadataRecord[]): Promise<void>;
+    remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void>;
+    clear(baseURL?: string): Promise<void>;
+}
+export declare class IdbMetadataStore implements MetadataStore {
+    private readonly db;
+    readonly kind: "indexeddb";
+    constructor(db: IDBDatabase);
+    readAll(baseURL: string): Promise<MetadataRecord[]>;
+    write(records: MetadataRecord[]): Promise<void>;
+    remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void>;
+    clear(baseURL?: string): Promise<void>;
+    private transact;
+}
+export declare function getMetadataStore(engine?: StorageEngine): Promise<MetadataStore>;
+export declare function setMetadataStoreForTesting(store: MetadataStore): void;
+export declare function resetMetadataStore(): Promise<void>;
+//# sourceMappingURL=metadataStore.d.ts.map