@mionjs/client 0.8.10 → 0.13.0

package/.dist/cjs/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

package/.dist/cjs/src/lib/methods.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var bundledMethods=new Map,fetchedMethods;function hasMethod(id){return bundledMethods.has(id)||fetchedMethods?.hasMetadata(id)===!0}function getMethod(id){return bundledMethods.get(id)??fetchedMethods?.getMetadata(id)}function useMethodFns(id){const bundled=bundledMethods.get(id);if(bundled)return bundled;const fetched=fetchedMethods?.useMethodJitFns(id);if(!fetched)throw new Error(`Metadata for remote method ${id} not found`);return fetched}function setBundledMethod(id,entry){bundledMethods.set(id,entry)}function isBundledMethod(id){return bundledMethods.has(id)}function bundledMethodIds(){return[...bundledMethods.keys()]}function setFetchedMethods(methods){fetchedMethods=methods}function resetBundledMethods(){bundledMethods.clear()}exports.bundledMethodIds=bundledMethodIds;exports.getMethod=getMethod;exports.hasMethod=hasMethod;exports.isBundledMethod=isBundledMethod;exports.resetBundledMethods=resetBundledMethods;exports.setBundledMethod=setBundledMethod;exports.setFetchedMethods=setFetchedMethods;exports.useMethodFns=useMethodFns;
+
+//# sourceMappingURL=methods.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"methods.cjs","names":[],"sources":["../../../../src/lib/methods.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 type {MethodWithOptions, MethodWithOptsAndJitFns} from '@mionjs/core';\n\n// The only method table the request path knows: the bundle's own rows, and the fetched lane's\n// (core's routesCache) once that lane loads. Keeping them apart leaves the routes cache out of a\n// bundled build, and stops a fetched or restored row ever landing on an id the build compiled.\n\n/** What the fetched lane answers with; `routesCache` implements it as-is. */\nexport interface FetchedMethods {\n  hasMetadata(id: string): boolean;\n  getMetadata(id: string): MethodWithOptions | undefined;\n  useMethodJitFns(id: string): MethodWithOptsAndJitFns;\n}\n\nconst bundledMethods = new Map<string, MethodWithOptsAndJitFns>();\nlet fetchedMethods: FetchedMethods | undefined;\n\nexport function hasMethod(id: string): boolean {\n  return bundledMethods.has(id) || fetchedMethods?.hasMetadata(id) === true;\n}\n\nexport function getMethod(id: string): MethodWithOptions | undefined {\n  return bundledMethods.get(id) ?? fetchedMethods?.getMetadata(id);\n}\n\n/** Row plus compiled functions; throws when neither shelf holds it, as `routesCache.useMethodJitFns` does. */\nexport function useMethodFns(id: string): MethodWithOptsAndJitFns {\n  const bundled = bundledMethods.get(id);\n  if (bundled) return bundled;\n  const fetched = fetchedMethods?.useMethodJitFns(id);\n  if (!fetched) throw new Error(`Metadata for remote method ${id} not found`);\n  return fetched;\n}\n\n/** Puts a build-compiled method on the bundled shelf. Only `registerBundledApi` calls this. */\nexport function setBundledMethod(id: string, entry: MethodWithOptsAndJitFns): void {\n  bundledMethods.set(id, entry);\n}\n\nexport function isBundledMethod(id: string): boolean {\n  return bundledMethods.has(id);\n}\n\n/** Every id the bundle carries: what the version-mismatch lane offers the server, and what tests read. */\nexport function bundledMethodIds(): string[] {\n  return [...bundledMethods.keys()];\n}\n\n/** Hands the fetched lane's table over, once, as that lane loads. */\nexport function setFetchedMethods(methods: FetchedMethods): void {\n  fetchedMethods = methods;\n}\n\n/** Empties the bundled shelf. Tests only: the fetched shelf stays wired, the lane module evaluates once. */\nexport function resetBundledMethods(): void {\n  bundledMethods.clear();\n}\n"],"mappings":"mEAoBA,IAAM,eAAiB,IAAI,IACvB,eAEJ,SAAgB,UAAU,GAAqB,CAC7C,OAAO,eAAe,IAAI,EAAE,GAAK,gBAAgB,YAAY,EAAE,IAAM,EACvE,CAEA,SAAgB,UAAU,GAA2C,CACnE,OAAO,eAAe,IAAI,EAAE,GAAK,gBAAgB,YAAY,EAAE,CACjE,CAGA,SAAgB,aAAa,GAAqC,CAChE,MAAM,QAAU,eAAe,IAAI,EAAE,EACrC,GAAI,QAAS,OAAO,QACpB,MAAM,QAAU,gBAAgB,gBAAgB,EAAE,EAClD,GAAI,CAAC,QAAS,MAAM,IAAI,MAAM,8BAA8B,EAAA,YAAc,EAC1E,OAAO,OACT,CAGA,SAAgB,iBAAiB,GAAY,MAAsC,CACjF,eAAe,IAAI,GAAI,KAAK,CAC9B,CAEA,SAAgB,gBAAgB,GAAqB,CACnD,OAAO,eAAe,IAAI,EAAE,CAC9B,CAGA,SAAgB,kBAA6B,CAC3C,MAAO,CAAC,GAAG,eAAe,KAAK,CAAC,CAClC,CAGA,SAAgB,kBAAkB,QAA+B,CAC/D,eAAiB,OACnB,CAGA,SAAgB,qBAA4B,CAC1C,eAAe,MAAM,CACvB"}

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

@@ -0,0 +1,15 @@
+import { MethodWithOptions, MethodWithOptsAndJitFns } from '@mionjs/core';
+export interface FetchedMethods {
+    hasMetadata(id: string): boolean;
+    getMetadata(id: string): MethodWithOptions | undefined;
+    useMethodJitFns(id: string): MethodWithOptsAndJitFns;
+}
+export declare function hasMethod(id: string): boolean;
+export declare function getMethod(id: string): MethodWithOptions | undefined;
+export declare function useMethodFns(id: string): MethodWithOptsAndJitFns;
+export declare function setBundledMethod(id: string, entry: MethodWithOptsAndJitFns): void;
+export declare function isBundledMethod(id: string): boolean;
+export declare function bundledMethodIds(): string[];
+export declare function setFetchedMethods(methods: FetchedMethods): void;
+export declare function resetBundledMethods(): void;
+//# sourceMappingURL=methods.d.ts.map

package/.dist/cjs/src/lib/persistentStorage.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});async function requestPersistentStorage(){const storage=globalThis.navigator?.storage;if(!storage?.persist)return!1;try{return await storage.persisted?.()?!0:await storage.persist()}catch{return!1}}async function requestPersistenceWhenSilent(){const storage=globalThis.navigator?.storage;if(!storage?.persist||!storage.persisted)return!1;try{if(await storage.persisted())return!0;const permissions=globalThis.navigator?.permissions;return!permissions?.query||(await permissions.query({name:"persistent-storage"})).state!=="granted"?!1:await storage.persist()}catch{return!1}}exports.requestPersistenceWhenSilent=requestPersistenceWhenSilent;exports.requestPersistentStorage=requestPersistentStorage;
+
+//# sourceMappingURL=persistentStorage.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persistentStorage.cjs","names":[],"sources":["../../../../src/lib/persistentStorage.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/** Asks the browser to keep the metadata cache when it starts clearing storage to reclaim space.\n *  Call it from your own code, ideally after a user action: some browsers show a permission bar for\n *  this, so mion never calls it on your behalf unless the permission is already granted.\n *  Resolves false where the browser has no such notion. */\nexport async function requestPersistentStorage(): Promise<boolean> {\n  const storage = globalThis.navigator?.storage;\n  if (!storage?.persist) return false;\n  try {\n    if (await storage.persisted?.()) return true;\n    return await storage.persist();\n  } catch {\n    return false;\n  }\n}\n\n/** The automatic half, run once after the cache's first successful write. mion NEVER triggers a browser\n *  prompt: `persist()` can show a permission bar and no one can tell in advance which browser will, so this\n *  asks only from `granted`. Anywhere else the cache is simply evictable, until an app asks for itself. */\nexport async function requestPersistenceWhenSilent(): Promise<boolean> {\n  const storage = globalThis.navigator?.storage;\n  if (!storage?.persist || !storage.persisted) return false;\n  try {\n    if (await storage.persisted()) return true;\n    const permissions = globalThis.navigator?.permissions;\n    if (!permissions?.query) return false;\n    const status = await permissions.query({name: 'persistent-storage' as PermissionName});\n    if (status.state !== 'granted') return false;\n    return await storage.persist();\n  } catch {\n    // an unsupported permission name rejects; that is a browser we do not ask in\n    return false;\n  }\n}\n"],"mappings":"mEAWA,eAAsB,0BAA6C,CACjE,MAAM,QAAU,WAAW,WAAW,QACtC,GAAI,CAAC,SAAS,QAAS,MAAO,GAC9B,GAAI,CACF,OAAI,MAAM,QAAQ,YAAY,EAAU,GACjC,MAAM,QAAQ,QAAQ,CAC/B,MAAQ,CACN,MAAO,EACT,CACF,CAKA,eAAsB,8BAAiD,CACrE,MAAM,QAAU,WAAW,WAAW,QACtC,GAAI,CAAC,SAAS,SAAW,CAAC,QAAQ,UAAW,MAAO,GACpD,GAAI,CACF,GAAI,MAAM,QAAQ,UAAU,EAAG,MAAO,GACtC,MAAM,YAAc,WAAW,WAAW,YAG1C,MAFI,CAAC,aAAa,QAEd,MADiB,YAAY,MAAM,CAAC,KAAM,oBAAsC,CAAC,GAC1E,QAAU,UAAkB,GAChC,MAAM,QAAQ,QAAQ,CAC/B,MAAQ,CAEN,MAAO,EACT,CACF"}

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

@@ -0,0 +1,3 @@
+export declare function requestPersistentStorage(): Promise<boolean>;
+export declare function requestPersistenceWhenSilent(): Promise<boolean>;
+//# sourceMappingURL=persistentStorage.d.ts.map

package/.dist/cjs/src/lib/sanitize.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_lib_methods=require("./methods.cjs");let _mionjs_core=require("@mionjs/core");var sanitizedParams=new WeakSet;function sanitizeSubRequests(subRequestIds,context){if(context.options.sanitizeParams)for(const id of subRequestIds){const subRequest=context.subRequestList[id];if(!subRequest||subRequest.isResolved||subRequest.error)continue;const params=subRequest.params;if(!Array.isArray(params)||sanitizedParams.has(params)||subRequest.mappings&&subRequest.mappings.length>0||!require_src_lib_methods.hasMethod(id))continue;const method=require_src_lib_methods.useMethodFns(id),formatTransform=method.paramsJitFns.formatTransform;if(!method.options?.sanitizeParams||!method.paramsCount||!formatTransform||formatTransform.isNoop)continue;const isHeadersMiddleware=method.type===_mionjs_core.HandlerType.headersMiddleware&&!!method.headersParam,body=isHeadersMiddleware?params.slice(1):params;try{const sanitized=formatTransform.fn(body);subRequest.params=isHeadersMiddleware?[params[0],...sanitized]:sanitized,sanitizedParams.add(subRequest.params)}catch{}}}exports.sanitizeSubRequests=sanitizeSubRequests;
+
+//# sourceMappingURL=sanitize.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.cjs","names":[],"sources":["../../../../src/lib/sanitize.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} from '@mionjs/core';\nimport {hasMethod, useMethodFns} from './methods.ts';\nimport type {CallContext} from '../types.ts';\n\n// A retry sanitizes the same params again, and a first-match `replace` must not run twice on them.\nconst sanitizedParams = new WeakSet<any[]>();\n\n/** Runs before validation and serialization, so the client sends what the server sees; never throws, validation reports bad input */\nexport function sanitizeSubRequests(subRequestIds: string[], context: CallContext): void {\n  if (!context.options.sanitizeParams) return;\n  for (const id of subRequestIds) {\n    const subRequest = context.subRequestList[id];\n    if (!subRequest || subRequest.isResolved || subRequest.error) continue;\n    const params = subRequest.params;\n    if (!Array.isArray(params) || sanitizedParams.has(params)) continue;\n    // inputFrom placeholders are filled by the server after the source route runs\n    if (subRequest.mappings && subRequest.mappings.length > 0) continue;\n    if (!hasMethod(id)) continue;\n    const method = useMethodFns(id);\n    const formatTransform = method.paramsJitFns.formatTransform;\n    if (!method.options?.sanitizeParams || !method.paramsCount || !formatTransform || formatTransform.isNoop) continue;\n    // a headersMiddleware's first param is the HeadersSubset, never part of the body params type\n    const isHeadersMiddleware = method.type === HandlerType.headersMiddleware && !!method.headersParam;\n    const body = isHeadersMiddleware ? params.slice(1) : params;\n    try {\n      const sanitized = formatTransform.fn(body) as any[];\n      subRequest.params = isHeadersMiddleware ? [params[0], ...sanitized] : sanitized;\n      sanitizedParams.add(subRequest.params);\n    } catch {\n      // validation reports the real error\n    }\n  }\n}\n"],"mappings":"mKAYA,IAAM,gBAAkB,IAAI,QAG5B,SAAgB,oBAAoB,cAAyB,QAA4B,CACvF,GAAK,QAAQ,QAAQ,eACrB,UAAW,MAAM,cAAe,CAC9B,MAAM,WAAa,QAAQ,eAAe,EAAA,EAC1C,GAAI,CAAC,YAAc,WAAW,YAAc,WAAW,MAAO,SAC9D,MAAM,OAAS,WAAW,OAI1B,GAHI,CAAC,MAAM,QAAQ,MAAM,GAAK,gBAAgB,IAAI,MAAM,GAEpD,WAAW,UAAY,WAAW,SAAS,OAAS,GACpD,CAAC,wBAAA,UAAU,EAAE,EAAG,SACpB,MAAM,OAAS,wBAAA,aAAa,EAAE,EACxB,gBAAkB,OAAO,aAAa,gBAC5C,GAAI,CAAC,OAAO,SAAS,gBAAkB,CAAC,OAAO,aAAe,CAAC,iBAAmB,gBAAgB,OAAQ,SAE1G,MAAM,oBAAsB,OAAO,OAAS,aAAA,YAAY,mBAAqB,CAAC,CAAC,OAAO,aAChF,KAAO,oBAAsB,OAAO,MAAM,CAAC,EAAI,OACrD,GAAI,CACF,MAAM,UAAY,gBAAgB,GAAG,IAAI,EACzC,WAAW,OAAS,oBAAsB,CAAC,OAAO,CAAA,EAAI,GAAG,SAAS,EAAI,UACtE,gBAAgB,IAAI,WAAW,MAAM,CACvC,MAAQ,CAER,CACF,CACF"}

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

@@ -0,0 +1,3 @@
+import { CallContext } from '../types.ts';
+export declare function sanitizeSubRequests(subRequestIds: string[], context: CallContext): void;
+//# sourceMappingURL=sanitize.d.ts.map

package/.dist/cjs/src/lib/serializer.cjs

@@ -1,2 +1,3 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const core=require("@mionjs/core"),src_constants=require("../constants.cjs"),src_lib_clientMethodsMetadata=require("./clientMethodsMetadata.cjs");function serializeRequestBody(req){const serializerMode=getSerializerMode(req);switch(serializerMode){case"json":case"stringifyJson":return{body:serializeJsonBody(req),contentType:"application/json; charset=utf-8"};case"optimistic":return{body:serializeJSonBodyOptimistic(req),contentType:"application/json; charset=utf-8"};case"binary":return{body:serializeBinaryBody(req),contentType:"application/octet-stream"};default:throw new Error(`Invalid serializer mode ${serializerMode}`)}}function serializeJsonBody(req){const props=[],subRequestIds=Object.keys(req.subRequestList);for(let i=0;i<subRequestIds.length;i++){const id=subRequestIds[i],subRequest=req.subRequestList[id];if(!subRequest)continue;let params=subRequest.params;const method=core.routesCache.useMethodJitFns(id);method.type===core.HandlerType.headersMiddleFn&&method.headersParam&&(params=getParamsWithoutHeadersSubset(params));try{const jsonValue=stringifyHandlerParams(method,params);if(!jsonValue)continue;props.push(`${JSON.stringify(id)}:${jsonValue}`)}catch(e){throw new core.RpcError({type:"json-stringify-request-error",publicMessage:`Failed to stringify params for handler ${id}`,originalError:e})}}return`{${props.join(",")}}`}function serializeJSonBodyOptimistic(req){const body={},subRequestIds=Object.keys(req.subRequestList);for(const id of subRequestIds){const subRequest=req.subRequestList[id];subRequest&&(body[id]=subRequest.params)}return JSON.stringify(body)}function serializeBinaryBody(req){const subRequestIds=Object.keys(req.subRequestList),body={},executionChain=[];for(const id of subRequestIds){let params=req.subRequestList[id].params;const method=core.routesCache.useMethodJitFns(id);method.type===core.HandlerType.headersMiddleFn&&method.headersParam&&(params=getParamsWithoutHeadersSubset(params)),body[id]=params,executionChain.push(method)}const workflowRouteIds=req.workflowSubRequests?.map(sr=>sr.id),{buffer}=core.serializeBinaryBody(req.path,executionChain,body,!1,workflowRouteIds);return new Uint8Array(buffer)}function stringifyHandlerParams(method,params){if(!method.paramNames||method.paramNames.length===0)return"";const paramsJit=method.paramsJitFns;return paramsJit.prepareForJson.isNoop?JSON.stringify(params):paramsJit.stringifyJson.fn(params)}async function deserializeResponseBody(response,options){let parsedBody;const contentType=response.headers.get("content-type")?.toLowerCase();switch(!0){case!!contentType?.includes("application/json"):parsedBody=await deserializeJsonResponseBody(response,options);break;case!!contentType?.includes("application/octet-stream"):parsedBody=await deserializeBinaryResponseBody(response);break;default:throw new core.RpcError({type:"unsupported-content-type",publicMessage:`Unsupported response content-type: '${contentType||"none"}'`})}return parsedBody}async function deserializeJsonResponseBody(response,options){try{const parsedBody=await response.json();src_lib_clientMethodsMetadata.extractAndProcessMetadata(core.MION_ROUTES.methodsMetadata,parsedBody,options),src_lib_clientMethodsMetadata.extractAndProcessMetadata(core.MION_ROUTES.methodsMetadataById,parsedBody,options);const platformError=unwrapUnexpectedErrors(parsedBody);if(platformError)return{[core.MION_ROUTES.platformError]:platformError};const deserializedBody={};return Object.entries(parsedBody).forEach(([methodId,returnValue])=>{const method=core.routesCache.useMethodJitFns(methodId);deserializedBody[methodId]=parseHandlerJsonReturnValue(method,returnValue)}),deserializedBody}catch(err){throw new core.RpcError({type:"parsing-json-response-error",publicMessage:`Invalid json response body: ${err?.message||"unknown parsing error."}`})}}async function deserializeBinaryResponseBody(response){const arrayBuffer=await response.arrayBuffer(),{body}=core.deserializeBinaryBody("client-response",arrayBuffer,!0),platformError=unwrapUnexpectedErrors(body);return platformError?{[core.MION_ROUTES.platformError]:platformError}:body}function unwrapUnexpectedErrors(parsedBody){if(!(core.MION_ROUTES.thrownErrors in parsedBody))return;const unexpectedErrors=parsedBody[core.MION_ROUTES.thrownErrors];if(core.MION_ROUTES.platformError in unexpectedErrors){const globalErrorValue=unexpectedErrors[core.MION_ROUTES.platformError];return core.isRpcError(globalErrorValue)?new core.RpcError(globalErrorValue):globalErrorValue}Object.assign(parsedBody,unexpectedErrors),delete parsedBody[core.MION_ROUTES.thrownErrors]}function getSerializerMode(req){if(req.options.serializer==="optimistic")return Object.keys(req.subRequestList).every(id=>core.routesCache.hasMetadata(id))?"stringifyJson":"optimistic";const methodId=req.route?.id??req.workflowSubRequests?.[0]?.id,serializerMode=core.routesCache.getMethodJitFns(methodId)?.options.serializer||src_constants.DEFAULT_PREFILL_OPTIONS.serializer;return serializerMode==="json"?src_constants.DEFAULT_PREFILL_OPTIONS.serializer:serializerMode}function getParamsWithoutHeadersSubset(params){return!params||params.length===0?[]:params.slice(1)}function parseHandlerJsonReturnValue(method,returnValue){if(!method.hasReturnData)return returnValue;const returnJit=method.returnJitFns;if(returnJit.restoreFromJson.isNoop||!returnValue)return returnValue;try{return returnValue instanceof core.RpcError?returnValue:core.isRpcError(returnValue)?new core.RpcError(returnValue):returnJit.restoreFromJson.fn(returnValue)}catch(e){return new core.RpcError({type:"deserialization-error",publicMessage:`Invalid response from Route or MiddleFn '${method.id}', can not deserialize return value: ${e.message}`,errorData:e?.errors})}}exports.deserializeResponseBody=deserializeResponseBody;exports.serializeRequestBody=serializeRequestBody;
-//# sourceMappingURL=serializer.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_lib_methods=require("./methods.cjs"),require_src_lib_headers=require("./headers.cjs");let _mionjs_core=require("@mionjs/core");function serializeRequestBody(context,optimistic=!1){return{body:optimistic?serializeJSonBodyOptimistic(context):serializeJsonBody(context),contentType:"application/json; charset=utf-8"}}function serializeJsonBody(context){const props=[],subRequestIds=Object.keys(context.subRequestList);for(let i=0;i<subRequestIds.length;i++){const id=subRequestIds[i],subRequest=context.subRequestList[id];if(!subRequest)continue;let params=subRequest.params;const method=require_src_lib_methods.useMethodFns(id);method.type===_mionjs_core.HandlerType.headersMiddleware&&method.headersParam&&(params=getParamsWithoutHeadersSubset(params));try{const jsonValue=stringifyHandlerParams(method,params,context.options.validateParams);if(!jsonValue)continue;props.push(`${JSON.stringify(id)}:${jsonValue}`)}catch(e){throw new _mionjs_core.RpcError({type:"json-stringify-request-error",publicMessage:`Failed to stringify params for handler ${id}`,originalError:e})}}return`{${props.join(",")}}`}function serializeJSonBodyOptimistic(context){const body={},subRequestIds=Object.keys(context.subRequestList);for(const id of subRequestIds){const subRequest=context.subRequestList[id];if(!subRequest)continue;const params=require_src_lib_headers.hasHeadersSubsetParam(id,subRequest.params)?getParamsWithoutHeadersSubset(subRequest.params):subRequest.params;params?.length&&(body[id]=params)}return JSON.stringify(body,wireFormReplacer)}function stringifyHandlerParams(method,params,validated){if(!method.paramsCount)return"";const{json,isType}=method.paramsJitFns;if(json.encode.isNoop)return JSON.stringify(params);if(!validated&&!isType.isNoop&&!isType.fn(params))return JSON.stringify(params,wireFormReplacer);const write=()=>JSON.stringify(json.encode.fn(params));try{return write()}catch{return JSON.stringify(params,wireFormReplacer)}}function wireFormReplacer(key,value){return value instanceof Map?[...value]:value instanceof Set?[...value]:typeof value=="bigint"?value.toString():value}async function deserializeResponseBody(response,options,takeRaw){let parsedBody;const contentType=response.headers.get("content-type")?.toLowerCase();if(!0===!!contentType?.includes("application/json"))parsedBody=await deserializeJsonResponseBody(response,takeRaw);else throw new _mionjs_core.RpcError({type:"unsupported-content-type",publicMessage:`Unsupported response content-type: '${contentType||"none"}'`});return parsedBody}async function deserializeJsonResponseBody(response,takeRaw){try{const parsedBody=await response.json(),rawEntries=parsedBody&&typeof parsedBody=="object"?takeRaw?.(parsedBody):void 0,extracted=extractThrownErrors(parsedBody);if(extracted.platformError)return{[_mionjs_core.MION_ROUTES.platformError]:extracted.platformError};let thrownErrors=extracted.thrownErrors;const deserializedBody={};return Object.entries(parsedBody).forEach(([methodId,returnValue])=>{const method=require_src_lib_methods.useMethodFns(methodId);try{deserializedBody[methodId]=parseHandlerJsonReturnValue(method,returnValue)}catch(decodeError){(thrownErrors??={})[methodId]=new _mionjs_core.RpcError({type:"deserialization-error",publicMessage:`Invalid response from Route or Middleware '${method.id}', can not deserialize return value: ${decodeError.message}`,errorData:decodeError?.errors})}}),thrownErrors&&(deserializedBody[_mionjs_core.MION_ROUTES.thrownErrors]=thrownErrors),rawEntries&&Object.assign(deserializedBody,rawEntries),deserializedBody}catch(err){throw new _mionjs_core.RpcError({type:"parsing-json-response-error",publicMessage:`Invalid json response body: ${err?.message||"unknown parsing error."}`})}}function extractThrownErrors(parsedBody){if(!(_mionjs_core.MION_ROUTES.thrownErrors in parsedBody))return{};const rawThrownErrors=parsedBody[_mionjs_core.MION_ROUTES.thrownErrors];if(delete parsedBody[_mionjs_core.MION_ROUTES.thrownErrors],_mionjs_core.MION_ROUTES.platformError in rawThrownErrors){const globalErrorValue=rawThrownErrors[_mionjs_core.MION_ROUTES.platformError];return{platformError:(0,_mionjs_core.isRpcError)(globalErrorValue)?new _mionjs_core.RpcError(globalErrorValue):globalErrorValue}}const thrownErrors=Object.create(null);return Object.entries(rawThrownErrors).forEach(([id,value])=>{thrownErrors[id]=(0,_mionjs_core.isRpcError)(value)?new _mionjs_core.RpcError(value):value}),{thrownErrors}}function getParamsWithoutHeadersSubset(params){return!params||params.length===0?[]:params.slice(1)}function parseHandlerJsonReturnValue(method,returnValue){if(!method.hasReturnData)return returnValue;const{decode}=method.returnJitFns.json;return decode.isNoop||!returnValue||returnValue instanceof _mionjs_core.RpcError?returnValue:(0,_mionjs_core.isRpcError)(returnValue)?new _mionjs_core.RpcError(returnValue):decode.fn(returnValue)}exports.deserializeResponseBody=deserializeResponseBody;exports.serializeRequestBody=serializeRequestBody;exports.wireFormReplacer=wireFormReplacer;
+
+//# sourceMappingURL=serializer.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"serializer.cjs","sources":["../../../../src/lib/serializer.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 type {ResponseBody} from '@mionjs/router';\nimport {\n    type MethodWithJitFns,\n    RpcError,\n    isRpcError,\n    routesCache,\n    MION_ROUTES,\n    HandlerType,\n    type SerializerMode,\n    serializeBinaryBody as coreSerializeBinaryBody,\n    deserializeBinaryBody as coreDeserializeBinaryBody,\n} from '@mionjs/core';\nimport type {MionClientRequest} from '../request.ts';\nimport {DEFAULT_PREFILL_OPTIONS} from '../constants.ts';\nimport {extractAndProcessMetadata} from './clientMethodsMetadata.ts';\nimport {ClientOptions} from '../types.ts';\n\n/** Result of serializing a request body - can be string (JSON) or Uint8Array (binary) */\nexport type SerializedBody = string | Uint8Array;\n\n/** Content-type header value for the serialized body */\nexport type ContentType = 'application/json; charset=utf-8' | 'application/octet-stream';\n\n/** Result of serializing a request body with its content type */\nexport interface SerializedRequest {\n    body: SerializedBody;\n    contentType: ContentType;\n}\n\n// ################################## SERIALIZE ##################################\n\n/** Serializes the request body and returns it with the appropriate content type */\nexport function serializeRequestBody(req: MionClientRequest<any, any>): SerializedRequest {\n    const serializerMode = getSerializerMode(req);\n    switch (serializerMode) {\n        case 'json':\n        case 'stringifyJson':\n            return {\n                body: serializeJsonBody(req),\n                contentType: 'application/json; charset=utf-8',\n            };\n        case 'optimistic':\n            return {\n                body: serializeJSonBodyOptimistic(req),\n                contentType: 'application/json; charset=utf-8',\n            };\n        case 'binary':\n            return {\n                body: serializeBinaryBody(req),\n                contentType: 'application/octet-stream',\n            };\n        default:\n            throw new Error(`Invalid serializer mode ${serializerMode}`);\n    }\n}\n\nfunction serializeJsonBody(req: MionClientRequest<any, any>): string {\n    const props: string[] = [];\n    const subRequestIds = Object.keys(req.subRequestList);\n\n    for (let i = 0; i < subRequestIds.length; i++) {\n        const id = subRequestIds[i];\n        const subRequest = req.subRequestList[id];\n        if (!subRequest) continue;\n        let params = subRequest.params;\n        const method = routesCache.useMethodJitFns(id);\n        if (method.type === HandlerType.headersMiddleFn && method.headersParam) {\n            params = getParamsWithoutHeadersSubset(params);\n        }\n        try {\n            const jsonValue = stringifyHandlerParams(method, params);\n            if (!jsonValue) continue;\n            props.push(`${JSON.stringify(id)}:${jsonValue}`);\n        } catch (e: any) {\n            const err = new RpcError({\n                type: 'json-stringify-request-error',\n                publicMessage: `Failed to stringify params for handler ${id}`,\n                originalError: e,\n            });\n            throw err;\n        }\n    }\n\n    return `{${props.join(',')}}`;\n}\n\n/** Serializes request body as plain JSON without JIT functions */\nfunction serializeJSonBodyOptimistic(req: MionClientRequest<any, any>): string {\n    const body: Record<string, any> = {};\n    const subRequestIds = Object.keys(req.subRequestList);\n    for (const id of subRequestIds) {\n        const subRequest = req.subRequestList[id];\n        if (!subRequest) continue;\n        body[id] = subRequest.params;\n    }\n    return JSON.stringify(body);\n}\n\n/** Serializes request body to binary format */\nfunction serializeBinaryBody(req: MionClientRequest<any, any>): Uint8Array {\n    const subRequestIds = Object.keys(req.subRequestList);\n    const body: Record<string, any> = {};\n    const executionChain: MethodWithJitFns[] = [];\n\n    for (const id of subRequestIds) {\n        const subRequest = req.subRequestList[id];\n        let params = subRequest.params;\n        const method = routesCache.useMethodJitFns(id);\n\n        if (method.type === HandlerType.headersMiddleFn && method.headersParam) {\n            params = getParamsWithoutHeadersSubset(params);\n        }\n\n        body[id] = params;\n        executionChain.push(method);\n    }\n\n    const workflowRouteIds = req.workflowSubRequests?.map((sr) => sr.id);\n    const {buffer} = coreSerializeBinaryBody(req.path, executionChain, body, false, workflowRouteIds);\n    return new Uint8Array(buffer);\n}\n\nfunction stringifyHandlerParams(method: MethodWithJitFns, params: any[]): string {\n    if (!method.paramNames || method.paramNames.length === 0) return '';\n    const paramsJit = method.paramsJitFns;\n    if (paramsJit.prepareForJson.isNoop) return JSON.stringify(params);\n    return paramsJit.stringifyJson.fn(params);\n}\n\n// ################################## DE-SERIALIZE ##################################\n\n/** Deserializes the response body from a fetch Response object. Handles routes metadata if present in json responses. */\nexport async function deserializeResponseBody(response: Response, options: ClientOptions): Promise<ResponseBody> {\n    let parsedBody: any;\n    const contentType = response.headers.get('content-type')?.toLowerCase();\n    switch (true) {\n        case !!contentType?.includes('application/json'):\n            parsedBody = await deserializeJsonResponseBody(response, options);\n            break;\n        case !!contentType?.includes('application/octet-stream'):\n            parsedBody = await deserializeBinaryResponseBody(response);\n            break;\n        default:\n            throw new RpcError({\n                type: 'unsupported-content-type',\n                publicMessage: `Unsupported response content-type: '${contentType || 'none'}'`,\n            });\n    }\n    return parsedBody;\n}\n\n/** Deserializes JSON response body, Also handles routes metadata if present */\nasync function deserializeJsonResponseBody(response: Response, options: ClientOptions) {\n    try {\n        const parsedBody = await response.json();\n        // Extract & process metadata if present and delete entries after processing (does not use jit functions)\n        extractAndProcessMetadata(MION_ROUTES.methodsMetadata, parsedBody, options);\n        extractAndProcessMetadata(MION_ROUTES.methodsMetadataById, parsedBody, options);\n        // Unwrap unexpected errors (move them from [MION_ROUTES.thrownErrors] to root)\n        const platformError = unwrapUnexpectedErrors(parsedBody);\n        if (platformError) return {[MION_ROUTES.platformError]: platformError};\n        // Deserialize the body using jit functions\n        const deserializedBody: ResponseBody = {};\n        Object.entries(parsedBody).forEach(([methodId, returnValue]) => {\n            const method = routesCache.useMethodJitFns(methodId);\n            deserializedBody[methodId] = parseHandlerJsonReturnValue(method, returnValue);\n        });\n        return deserializedBody;\n    } catch (err: any) {\n        throw new RpcError({\n            type: 'parsing-json-response-error',\n            publicMessage: `Invalid json response body: ${err?.message || 'unknown parsing error.'}`,\n        });\n    }\n}\n\n/** Deserializes binary response body */\nasync function deserializeBinaryResponseBody(response: Response): Promise<ResponseBody> {\n    const arrayBuffer = await response.arrayBuffer();\n    const {body} = coreDeserializeBinaryBody('client-response', arrayBuffer, true);\n    // Unwrap unexpected errors (move them from [MION_ROUTES.thrownErrors] to root)\n    const platformError = unwrapUnexpectedErrors(body);\n    if (platformError) return {[MION_ROUTES.platformError]: platformError};\n    return body;\n}\n\n/** Unwraps unexpected errors from the response body into parsedBody. Returns a platformError if present as a special case. */\nfunction unwrapUnexpectedErrors(parsedBody: any): RpcError<string> | undefined {\n    if (!(MION_ROUTES.thrownErrors in parsedBody)) return;\n    const unexpectedErrors = parsedBody[MION_ROUTES.thrownErrors];\n    // if platform error is present that means the router never executed (just the platform wrapper)\n    if (MION_ROUTES.platformError in unexpectedErrors) {\n        const globalErrorValue = unexpectedErrors[MION_ROUTES.platformError];\n        return isRpcError(globalErrorValue) ? new RpcError<string>(globalErrorValue) : globalErrorValue;\n    }\n    Object.assign(parsedBody, unexpectedErrors);\n    delete parsedBody[MION_ROUTES.thrownErrors];\n}\n\n/** Determines the serializer mode to use for a request */\nfunction getSerializerMode(req: MionClientRequest<any, any>): SerializerMode {\n    if (req.options.serializer === 'optimistic') {\n        // When metadata is cached (e.g. after retry), use JIT serialization\n        const subRequestIds = Object.keys(req.subRequestList);\n        const allCached = subRequestIds.every((id) => routesCache.hasMetadata(id));\n        if (allCached) return 'stringifyJson';\n        return 'optimistic';\n    }\n    const methodId = req.route?.id ?? req.workflowSubRequests?.[0]?.id;\n    const method = routesCache.getMethodJitFns(methodId);\n    const serializerMode = method?.options.serializer || DEFAULT_PREFILL_OPTIONS.serializer;\n    if (serializerMode === 'json') return DEFAULT_PREFILL_OPTIONS.serializer;\n    return serializerMode;\n}\n\n/** Returns params array without the HeadersSubset (first param) */\nfunction getParamsWithoutHeadersSubset(params: any[]): any[] {\n    if (!params || params.length === 0) return [];\n    return params.slice(1);\n}\n\nfunction parseHandlerJsonReturnValue(method: MethodWithJitFns, returnValue: any): any {\n    if (!method.hasReturnData) return returnValue;\n    const returnJit = method.returnJitFns;\n    if (returnJit.restoreFromJson.isNoop || !returnValue) return returnValue;\n\n    try {\n        if (returnValue instanceof RpcError) return returnValue;\n        if (isRpcError(returnValue)) return new RpcError(returnValue);\n        return returnJit.restoreFromJson.fn(returnValue);\n    } catch (e: any) {\n        return new RpcError({\n            type: 'deserialization-error',\n            publicMessage: `Invalid response from Route or MiddleFn '${method.id}', can not deserialize return value: ${e.message}`,\n            errorData: e?.errors,\n        });\n    }\n}\n"],"names":["routesCache","HandlerType","RpcError","coreSerializeBinaryBody","extractAndProcessMetadata","MION_ROUTES","coreDeserializeBinaryBody","isRpcError","DEFAULT_PREFILL_OPTIONS"],"mappings":"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"}
+{"version":3,"file":"serializer.cjs","names":[],"sources":["../../../../src/lib/serializer.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 type {ResponseBody} from '@mionjs/router';\nimport {type MethodWithJitFns, RpcError, isRpcError, MION_ROUTES, HandlerType} from '@mionjs/core';\nimport type {CallContext} from '../types.ts';\nimport {useMethodFns} from './methods.ts';\nimport {hasHeadersSubsetParam} from './headers.ts';\nimport {ClientOptions} from '../types.ts';\n\nexport type SerializedBody = string;\n\nexport type ContentType = 'application/json; charset=utf-8';\n\n/** Runs on the parsed body before anything decodes, and may hand back entries to add untouched. */\ntype TakeRaw = (parsedBody: Record<string, unknown>) => Record<string, unknown> | undefined;\n\nexport interface SerializedRequest {\n  body: SerializedBody;\n  contentType: ContentType;\n}\n\n// ################################## SERIALIZE ##################################\n\n/** `optimistic`: the route's metadata is still being fetched, so no compiled encoders exist yet. */\nexport function serializeRequestBody(context: CallContext, optimistic = false): SerializedRequest {\n  const body = optimistic ? serializeJSonBodyOptimistic(context) : serializeJsonBody(context);\n  return {body, contentType: 'application/json; charset=utf-8'};\n}\n\nfunction serializeJsonBody(context: CallContext): string {\n  const props: 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) continue;\n    let params = subRequest.params;\n    const method = useMethodFns(id);\n    if (method.type === HandlerType.headersMiddleware && method.headersParam) {\n      params = getParamsWithoutHeadersSubset(params);\n    }\n    try {\n      const jsonValue = stringifyHandlerParams(method, params, context.options.validateParams);\n      if (!jsonValue) continue;\n      props.push(`${JSON.stringify(id)}:${jsonValue}`);\n    } catch (e: any) {\n      const err = new RpcError({\n        type: 'json-stringify-request-error',\n        publicMessage: `Failed to stringify params for handler ${id}`,\n        originalError: e,\n      });\n      throw err;\n    }\n  }\n\n  return `{${props.join(',')}}`;\n}\n\n/** Plain wire forms every server decoder accepts; a HeadersSubset goes out as HTTP headers, never in the body */\nfunction serializeJSonBodyOptimistic(context: CallContext): string {\n  const body: Record<string, any> = {};\n  const subRequestIds = Object.keys(context.subRequestList);\n  for (const id of subRequestIds) {\n    const subRequest = context.subRequestList[id];\n    if (!subRequest) continue;\n    const params = hasHeadersSubsetParam(id, subRequest.params)\n      ? getParamsWithoutHeadersSubset(subRequest.params)\n      : subRequest.params;\n    if (params?.length) body[id] = params;\n  }\n  return JSON.stringify(body, wireFormReplacer);\n}\n\n/** Writes the params with the strategy the server compiled. */\nfunction stringifyHandlerParams(method: MethodWithJitFns, params: any[], validated: boolean): string {\n  if (!method.paramsCount) return '';\n  const {json, isType} = method.paramsJitFns;\n  if (json.encode.isNoop) return JSON.stringify(params);\n  // with local validation off a wrong-typed value must still reach the server's validation, and the\n  // compiled encoders assume the type, so it rides the plain wire form instead\n  if (!validated && !isType.isNoop && !isType.fn(params)) return JSON.stringify(params, wireFormReplacer);\n  const write = (): string => JSON.stringify(json.encode.fn(params));\n  // the compiled encoder rejects anything but the real params (a batch mapping's `null` placeholder,\n  // a wrong-typed value), so those fall back to the plain wire forms the server decoders accept\n  try {\n    return write();\n  } catch {\n    return JSON.stringify(params, wireFormReplacer);\n  }\n}\n\n/** The wire forms the server's JSON decoders accept; Date, URL and Temporal need no arm, their own toJSON writes it.\n *  No union `[index, value]` envelope: the index needs metadata, so the server's guarded decoder refuses and the client retries. */\nexport function wireFormReplacer(this: unknown, key: string, value: unknown): unknown {\n  if (value instanceof Map) return [...value];\n  if (value instanceof Set) return [...value];\n  if (typeof value === 'bigint') return value.toString();\n  return value;\n}\n\n// ################################## DE-SERIALIZE ##################################\n\nexport async function deserializeResponseBody(\n  response: Response,\n  options: ClientOptions,\n  takeRaw?: TakeRaw\n): Promise<ResponseBody> {\n  let parsedBody: any;\n  const contentType = response.headers.get('content-type')?.toLowerCase();\n  switch (true) {\n    case !!contentType?.includes('application/json'):\n      parsedBody = await deserializeJsonResponseBody(response, takeRaw);\n      break;\n    default:\n      throw new RpcError({\n        type: 'unsupported-content-type',\n        publicMessage: `Unsupported response content-type: '${contentType || 'none'}'`,\n      });\n  }\n  return parsedBody;\n}\n\nasync function deserializeJsonResponseBody(response: Response, takeRaw: TakeRaw | undefined) {\n  try {\n    const parsedBody = await response.json();\n    const rawEntries = parsedBody && typeof parsedBody === 'object' ? takeRaw?.(parsedBody) : undefined;\n    // kept out of the body, so the wire's returned-vs-thrown split survives\n    const extracted = extractThrownErrors(parsedBody);\n    if (extracted.platformError) return {[MION_ROUTES.platformError]: extracted.platformError};\n    let thrownErrors = extracted.thrownErrors;\n    const deserializedBody: ResponseBody = {};\n    Object.entries(parsedBody).forEach(([methodId, returnValue]) => {\n      const method = useMethodFns(methodId);\n      try {\n        deserializedBody[methodId] = parseHandlerJsonReturnValue(method, returnValue);\n      } catch (decodeError: any) {\n        // an unreadable answer is untyped: thrown, never the method's declared value\n        (thrownErrors ??= {})[methodId] = new RpcError({\n          type: 'deserialization-error',\n          publicMessage: `Invalid response from Route or Middleware '${method.id}', can not deserialize return value: ${decodeError.message}`,\n          errorData: decodeError?.errors,\n        });\n      }\n    });\n    if (thrownErrors) deserializedBody[MION_ROUTES.thrownErrors] = thrownErrors;\n    if (rawEntries) Object.assign(deserializedBody, rawEntries);\n    return deserializedBody;\n  } catch (err: any) {\n    throw new RpcError({\n      type: 'parsing-json-response-error',\n      publicMessage: `Invalid json response body: ${err?.message || 'unknown parsing error.'}`,\n    });\n  }\n}\n\n/** Takes [MION_ROUTES.thrownErrors] out WITHOUT flattening it into the body, so the returned-vs-thrown split\n * survives for error classification. Thrown errors are not strongly typed and deserialize as RpcError<string>. */\nfunction extractThrownErrors(parsedBody: any): {\n  platformError?: RpcError<string>;\n  thrownErrors?: Record<string, RpcError<string>>;\n} {\n  if (!(MION_ROUTES.thrownErrors in parsedBody)) return {};\n  const rawThrownErrors = parsedBody[MION_ROUTES.thrownErrors];\n  delete parsedBody[MION_ROUTES.thrownErrors];\n  // if platform error is present that means the router never executed (just the platform wrapper)\n  if (MION_ROUTES.platformError in rawThrownErrors) {\n    const globalErrorValue = rawThrownErrors[MION_ROUTES.platformError];\n    const platformError = isRpcError(globalErrorValue) ? new RpcError<string>(globalErrorValue) : globalErrorValue;\n    return {platformError};\n  }\n  // keyed by whatever the response says, so a `__proto__` key stays a plain entry\n  const thrownErrors: Record<string, RpcError<string>> = Object.create(null);\n  Object.entries(rawThrownErrors).forEach(([id, value]) => {\n    thrownErrors[id] = isRpcError(value) ? new RpcError<string>(value) : (value as RpcError<string>);\n  });\n  return {thrownErrors};\n}\n\nfunction getParamsWithoutHeadersSubset(params: any[]): any[] {\n  if (!params || params.length === 0) return [];\n  return params.slice(1);\n}\n\nfunction parseHandlerJsonReturnValue(method: MethodWithJitFns, returnValue: any): any {\n  if (!method.hasReturnData) return returnValue;\n  const {decode} = method.returnJitFns.json;\n  if (decode.isNoop || !returnValue) return returnValue;\n\n  if (returnValue instanceof RpcError) return returnValue;\n  if (isRpcError(returnValue)) return new RpcError(returnValue);\n  return decode.fn(returnValue);\n}\n"],"mappings":"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"}

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

@@ -1,12 +1,14 @@
 import { ResponseBody } from '@mionjs/router';
-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';
+import { CallContext, ClientOptions } from '../types.ts';
+export type SerializedBody = string;
+export type ContentType = 'application/json; charset=utf-8';
+type TakeRaw = (parsedBody: Record<string, unknown>) => Record<string, unknown> | undefined;
 export interface SerializedRequest {
     body: SerializedBody;
     contentType: ContentType;
 }
-export declare function serializeRequestBody(req: MionClientRequest<any, any>): SerializedRequest;
-export declare function deserializeResponseBody(response: Response, options: ClientOptions): Promise<ResponseBody>;
+export declare function serializeRequestBody(context: CallContext, optimistic?: boolean): SerializedRequest;
+export declare function wireFormReplacer(this: unknown, key: string, value: unknown): unknown;
+export declare function deserializeResponseBody(response: Response, options: ClientOptions, takeRaw?: TakeRaw): Promise<ResponseBody>;
+export {};
 //# sourceMappingURL=serializer.d.ts.map

package/.dist/cjs/src/lib/storage.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const STORAGE_GLOBAL_KEY="__mion_storage__";class MemoryStorage{data=new Map;get length(){return this.data.size}getItem(key){return this.data.get(key)??null}setItem(key,value){this.data.set(key,value)}removeItem(key){this.data.delete(key)}clear(){this.data.clear()}key(index){return[...this.data.keys()][index]??null}}function getStorage(){const existing=globalThis[STORAGE_GLOBAL_KEY];if(existing)return existing;let storage;try{typeof localStorage<"u"?(localStorage.setItem("__mion_test__","1"),localStorage.removeItem("__mion_test__"),storage=localStorage):storage=new MemoryStorage}catch{storage=new MemoryStorage}return globalThis[STORAGE_GLOBAL_KEY]=storage,storage}function resetStorageInstance(){delete globalThis[STORAGE_GLOBAL_KEY]}exports.MemoryStorage=MemoryStorage;exports.getStorage=getStorage;exports.resetStorageInstance=resetStorageInstance;
-//# sourceMappingURL=storage.cjs.map

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

@@ -1,12 +1,19 @@
-export declare class MemoryStorage {
-    private data;
-    get length(): number;
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-    removeItem(key: string): void;
-    clear(): void;
-    key(index: number): string | null;
+export type MetadataKind = 'm' | 'j' | 'p';
+export interface MetadataRecord {
+    baseURL: string;
+    kind: MetadataKind;
+    id: string;
+    json: string;
+    ts: number;
 }
-export declare function getStorage(): Storage | MemoryStorage;
-export declare function resetStorageInstance(): void;
+export type MetadataRecordKey = [MetadataKind, string];
+export interface MetadataStore {
+    readonly kind: string;
+    readAll(baseURL: string): Promise<MetadataRecord[]>;
+    write(records: MetadataRecord[]): Promise<void>;
+    remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void>;
+    clear(baseURL?: string): Promise<void>;
+}
+export type MetadataStoreFactory = () => MetadataStore | undefined | Promise<MetadataStore | undefined>;
+export type StorageEngine = 'indexeddb' | 'memory' | MetadataStoreFactory;
 //# sourceMappingURL=storage.d.ts.map

package/.dist/cjs/src/lib/typedEvent.cjs

@@ -1,2 +1,3 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class TypedEvent{handlerId;registry;constructor(handlerId,registry){this.handlerId=handlerId,this.registry=registry}onSuccess(handler){return this.registry.registerSuccess(this.handlerId,handler),this}offSuccess(){return this.registry.unregisterSuccess(this.handlerId),this}onError(errorType,handler){return this.registry.register(this.handlerId,errorType,handler),this}offError(errorType){return this.registry.unregister(this.handlerId,errorType),this}getHandlerId(){return this.handlerId}hasErrorHandler(errorType){return this.registry.hasHandler(this.handlerId,errorType)}hasSuccessHandler(){return this.registry.hasSuccessHandler(this.handlerId)}}exports.TypedEvent=TypedEvent;
-//# sourceMappingURL=typedEvent.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var TypedEvent=class{handlerId;registry;createSubRequest;constructor(handlerId,registry,createSubRequest){this.handlerId=handlerId,this.registry=registry,this.createSubRequest=createSubRequest}onRequest(handler){if(!this.createSubRequest)throw new Error(`onRequest needs the middleware from the client, '${this.handlerId}' has none`);return this.registry.registerRequest(this.handlerId,handler,this.createSubRequest),this}offRequest(){return this.registry.unregisterRequest(this.handlerId),this}onResponse(handler){return this.registry.registerResponse(this.handlerId,handler),this}offResponse(handler){return this.registry.unregisterResponse(this.handlerId,handler),this}onError(errorType,handler){return this.registry.register(this.handlerId,errorType,handler),this}offError(errorType,handler){return this.registry.unregister(this.handlerId,errorType,handler),this}getHandlerId(){return this.handlerId}hasErrorHandler(errorType){return this.registry.hasHandler(this.handlerId,errorType)}hasResponseHandler(){return this.registry.hasResponseHandler(this.handlerId)}hasRequestHandler(){return this.registry.hasRequestHandler(this.handlerId)}};exports.TypedEvent=TypedEvent;
+
+//# sourceMappingURL=typedEvent.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"typedEvent.cjs","sources":["../../../../src/lib/typedEvent.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 {HandlersRegistry} from './handlersRegistry.ts';\nimport type {ErrorHandler, SuccessHandler} from '../types.ts';\n\n/** Persistent event emitter for middleFn success and error handling */\nexport class TypedEvent<S = void, E extends RpcError<string, any> = never> {\n    constructor(\n        private readonly handlerId: string,\n        private readonly registry: HandlersRegistry\n    ) {}\n\n    /** Register a persistent success handler for this middleFn */\n    onSuccess(handler: SuccessHandler<S>): TypedEvent<S, E> {\n        this.registry.registerSuccess(this.handlerId, handler);\n        return this;\n    }\n\n    /** Remove a previously registered success handler from HandlersRegistry */\n    offSuccess(): TypedEvent<S, E> {\n        this.registry.unregisterSuccess(this.handlerId);\n        return this;\n    }\n\n    /** Register a persistent error handler for this middleFn */\n    onError<T extends E['type']>(errorType: T, handler: (error: Extract<E, {type: T}>) => void): TypedEvent<S, E> {\n        this.registry.register(this.handlerId, errorType, handler as ErrorHandler<any>);\n        return this;\n    }\n\n    /** Remove a previously registered error handler from HandlersRegistry */\n    offError<T extends E['type']>(errorType: T): TypedEvent<S, E> {\n        this.registry.unregister(this.handlerId, errorType);\n        return this;\n    }\n\n    /** Get the handler ID this event is associated with */\n    getHandlerId(): string {\n        return this.handlerId;\n    }\n\n    /** Check if an error handler is registered for a specific error type */\n    hasErrorHandler(errorType: string): boolean {\n        return this.registry.hasHandler(this.handlerId, errorType);\n    }\n\n    /** Check if a success handler is registered */\n    hasSuccessHandler(): boolean {\n        return this.registry.hasSuccessHandler(this.handlerId);\n    }\n}\n"],"names":[],"mappings":"sFAYa,UAAU,CAEE,UACA,SAFrB,YACqB,UACA,SAA0B,CAD1B,KAAA,UAAA,UACA,KAAA,SAAA,QAClB,CAGH,UAAU,QAA0B,CAChC,YAAK,SAAS,gBAAgB,KAAK,UAAW,OAAO,EAC9C,IACX,CAGA,YAAU,CACN,YAAK,SAAS,kBAAkB,KAAK,SAAS,EACvC,IACX,CAGA,QAA6B,UAAc,QAA+C,CACtF,YAAK,SAAS,SAAS,KAAK,UAAW,UAAW,OAA4B,EACvE,IACX,CAGA,SAA8B,UAAY,CACtC,YAAK,SAAS,WAAW,KAAK,UAAW,SAAS,EAC3C,IACX,CAGA,cAAY,CACR,OAAO,KAAK,SAChB,CAGA,gBAAgB,UAAiB,CAC7B,OAAO,KAAK,SAAS,WAAW,KAAK,UAAW,SAAS,CAC7D,CAGA,mBAAiB,CACb,OAAO,KAAK,SAAS,kBAAkB,KAAK,SAAS,CACzD,CACH"}
+{"version":3,"file":"typedEvent.cjs","names":[],"sources":["../../../../src/lib/typedEvent.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 {HandlersRegistry} from './handlersRegistry.ts';\nimport type {ErrorHandler, ErrorOfType, RequestHandler, ResponseHandler, SubRequest} from '../types.ts';\n\n/** Persistent hooks of one middleware: its params before each request, its result or error after it */\nexport class TypedEvent<S = void, E extends RpcError<string, any> = never, P extends any[] = any[]> {\n  constructor(\n    private readonly handlerId: string,\n    private readonly registry: HandlersRegistry,\n    private readonly createSubRequest?: (params: any[]) => SubRequest<any>\n  ) {}\n\n  /** Register a persistent handler that gives this middleware its params before every request that runs it */\n  onRequest(handler: RequestHandler<P>): TypedEvent<S, E, P> {\n    if (!this.createSubRequest) throw new Error(`onRequest needs the middleware from the client, '${this.handlerId}' has none`);\n    this.registry.registerRequest(this.handlerId, handler, this.createSubRequest);\n    return this;\n  }\n\n  /** Remove a previously registered request handler from HandlersRegistry */\n  offRequest(): TypedEvent<S, E, P> {\n    this.registry.unregisterRequest(this.handlerId);\n    return this;\n  }\n\n  /** Persistent handler for this middleware's successful result; every one registered runs, in order */\n  onResponse(handler: ResponseHandler<S>): TypedEvent<S, E, P> {\n    this.registry.registerResponse(this.handlerId, handler);\n    return this;\n  }\n\n  /** Remove this response handler; the others on this middleware stay */\n  offResponse(handler: ResponseHandler<S>): TypedEvent<S, E, P> {\n    this.registry.unregisterResponse(this.handlerId, handler);\n    return this;\n  }\n\n  /** Persistent error handler; every one registered for the type runs, in order */\n  onError<T extends E['type']>(errorType: T, handler: ErrorHandler<ErrorOfType<E, T>>): TypedEvent<S, E, P> {\n    this.registry.register(this.handlerId, errorType, handler as ErrorHandler<any>);\n    return this;\n  }\n\n  /** Remove this error handler; the others for the type stay */\n  offError<T extends E['type']>(errorType: T, handler: ErrorHandler<ErrorOfType<E, T>>): TypedEvent<S, E, P> {\n    this.registry.unregister(this.handlerId, errorType, handler as ErrorHandler<any>);\n    return this;\n  }\n\n  /** Get the handler ID this event is associated with */\n  getHandlerId(): string {\n    return this.handlerId;\n  }\n\n  /** Check if an error handler is registered for a specific error type */\n  hasErrorHandler(errorType: string): boolean {\n    return this.registry.hasHandler(this.handlerId, errorType);\n  }\n\n  /** Check if a response handler is registered */\n  hasResponseHandler(): boolean {\n    return this.registry.hasResponseHandler(this.handlerId);\n  }\n\n  /** Check if a request handler is registered */\n  hasRequestHandler(): boolean {\n    return this.registry.hasRequestHandler(this.handlerId);\n  }\n}\n"],"mappings":"mEAYA,IAAa,WAAb,KAAoG,CAE/E,UACA,SACA,iBAHnB,YACE,UACA,SACA,iBACA,CAHiB,KAAA,UAAA,UACA,KAAA,SAAA,SACA,KAAA,iBAAA,gBAChB,CAGH,UAAU,QAAiD,CACzD,GAAI,CAAC,KAAK,iBAAkB,MAAM,IAAI,MAAM,oDAAoD,KAAK,SAAA,YAAqB,EAC1H,YAAK,SAAS,gBAAgB,KAAK,UAAW,QAAS,KAAK,gBAAgB,EACrE,IACT,CAGA,YAAkC,CAChC,YAAK,SAAS,kBAAkB,KAAK,SAAS,EACvC,IACT,CAGA,WAAW,QAAkD,CAC3D,YAAK,SAAS,iBAAiB,KAAK,UAAW,OAAO,EAC/C,IACT,CAGA,YAAY,QAAkD,CAC5D,YAAK,SAAS,mBAAmB,KAAK,UAAW,OAAO,EACjD,IACT,CAGA,QAA6B,UAAc,QAA+D,CACxG,YAAK,SAAS,SAAS,KAAK,UAAW,UAAW,OAA4B,EACvE,IACT,CAGA,SAA8B,UAAc,QAA+D,CACzG,YAAK,SAAS,WAAW,KAAK,UAAW,UAAW,OAA4B,EACzE,IACT,CAGA,cAAuB,CACrB,OAAO,KAAK,SACd,CAGA,gBAAgB,UAA4B,CAC1C,OAAO,KAAK,SAAS,WAAW,KAAK,UAAW,SAAS,CAC3D,CAGA,oBAA8B,CAC5B,OAAO,KAAK,SAAS,mBAAmB,KAAK,SAAS,CACxD,CAGA,mBAA6B,CAC3B,OAAO,KAAK,SAAS,kBAAkB,KAAK,SAAS,CACvD,CACF"}

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

@@ -1,18 +1,20 @@
 import { RpcError } from '@mionjs/core';
 import { HandlersRegistry } from './handlersRegistry.ts';
-import { SuccessHandler } from '../types.ts';
-export declare class TypedEvent<S = void, E extends RpcError<string, any> = never> {
+import { ErrorHandler, ErrorOfType, RequestHandler, ResponseHandler, SubRequest } from '../types.ts';
+export declare class TypedEvent<S = void, E extends RpcError<string, any> = never, P extends any[] = any[]> {
     private readonly handlerId;
     private readonly registry;
-    constructor(handlerId: string, registry: HandlersRegistry);
-    onSuccess(handler: SuccessHandler<S>): TypedEvent<S, E>;
-    offSuccess(): TypedEvent<S, E>;
-    onError<T extends E['type']>(errorType: T, handler: (error: Extract<E, {
-        type: T;
-    }>) => void): TypedEvent<S, E>;
-    offError<T extends E['type']>(errorType: T): TypedEvent<S, E>;
+    private readonly createSubRequest?;
+    constructor(handlerId: string, registry: HandlersRegistry, createSubRequest?: ((params: any[]) => SubRequest<any>) | undefined);
+    onRequest(handler: RequestHandler<P>): TypedEvent<S, E, P>;
+    offRequest(): TypedEvent<S, E, P>;
+    onResponse(handler: ResponseHandler<S>): TypedEvent<S, E, P>;
+    offResponse(handler: ResponseHandler<S>): TypedEvent<S, E, P>;
+    onError<T extends E['type']>(errorType: T, handler: ErrorHandler<ErrorOfType<E, T>>): TypedEvent<S, E, P>;
+    offError<T extends E['type']>(errorType: T, handler: ErrorHandler<ErrorOfType<E, T>>): TypedEvent<S, E, P>;
     getHandlerId(): string;
     hasErrorHandler(errorType: string): boolean;
-    hasSuccessHandler(): boolean;
+    hasResponseHandler(): boolean;
+    hasRequestHandler(): boolean;
 }
 //# sourceMappingURL=typedEvent.d.ts.map

package/.dist/cjs/src/lib/validation.cjs

@@ -1,2 +1,3 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const core=require("@mionjs/core");function validateSubRequests(subRequestIds,req,errors,validateRouteMiddleFns=!0){req.options.validateParams&&subRequestIds.forEach(id=>{const subRequest=req.subRequestList[id];validateSubRequest(id,subRequest,errors);const methodMeta=core.routesCache.getMetadata(id);if(validateRouteMiddleFns&&methodMeta?.middleFnIds?.length){const validMiddleFnIds=methodMeta.middleFnIds.filter(middleFnId=>middleFnId!=null);validateSubRequests(validMiddleFnIds,req,errors,validateRouteMiddleFns)}})}function validateSubRequest(id,subRequest,errors){if(subRequest?.error||subRequest?.isResolved)return;const mappings=subRequest?.mappings;if(Array.isArray(mappings)&&mappings.length>0)return;const params=subRequest?.params||[],validationResponse=getTypeErrors(id,params);if(!validationResponse)return;const error=validationResponse;errors.set(id,error),subRequest&&(subRequest.error=error,subRequest.isResolved=!0)}function getTypeErrors(id,params){const method=core.routesCache.useMethodJitFns(id);if(!method.paramNames||method.paramNames.length===0)return;const paramsJit=method.paramsJitFns;if(!paramsJit.typeErrors.isNoop)try{const validationsResponse=paramsJit.isType.fn(params)||paramsJit.typeErrors.fn(params);if(validationsResponse?.length)return new core.RpcError({type:"validation-error",publicMessage:`Invalid params for Route or MiddleFn '${method.id}', validation failed.`,errorData:validationsResponse})}catch(e){return new core.RpcError({type:"unexpected-validation-error",publicMessage:`Could not validate params for Route or MiddleFn '${method.id}': ${e.message} `})}}exports.validateSubRequest=validateSubRequest;exports.validateSubRequests=validateSubRequests;
-//# sourceMappingURL=validation.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_lib_methods=require("./methods.cjs");let _mionjs_core=require("@mionjs/core");function validateSubRequests(subRequestIds,context,errors,validateRouteMiddlewares=!0){context.options.validateParams&&subRequestIds.forEach(id=>{const subRequest=context.subRequestList[id];validateSubRequest(id,subRequest,errors);const methodMeta=require_src_lib_methods.getMethod(id);validateRouteMiddlewares&&methodMeta?.middlewareIds?.length&&validateSubRequests(methodMeta.middlewareIds.filter(middlewareId=>middlewareId!=null),context,errors,validateRouteMiddlewares)})}function validateSubRequest(id,subRequest,errors){if(subRequest?.error||subRequest?.isResolved||subRequest?.mappings&&subRequest.mappings.length>0)return;const validationResponse=getTypeErrors(id,subRequest?.params||[]);if(!validationResponse)return;const error=validationResponse;errors.set(id,error),subRequest&&(subRequest.error=error,subRequest.isResolved=!0)}function getResponseError(id,value){const method=require_src_lib_methods.useMethodFns(id);if(method.hasReturnData){if(method.headersReturn){if(!(value instanceof _mionjs_core.HeadersSubset))return;const jitFns=method.headersReturn.jitFns;return checkValue(method.id,jitFns,value,"response-validation-error","response-validation-error","headers from")}return checkValue(method.id,method.returnJitFns,value,"response-validation-error","response-validation-error","response from")}}function getTypeErrors(id,params){const method=require_src_lib_methods.useMethodFns(id);if(method.paramsCount)return checkValue(method.id,method.paramsJitFns,params,"validation-error","unexpected-validation-error","params for")}function checkValue(methodId,jitFns,value,invalidType,failedType,subject){if(!jitFns.isType.isNoop)try{return jitFns.isType.fn(value)?void 0:new _mionjs_core.RpcError({type:invalidType,publicMessage:`Invalid ${subject} Route or Middleware '${methodId}', validation failed.`,errorData:{typeErrors:jitFns.typeErrors.fn(value)}})}catch(err){return new _mionjs_core.RpcError({type:failedType,publicMessage:`Could not validate ${subject} Route or Middleware '${methodId}': ${err.message}`})}}exports.getResponseError=getResponseError;exports.validateSubRequest=validateSubRequest;exports.validateSubRequests=validateSubRequests;
+
+//# sourceMappingURL=validation.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"validation.cjs","sources":["../../../../src/lib/validation.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {RpcError, routesCache} from '@mionjs/core';\nimport {RequestErrors, SubRequest} from '../types.ts';\nimport type {MionClientRequest} from '../request.ts';\n\n/** Validate subRequests locally using existing RemoteApi metadata */\nexport function validateSubRequests(\n    subRequestIds: string[],\n    req: MionClientRequest<any, any>,\n    errors: RequestErrors,\n    validateRouteMiddleFns = true\n): void {\n    if (!req.options.validateParams) return;\n    subRequestIds.forEach((id) => {\n        const subRequest = req.subRequestList[id];\n        validateSubRequest(id, subRequest, errors);\n        const methodMeta = routesCache.getMetadata(id);\n        if (validateRouteMiddleFns && methodMeta?.middleFnIds?.length) {\n            const validMiddleFnIds = methodMeta.middleFnIds.filter((middleFnId) => middleFnId != null);\n            validateSubRequests(validMiddleFnIds, req, errors, validateRouteMiddleFns);\n        }\n    });\n    return;\n}\n\n/** Validate subRequest locally using existing RemoteApi metadata */\nexport function validateSubRequest(id: string, subRequest: SubRequest<any>, errors: RequestErrors): void {\n    if (subRequest?.error || subRequest?.isResolved) return;\n    // Skip validation for subrequests with mapFrom mappings — params contain null placeholders\n    // that will be filled by the server's mapping step after the source route executes\n    const mappings = (subRequest as any)?.mappings;\n    if (Array.isArray(mappings) && mappings.length > 0) return;\n\n    const params = subRequest?.params || [];\n    const validationResponse = getTypeErrors(id, params);\n    if (!validationResponse) return;\n    const error = validationResponse;\n    errors.set(id, error);\n    if (subRequest) {\n        subRequest.error = error;\n        subRequest.isResolved = true;\n    }\n    return;\n}\n\nfunction getTypeErrors(id: string, params: any[]): void | RpcError<'validation-error' | 'unexpected-validation-error'> {\n    const method = routesCache.useMethodJitFns(id);\n    if (!method.paramNames || method.paramNames.length === 0) return;\n    const paramsJit = method.paramsJitFns;\n    if (paramsJit.typeErrors.isNoop) return;\n    try {\n        const validationsResponse = paramsJit.isType.fn(params) || paramsJit.typeErrors.fn(params);\n        if ((validationsResponse as [])?.length) {\n            return new RpcError({\n                type: 'validation-error',\n                publicMessage: `Invalid params for Route or MiddleFn '${method.id}', validation failed.`,\n                errorData: validationsResponse,\n            });\n        }\n    } catch (e: any | Error) {\n        return new RpcError({\n            type: 'unexpected-validation-error',\n            publicMessage: `Could not validate params for Route or MiddleFn '${method.id}': ${e.message} `,\n        });\n    }\n}\n"],"names":["routesCache","RpcError"],"mappings":"mHAYM,SAAU,oBACZ,cACA,IACA,OACA,uBAAyB,GAAI,CAExB,IAAI,QAAQ,gBACjB,cAAc,QAAS,IAAM,CACzB,MAAM,WAAa,IAAI,eAAe,EAAE,EACxC,mBAAmB,GAAI,WAAY,MAAM,EACzC,MAAM,WAAaA,KAAAA,YAAY,YAAY,EAAE,EAC7C,GAAI,wBAA0B,YAAY,aAAa,OAAQ,CAC3D,MAAM,iBAAmB,WAAW,YAAY,OAAQ,YAAe,YAAc,IAAI,EACzF,oBAAoB,iBAAkB,IAAK,OAAQ,sBAAsB,CAC7E,CACJ,CAAC,CAEL,UAGgB,mBAAmB,GAAY,WAA6B,OAAqB,CAC7F,GAAI,YAAY,OAAS,YAAY,WAAY,OAGjD,MAAM,SAAY,YAAoB,SACtC,GAAI,MAAM,QAAQ,QAAQ,GAAK,SAAS,OAAS,EAAG,OAEpD,MAAM,OAAS,YAAY,QAAU,CAAA,EAC/B,mBAAqB,cAAc,GAAI,MAAM,EACnD,GAAI,CAAC,mBAAoB,OACzB,MAAM,MAAQ,mBACd,OAAO,IAAI,GAAI,KAAK,EAChB,aACA,WAAW,MAAQ,MACnB,WAAW,WAAa,GAGhC,CAEA,SAAS,cAAc,GAAY,OAAa,CAC5C,MAAM,OAASA,KAAAA,YAAY,gBAAgB,EAAE,EAC7C,GAAI,CAAC,OAAO,YAAc,OAAO,WAAW,SAAW,EAAG,OAC1D,MAAM,UAAY,OAAO,aACzB,GAAI,WAAU,WAAW,OACzB,GAAI,CACA,MAAM,oBAAsB,UAAU,OAAO,GAAG,MAAM,GAAK,UAAU,WAAW,GAAG,MAAM,EACzF,GAAK,qBAA4B,OAC7B,OAAO,IAAIC,KAAAA,SAAS,CAChB,KAAM,mBACN,cAAe,yCAAyC,OAAO,EAAE,wBACjE,UAAW,mBAAA,CACd,CAET,OAAS,EAAgB,CACrB,OAAO,IAAIA,KAAAA,SAAS,CAChB,KAAM,8BACN,cAAe,oDAAoD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAA,CAC9F,CACL,CACJ"}
+{"version":3,"file":"validation.cjs","names":[],"sources":["../../../../src/lib/validation.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 {HeadersSubset, RpcError} from '@mionjs/core';\nimport {getMethod, useMethodFns} from './methods.ts';\nimport type {JitCompiledFunctions, RunTypeError, ValidationErrorData} from '@mionjs/core';\nimport type {CallContext, RequestErrors, SubRequest} from '../types.ts';\n\nexport function validateSubRequests(\n  subRequestIds: string[],\n  context: CallContext,\n  errors: RequestErrors,\n  validateRouteMiddlewares = true\n): void {\n  if (!context.options.validateParams) return;\n  subRequestIds.forEach((id) => {\n    const subRequest = context.subRequestList[id];\n    validateSubRequest(id, subRequest, errors);\n    const methodMeta = getMethod(id);\n    if (validateRouteMiddlewares && methodMeta?.middlewareIds?.length) {\n      const validMiddlewareIds = methodMeta.middlewareIds.filter((middlewareId) => middlewareId != null);\n      validateSubRequests(validMiddlewareIds, context, errors, validateRouteMiddlewares);\n    }\n  });\n  return;\n}\n\nexport function validateSubRequest(id: string, subRequest: SubRequest<any>, errors: RequestErrors): void {\n  if (subRequest?.error || subRequest?.isResolved) return;\n  // inputFrom params hold null placeholders the server fills after the source route runs\n  if (subRequest?.mappings && subRequest.mappings.length > 0) return;\n\n  const params = subRequest?.params || [];\n  const validationResponse = getTypeErrors(id, params);\n  if (!validationResponse) return;\n  const error = validationResponse;\n  errors.set(id, error);\n  if (subRequest) {\n    subRequest.error = error;\n    subRequest.isResolved = true;\n  }\n  return;\n}\n\n/** An answer the return type does not describe; undefined when it matches or the method returns nothing. */\nexport function getResponseError(id: string, value: unknown) {\n  const method = useMethodFns(id);\n  if (!method.hasReturnData) return;\n  if (method.headersReturn) {\n    // no header on the wire can be a valid void return\n    if (!(value instanceof HeadersSubset)) return;\n    const jitFns = method.headersReturn.jitFns as JitCompiledFunctions;\n    return checkValue(method.id, jitFns, value, 'response-validation-error', 'response-validation-error', 'headers from');\n  }\n  return checkValue(\n    method.id,\n    method.returnJitFns,\n    value,\n    'response-validation-error',\n    'response-validation-error',\n    'response from'\n  );\n}\n\nfunction getTypeErrors(id: string, params: any[]) {\n  const method = useMethodFns(id);\n  if (!method.paramsCount) return;\n  // No separate strict pass: the parser strategy's key check is compiled into isType.\n  return checkValue(method.id, method.paramsJitFns, params, 'validation-error', 'unexpected-validation-error', 'params for');\n}\n\n/** typeErrors runs only on a miss, and a validator that throws is reported, never raised. */\nfunction checkValue<Invalid extends string, Failed extends string>(\n  methodId: string,\n  jitFns: JitCompiledFunctions,\n  value: unknown,\n  invalidType: Invalid,\n  failedType: Failed,\n  subject: string\n): RpcError<Invalid, ValidationErrorData> | RpcError<Failed> | undefined {\n  if (jitFns.isType.isNoop) return;\n  try {\n    if (jitFns.isType.fn(value)) return;\n    return new RpcError<Invalid, ValidationErrorData>({\n      type: invalidType,\n      publicMessage: `Invalid ${subject} Route or Middleware '${methodId}', validation failed.`,\n      errorData: {typeErrors: jitFns.typeErrors.fn(value) as RunTypeError[]},\n    });\n  } catch (err: any) {\n    return new RpcError<Failed>({\n      type: failedType,\n      publicMessage: `Could not validate ${subject} Route or Middleware '${methodId}': ${err.message}`,\n    });\n  }\n}\n"],"mappings":"mKAYA,SAAgB,oBACd,cACA,QACA,OACA,yBAA2B,GACrB,CACD,QAAQ,QAAQ,gBACrB,cAAc,QAAS,IAAO,CAC5B,MAAM,WAAa,QAAQ,eAAe,EAAA,EAC1C,mBAAmB,GAAI,WAAY,MAAM,EACzC,MAAM,WAAa,wBAAA,UAAU,EAAE,EAC3B,0BAA4B,YAAY,eAAe,QAEzD,oBAD2B,WAAW,cAAc,OAAQ,cAAiB,cAAgB,IACzE,EAAoB,QAAS,OAAQ,wBAAwB,CAErF,CAAC,CAEH,CAEA,SAAgB,mBAAmB,GAAY,WAA6B,OAA6B,CAGvG,GAFI,YAAY,OAAS,YAAY,YAEjC,YAAY,UAAY,WAAW,SAAS,OAAS,EAAG,OAG5D,MAAM,mBAAqB,cAAc,GAD1B,YAAY,QAAU,CAAC,CACa,EACnD,GAAI,CAAC,mBAAoB,OACzB,MAAM,MAAQ,mBACd,OAAO,IAAI,GAAI,KAAK,EAChB,aACF,WAAW,MAAQ,MACnB,WAAW,WAAa,GAG5B,CAGA,SAAgB,iBAAiB,GAAY,MAAgB,CAC3D,MAAM,OAAS,wBAAA,aAAa,EAAE,EAC9B,GAAK,OAAO,cACZ,IAAI,OAAO,cAAe,CAExB,GAAI,EAAE,iBAAiB,aAAA,eAAgB,OACvC,MAAM,OAAS,OAAO,cAAc,OACpC,OAAO,WAAW,OAAO,GAAI,OAAQ,MAAO,4BAA6B,4BAA6B,cAAc,CACtH,CACA,OAAO,WACL,OAAO,GACP,OAAO,aACP,MACA,4BACA,4BACA,eACF,EACF,CAEA,SAAS,cAAc,GAAY,OAAe,CAChD,MAAM,OAAS,wBAAA,aAAa,EAAE,EAC9B,GAAK,OAAO,YAEZ,OAAO,WAAW,OAAO,GAAI,OAAO,aAAc,OAAQ,mBAAoB,8BAA+B,YAAY,CAC3H,CAGA,SAAS,WACP,SACA,OACA,MACA,YACA,WACA,QACuE,CACvE,GAAI,QAAO,OAAO,OAClB,GAAI,CACF,OAAI,OAAO,OAAO,GAAG,KAAK,EAAG,OACtB,IAAI,aAAA,SAAuC,CAChD,KAAM,YACN,cAAe,WAAW,OAAA,yBAAgC,QAAA,wBAC1D,UAAW,CAAC,WAAY,OAAO,WAAW,GAAG,KAAK,CAAmB,CACvE,CAAC,CACH,OAAS,IAAU,CACjB,OAAO,IAAI,aAAA,SAAiB,CAC1B,KAAM,WACN,cAAe,sBAAsB,OAAA,yBAAgC,QAAA,MAAc,IAAI,OAAA,EACzF,CAAC,CACH,CACF"}

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

@@ -1,5 +1,6 @@
-import { RequestErrors, SubRequest } from '../types.ts';
-import { MionClientRequest } from '../request.ts';
-export declare function validateSubRequests(subRequestIds: string[], req: MionClientRequest<any, any>, errors: RequestErrors, validateRouteMiddleFns?: boolean): void;
+import { RpcError } from '@mionjs/core';
+import { CallContext, RequestErrors, SubRequest } from '../types.ts';
+export declare function validateSubRequests(subRequestIds: string[], context: CallContext, errors: RequestErrors, validateRouteMiddlewares?: boolean): void;
 export declare function validateSubRequest(id: string, subRequest: SubRequest<any>, errors: RequestErrors): void;
+export declare function getResponseError(id: string, value: unknown): RpcError<"response-validation-error", any> | undefined;
 //# sourceMappingURL=validation.d.ts.map

package/.dist/cjs/src/middlewares/fetchMetadata.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_lib_methods=require("../lib/methods.cjs"),require_src_callContext=require("../callContext.cjs"),require_src_lib_apiBuildVersion=require("../lib/apiBuildVersion.cjs"),require_src_lib_metadataFetcher=require("../lib/metadataFetcher.cjs"),require_src_lib_metadataFromServerLoader=require("../lib/metadataFromServerLoader.cjs");let _mionjs_core=require("@mionjs/core");function useFetchMetadata(middleware){const{id,registry}=require_src_lib_metadataFetcher.middlewareTargetOf(middleware);require_src_lib_metadataFetcher.setMetadataFetcher(registry,createFetcher(id))}function createFetcher(id){const fetchRows=async(ids,routePointer,options,signal)=>{await(await require_src_lib_metadataFromServerLoader.loadMetadataFromServer()).fetchRemoteMethodsMetadata(ids,routePointer,options,signal,id)};return{fetchRows,startCall:context=>startCall(id,context,fetchRows)}}function failedOnWire(errors){for(const error of errors.values()){const type=error?.type;if(type==="serialization-error"||type==="validation-error"||type==="parsing-json-request-error")return!0}return!1}function startCall(id,context,fetchRows){const{options}=context;let optimistic=!1,verifying,callIds=[];const addRowsRequest=ids=>{context.subRequestList[id]={pointer:id.split("/"),id,isResolved:!1,params:[ids]}};return{id,async prepare(skipOptimistic){delete context.subRequestList[id];const ids=Object.keys(context.subRequestList);if(callIds=ids,verifying=void 0,optimistic=!1,!ids.every(methodId=>require_src_lib_methods.hasMethod(methodId)))return await(await require_src_lib_metadataFromServerLoader.loadMetadataFromServer()).hydrateMetadataCache(options),optimistic=!skipOptimistic&&!ids.every(methodId=>require_src_lib_methods.hasMethod(methodId)),{ids,optimistic};if(require_src_lib_apiBuildVersion.hasApiVersionMismatch(options.baseURL)&&require_src_lib_methods.hasMethod(id)){const unverified=(await require_src_lib_metadataFromServerLoader.loadMetadataFromServer()).unverifiedIds(options.baseURL,ids);unverified.length&&(verifying=unverified,addRowsRequest(unverified))}return{ids,optimistic}},askRows(){addRowsRequest(Object.keys(context.subRequestList).filter(methodId=>!require_src_lib_methods.hasMethod(methodId)))},fetchRows(ids,signal){return fetchRows(ids,require_src_callContext.getRoutePointers(context)[0]??Object.values(context.subRequestList)[0].pointer,options,signal)},readRows(parsedBody){if(!(id in parsedBody))return;const slot=parsedBody[id];delete parsedBody[id];const value=Array.isArray(slot)?slot[1]:slot;if((0,_mionjs_core.isRpcError)(value))return{[id]:new _mionjs_core.RpcError(value)};const rows=value,lane=require_src_lib_metadataFromServerLoader.loadedMetadataFromServer();!rows?.methods||!lane||(verifying?lane.verifyMethodRows(options,verifying,rows):lane.installMethodRows(rows,options))},async shouldResend(errors){if(!failedOnWire(errors)||context.signal?.aborted)return!1;if(optimistic)return!0;const lane=require_src_lib_metadataFromServerLoader.loadedMetadataFromServer();return lane&&callIds.some(methodId=>lane.wasHydratedFromCache(methodId,options))?(await lane.purgeHydratedMetadata(callIds,options),!0):require_src_lib_apiBuildVersion.hasApiVersionMismatch(options.baseURL)},takeError:()=>require_src_lib_metadataFromServerLoader.loadedMetadataFromServer()?.takeMetadataCacheError()}}exports.useFetchMetadata=useFetchMetadata;
+
+//# sourceMappingURL=fetchMetadata.cjs.map

package/.dist/cjs/src/middlewares/fetchMetadata.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchMetadata.cjs","names":[],"sources":["../../../../src/middlewares/fetchMetadata.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 {isRpcError, RpcError} from '@mionjs/core';\nimport type {SerializableMethodsData} from '@mionjs/core';\nimport type {FetchMetadataHandler as Handler} from '@mionjs/core/middlewares';\nimport type {ClientCallContext, ClientMiddlewareOf, RequestErrors, SubRequest} from '../types.ts';\nimport {getRoutePointers} from '../callContext.ts';\nimport {hasApiVersionMismatch} from '../lib/apiBuildVersion.ts';\nimport {hasMethod} from '../lib/methods.ts';\nimport {loadedMetadataFromServer, loadMetadataFromServer} from '../lib/metadataFromServerLoader.ts';\nimport {middlewareTargetOf, setMetadataFetcher, type MetadataCall, type MetadataFetcher} from '../lib/metadataFetcher.ts';\n\n/** Client half of `mionFetchMetadata`: fetches unbundled routes' rows on first use. */\nexport function useFetchMetadata(middleware: ClientMiddlewareOf<Handler>): void {\n  const {id, registry} = middlewareTargetOf(middleware);\n  setMetadataFetcher(registry, createFetcher(id));\n}\n\nfunction createFetcher(id: string): MetadataFetcher {\n  const fetchRows: MetadataFetcher['fetchRows'] = async (ids, routePointer, options, signal) => {\n    const lane = await loadMetadataFromServer();\n    await lane.fetchRemoteMethodsMetadata(ids, routePointer, options, signal, id);\n  };\n  return {fetchRows, startCall: (context) => startCall(id, context, fetchRows)};\n}\n\n/** The errors plain wire forms or stale rows cause: the server could not read what the client wrote. */\nfunction failedOnWire(errors: RequestErrors): boolean {\n  for (const error of errors.values()) {\n    const type = error?.type;\n    if (type === 'serialization-error' || type === 'validation-error' || type === 'parsing-json-request-error') return true;\n  }\n  return false;\n}\n\nfunction startCall(id: string, context: ClientCallContext, fetchRows: MetadataFetcher['fetchRows']): MetadataCall {\n  const {options} = context;\n  let optimistic = false;\n  /** ids this attempt asked the server to confirm after a version mismatch */\n  let verifying: string[] | undefined;\n  let callIds: string[] = [];\n\n  const addRowsRequest = (ids: string[]) => {\n    context.subRequestList[id] = {pointer: id.split('/'), id, isResolved: false, params: [ids]} as SubRequest<any>;\n  };\n\n  return {\n    id,\n\n    async prepare(skipOptimistic) {\n      delete context.subRequestList[id];\n      const ids = Object.keys(context.subRequestList);\n      callIds = ids;\n      verifying = undefined;\n      optimistic = false;\n      if (!ids.every((methodId) => hasMethod(methodId))) {\n        // One indexed read settles an id this page never heard of; guessing wrong costs a round trip AND its resend.\n        await (await loadMetadataFromServer()).hydrateMetadataCache(options);\n        optimistic = !skipOptimistic && !ids.every((methodId) => hasMethod(methodId));\n        return {ids, optimistic};\n      }\n      // After a version mismatch each route is confirmed once, on first use, riding this request.\n      // Needs the middleware's own row: it encodes the ids, and a server that never placed it cannot confirm.\n      if (hasApiVersionMismatch(options.baseURL) && hasMethod(id)) {\n        const unverified = (await loadMetadataFromServer()).unverifiedIds(options.baseURL, ids);\n        if (unverified.length) {\n          verifying = unverified;\n          addRowsRequest(unverified);\n        }\n      }\n      return {ids, optimistic};\n    },\n\n    askRows() {\n      // Storing the server's copy over a BUNDLED method would let a later purge drop it for good.\n      addRowsRequest(Object.keys(context.subRequestList).filter((methodId) => !hasMethod(methodId)));\n    },\n\n    fetchRows(ids, signal) {\n      // sent to a route of this call, whose chain holds the metadata middleware\n      const pointer = getRoutePointers(context)[0] ?? Object.values(context.subRequestList)[0].pointer;\n      return fetchRows(ids, pointer, options, signal);\n    },\n\n    readRows(parsedBody) {\n      if (!(id in parsedBody)) return;\n      const slot = parsedBody[id];\n      delete parsedBody[id];\n      // a union answer rides the `[index, value]` envelope\n      const value = Array.isArray(slot) ? slot[1] : slot;\n      if (isRpcError(value)) return {[id]: new RpcError(value)};\n      const rows = value as SerializableMethodsData | undefined;\n      // only an attempt that loaded the lane asks for rows\n      const lane = loadedMetadataFromServer();\n      if (!rows?.methods || !lane) return;\n      if (verifying) lane.verifyMethodRows(options, verifying, rows);\n      else lane.installMethodRows(rows, options);\n    },\n\n    async shouldResend(errors) {\n      if (!failedOnWire(errors) || context.signal?.aborted) return false;\n      // the server read plain wire forms its decoders refused; the real encoders fix that\n      if (optimistic) return true;\n      // stored rows can predate the server's current build and nothing else would correct them\n      const lane = loadedMetadataFromServer();\n      if (lane && callIds.some((methodId) => lane.wasHydratedFromCache(methodId, options))) {\n        await lane.purgeHydratedMetadata(callIds, options);\n        return true;\n      }\n      // the server's build differs: the resend confirms the rows this call uses, and refreshes fetched ones\n      return hasApiVersionMismatch(options.baseURL);\n    },\n\n    takeError: () => loadedMetadataFromServer()?.takeMetadataCacheError(),\n  };\n}\n"],"mappings":"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"}

package/.dist/cjs/src/middlewares/fetchMetadata.d.ts

@@ -0,0 +1,4 @@
+import { FetchMetadataHandler as Handler } from '@mionjs/core/middlewares';
+import { ClientMiddlewareOf } from '../types.ts';
+export declare function useFetchMetadata(middleware: ClientMiddlewareOf<Handler>): void;
+//# sourceMappingURL=fetchMetadata.d.ts.map

package/.dist/cjs/src/middlewares/syncRoutes.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_lib_methods=require("../lib/methods.cjs"),require_src_lib_metadataFetcher=require("../lib/metadataFetcher.cjs"),require_src_lib_metadataFromServerLoader=require("../lib/metadataFromServerLoader.cjs");function useSyncRoutes(middleware){middleware.onRequest((call,context)=>call(routeSyncIds(context))),middleware.onError("route-sync-required",async(refusal,context)=>{const rows=refusal.errorData?.metadata;rows?.methods&&(await require_src_lib_metadataFromServerLoader.loadMetadataFromServer()).installMethodRows(rows,context.options,Object.keys(rows.methods)),context.retry()}),middleware.onError("route-types-mismatch",async(refusal,context)=>{const refusedIds=refusal.errorData?.routeIds,fetcher=require_src_lib_metadataFetcher.metadataFetcherOf(middleware);!fetcher||!refusedIds?.length||refusedIds.some(id=>require_src_lib_methods.isBundledMethod(id))||(await(await require_src_lib_metadataFromServerLoader.loadMetadataFromServer()).forgetFetchedMetadata(refusedIds,context.options),await fetcher.fetchRows(refusedIds,refusedIds[0].split("/"),context.options,context.signal),context.retry())})}function routeSyncIds(context){return(context.batchSubRequests?.length?context.batchSubRequests:context.route?[context.route]:[]).map(route=>require_src_lib_methods.getMethod(route.id)?.syncId??"")}exports.useSyncRoutes=useSyncRoutes;
+
+//# sourceMappingURL=syncRoutes.cjs.map

package/.dist/cjs/src/middlewares/syncRoutes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncRoutes.cjs","names":[],"sources":["../../../../src/middlewares/syncRoutes.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 type {SyncRoutesHandler} from '@mionjs/core/middlewares';\nimport type {CallContext, ClientMiddlewareOf} from '../types.ts';\nimport {getMethod, isBundledMethod} from '../lib/methods.ts';\nimport {loadMetadataFromServer} from '../lib/metadataFromServerLoader.ts';\nimport {metadataFetcherOf} from '../lib/metadataFetcher.ts';\n\n/** Client half of `mionSyncRoutes`: sends each route's sync id, and resends once when the server asks for it. */\nexport function useSyncRoutes(middleware: ClientMiddlewareOf<SyncRoutesHandler>): void {\n  middleware.onRequest((call, context) => call(routeSyncIds(context)));\n\n  // no route ran, so a resend is always allowed\n  middleware.onError('route-sync-required', async (refusal, context) => {\n    const rows = refusal.errorData?.metadata;\n    if (rows?.methods) (await loadMetadataFromServer()).installMethodRows(rows, context.options, Object.keys(rows.methods));\n    context.retry();\n  });\n\n  // a fetched row is a cache of the server's and can be relearned; a bundled one needs a new build\n  middleware.onError('route-types-mismatch', async (refusal, context) => {\n    const refusedIds = refusal.errorData?.routeIds;\n    const fetcher = metadataFetcherOf(middleware);\n    if (!fetcher || !refusedIds?.length || refusedIds.some((id) => isBundledMethod(id))) return;\n    await (await loadMetadataFromServer()).forgetFetchedMetadata(refusedIds, context.options);\n    // fetched here rather than on a second refusal: a call gets one resend per middleware\n    await fetcher.fetchRows(refusedIds, refusedIds[0].split('/'), context.options, context.signal);\n    context.retry();\n  });\n}\n\n/** In the server's batch order; the server answers an '' id with the rows. */\nfunction routeSyncIds(context: CallContext): string[] {\n  const routes = context.batchSubRequests?.length ? context.batchSubRequests : context.route ? [context.route] : [];\n  return routes.map((route) => getMethod(route.id)?.syncId ?? '');\n}\n"],"mappings":"6RAcA,SAAgB,cAAc,WAAyD,CACrF,WAAW,UAAA,CAAW,KAAM,UAAY,KAAK,aAAa,OAAO,CAAC,CAAC,EAGnE,WAAW,QAAQ,sBAAuB,MAAO,QAAS,UAAY,CACpE,MAAM,KAAO,QAAQ,WAAW,SAC5B,MAAM,UAAU,MAAM,yCAAA,uBAAuB,GAAG,kBAAkB,KAAM,QAAQ,QAAS,OAAO,KAAK,KAAK,OAAO,CAAC,EACtH,QAAQ,MAAM,CAChB,CAAC,EAGD,WAAW,QAAQ,uBAAwB,MAAO,QAAS,UAAY,CACrE,MAAM,WAAa,QAAQ,WAAW,SAChC,QAAU,gCAAA,kBAAkB,UAAU,EACxC,CAAC,SAAW,CAAC,YAAY,QAAU,WAAW,KAAM,IAAO,wBAAA,gBAAgB,EAAE,CAAC,IAClF,MAAO,MAAM,yCAAA,uBAAuB,GAAG,sBAAsB,WAAY,QAAQ,OAAO,EAExF,MAAM,QAAQ,UAAU,WAAY,WAAW,CAAA,EAAG,MAAM,GAAG,EAAG,QAAQ,QAAS,QAAQ,MAAM,EAC7F,QAAQ,MAAM,EAChB,CAAC,CACH,CAGA,SAAS,aAAa,QAAgC,CAEpD,OADe,QAAQ,kBAAkB,OAAS,QAAQ,iBAAmB,QAAQ,MAAQ,CAAC,QAAQ,KAAK,EAAI,CAAC,GAClG,IAAK,OAAU,wBAAA,UAAU,MAAM,EAAE,GAAG,QAAU,EAAE,CAChE"}

package/.dist/cjs/src/middlewares/syncRoutes.d.ts

@@ -0,0 +1,4 @@
+import { SyncRoutesHandler } from '@mionjs/core/middlewares';
+import { ClientMiddlewareOf } from '../types.ts';
+export declare function useSyncRoutes(middleware: ClientMiddlewareOf<SyncRoutesHandler>): void;
+//# sourceMappingURL=syncRoutes.d.ts.map

package/.dist/cjs/src/subRequest.cjs

@@ -1,2 +1,3 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const core=require("@mionjs/core"),src_lib_typedEvent=require("./lib/typedEvent.cjs"),src_routesFlow=require("./routesFlow.cjs");class MionSubRequest{client;pointer;id;isResolved=!1;params;resolvedValue;error;serializedParams;mappings=[];constructor(parentProps,handlerId,argArray,client){this.client=client,this.pointer=[...parentProps],this.id=handlerId,this.params=argArray.map((arg,index)=>src_routesFlow.isMapFromRef(arg)?(arg.toRequestId=this.id,arg.paramIndex=index,this.mappings.push(arg),null):arg)}prefill(){const typedEvent=new src_lib_typedEvent.TypedEvent(this.id,this.client.handlersRegistry);return this.client.prefill(this).catch(errors=>{console.error("Prefill error:",findSubRequestError(this,errors))}),typedEvent}removePrefill(){return this.client.handlersRegistry.clearHandlers(this.id),this.client.removePrefill(this)}call(setup){const signal=setup?.signal,timeout=setup?.timeout;return!setup||!setup.otherRoutes&&!setup.middleFns?this.client.execute(this,void 0,void 0,signal,timeout):setup.otherRoutes&&setup.otherRoutes.length>0?this.executeWithOtherRoutes(setup.otherRoutes,setup.middleFns,signal,timeout):this.client.execute(this,void 0,setup.middleFns,signal,timeout)}async executeWithOtherRoutes(otherRoutes,middleFns,signal,timeout){const allRoutes=[this,...otherRoutes],[results,errors,mfR,mfE]=await this.client.execute(void 0,allRoutes,middleFns??{},signal,timeout),emptyResults=allRoutes.map(()=>{}),emptyErrors=allRoutes.map(()=>{});return[results??emptyResults,errors??emptyErrors,mfR,mfE]}typeErrors(){return this.client.typeErrors(this).catch(errors=>Promise.reject(findSubRequestError(this,errors)))}}function findSubRequestError(subRequest,errors){const specificError=errors.get(subRequest.id);if(specificError)return specificError;const firstError=errors.values().next().value;return firstError||new core.RpcError({type:"unknown-error",publicMessage:"An unknown error occurred"})}exports.MionSubRequest=MionSubRequest;exports.findSubRequestError=findSubRequestError;
-//# sourceMappingURL=subRequest.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_batch=require("./batch.cjs");let _mionjs_core=require("@mionjs/core");var MionSubRequest=class{client;pointer;id;isResolved=!1;params;resolvedValue;error;serializedParams;mappings=[];constructor(parentProps,handlerId,argArray,client){this.client=client,this.pointer=[...parentProps],this.id=handlerId,this.params=argArray.map((arg,index)=>require_src_batch.isInputFromRef(arg)?(arg.toRequestId=this.id,arg.paramIndex=index,this.mappings.push(arg),null):arg)}call(setup,apiMetadata){return this.client.useBundledApi(apiMetadata),this.client.execute(this,void 0,void 0,setup?.signal,setup?.timeout)}typeErrors(apiMetadata){return this.client.useBundledApi(apiMetadata),this.client.typeErrors(this).catch(errors=>Promise.reject(findSubRequestError(this,errors)))}};function findSubRequestError(subRequest,errors){const specificError=errors.get(subRequest.id);if(specificError)return specificError;const firstError=errors.values().next().value;return firstError||new _mionjs_core.RpcError({type:"unknown-error",publicMessage:"An unknown error occurred"})}exports.MionSubRequest=MionSubRequest;exports.findSubRequestError=findSubRequestError;
+
+//# sourceMappingURL=subRequest.cjs.map

package/.dist/cjs/src/subRequest.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"subRequest.cjs","sources":["../../../src/subRequest.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 {RpcError} from '@mionjs/core';\nimport type {RunTypeError} from '@mionjs/core';\nimport type {CallSetup, MiddlewareSubRequest, RequestErrors, RouteSubRequest, SubRequest} from './types.ts';\nimport type {MapFromServerFnRef} from '@mionjs/core';\nimport type {MionClient} from './client.ts';\nimport {TypedEvent} from './lib/typedEvent.ts';\nimport {isMapFromRef} from './routesFlow.ts';\n\n/** Implementation of both RouteSubRequest and MiddleFnSubRequest interfaces */\nexport class MionSubRequest<S = any, E extends RpcError<string, any> = any>\n    implements RouteSubRequest<any>, MiddlewareSubRequest<any>\n{\n    pointer: string[];\n    id: string;\n    isResolved: boolean = false;\n    params: any[];\n    resolvedValue?: S;\n    error?: E;\n    serializedParams?: any[];\n    mappings: MapFromServerFnRef[] = [];\n\n    constructor(\n        parentProps: string[],\n        handlerId: string,\n        argArray: any[],\n        readonly client: MionClient\n    ) {\n        this.pointer = [...parentProps];\n        this.id = handlerId;\n        this.params = argArray.map((arg, index) => {\n            if (isMapFromRef(arg)) {\n                arg.toRequestId = this.id;\n                arg.paramIndex = index;\n                this.mappings.push(arg);\n                return null;\n            }\n            return arg;\n        });\n    }\n\n    /** Prefills MiddleFn's parameters and returns TypedEvent for event handler registration */\n    prefill(): TypedEvent<S, E> {\n        const typedEvent = new TypedEvent<S, E>(this.id, this.client.handlersRegistry);\n\n        this.client.prefill(this as MiddlewareSubRequest<any>).catch((errors: RequestErrors) => {\n            console.error('Prefill error:', findSubRequestError(this, errors));\n        });\n\n        return typedEvent;\n    }\n\n    /** Removes prefilled value and clears any registered error handlers for this middleFn */\n    removePrefill(): Promise<void> {\n        this.client.handlersRegistry.clearHandlers(this.id);\n        return this.client.removePrefill(this as MiddlewareSubRequest<any>);\n    }\n\n    /** Calls a remote route with optional setup (middleFns, otherRoutes, signal, timeout) */\n    call(setup?: CallSetup<any, any>): Promise<any> {\n        const signal = setup?.signal;\n        const timeout = setup?.timeout;\n        if (!setup || (!setup.otherRoutes && !setup.middleFns)) {\n            return this.client.execute(this as unknown as RouteSubRequest<any>, undefined, undefined, signal, timeout);\n        }\n        if (setup.otherRoutes && setup.otherRoutes.length > 0) {\n            return this.executeWithOtherRoutes(setup.otherRoutes, setup.middleFns, signal, timeout);\n        }\n        return this.client.execute(this as unknown as RouteSubRequest<any>, undefined, setup.middleFns, signal, timeout);\n    }\n\n    private async executeWithOtherRoutes(\n        otherRoutes: RouteSubRequest<any>[],\n        middleFns?: Record<string, MiddlewareSubRequest<any>>,\n        signal?: AbortSignal,\n        timeout?: number\n    ): Promise<any> {\n        const allRoutes = [this as unknown as RouteSubRequest<any>, ...otherRoutes];\n        const [results, errors, mfR, mfE] = await this.client.execute(undefined, allRoutes, middleFns ?? {}, signal, timeout);\n        const emptyResults = allRoutes.map(() => undefined);\n        const emptyErrors = allRoutes.map(() => undefined);\n        return [results ?? emptyResults, errors ?? emptyErrors, mfR, mfE];\n    }\n\n    /** Validates parameters and returns type errors */\n    typeErrors(): Promise<RunTypeError[]> {\n        return this.client\n            .typeErrors(this as SubRequest<any>)\n            .catch((errors: RequestErrors) => Promise.reject(findSubRequestError(this, errors)));\n    }\n}\n\n/** Finds the most relevant error from the errors map for a given sub-request */\nexport function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string> {\n    const specificError = errors.get(subRequest.id);\n    if (specificError) return specificError;\n\n    const firstError = errors.values().next().value;\n    if (firstError) return firstError;\n\n    return new RpcError({\n        type: 'unknown-error',\n        publicMessage: 'An unknown error occurred',\n    });\n}\n"],"names":["isMapFromRef","TypedEvent","RpcError"],"mappings":"uNAgBa,cAAc,CAgBV,OAbb,QACA,GACA,WAAsB,GACtB,OACA,cACA,MACA,iBACA,SAAiC,CAAA,EAEjC,YACI,YACA,UACA,SACS,OAAkB,CAAlB,KAAA,OAAA,OAET,KAAK,QAAU,CAAC,GAAG,WAAW,EAC9B,KAAK,GAAK,UACV,KAAK,OAAS,SAAS,IAAI,CAAC,IAAK,QACzBA,eAAAA,aAAa,GAAG,GAChB,IAAI,YAAc,KAAK,GACvB,IAAI,WAAa,MACjB,KAAK,SAAS,KAAK,GAAG,EACf,MAEJ,GACV,CACL,CAGA,SAAO,CACH,MAAM,WAAa,IAAIC,8BAAiB,KAAK,GAAI,KAAK,OAAO,gBAAgB,EAE7E,YAAK,OAAO,QAAQ,IAAiC,EAAE,MAAO,QAAyB,CACnF,QAAQ,MAAM,iBAAkB,oBAAoB,KAAM,MAAM,CAAC,CACrE,CAAC,EAEM,UACX,CAGA,eAAa,CACT,YAAK,OAAO,iBAAiB,cAAc,KAAK,EAAE,EAC3C,KAAK,OAAO,cAAc,IAAiC,CACtE,CAGA,KAAK,MAA2B,CAC5B,MAAM,OAAS,OAAO,OAChB,QAAU,OAAO,QACvB,MAAI,CAAC,OAAU,CAAC,MAAM,aAAe,CAAC,MAAM,UACjC,KAAK,OAAO,QAAQ,KAAyC,OAAW,OAAW,OAAQ,OAAO,EAEzG,MAAM,aAAe,MAAM,YAAY,OAAS,EACzC,KAAK,uBAAuB,MAAM,YAAa,MAAM,UAAW,OAAQ,OAAO,EAEnF,KAAK,OAAO,QAAQ,KAAyC,OAAW,MAAM,UAAW,OAAQ,OAAO,CACnH,CAEQ,MAAM,uBACV,YACA,UACA,OACA,QAAgB,CAEhB,MAAM,UAAY,CAAC,KAAyC,GAAG,WAAW,EACpE,CAAC,QAAS,OAAQ,IAAK,GAAG,EAAI,MAAM,KAAK,OAAO,QAAQ,OAAW,UAAW,WAAa,CAAA,EAAI,OAAQ,OAAO,EAC9G,aAAe,UAAU,IAAI,IAAA,EAAe,EAC5C,YAAc,UAAU,IAAI,IAAA,EAAe,EACjD,MAAO,CAAC,SAAW,aAAc,QAAU,YAAa,IAAK,GAAG,CACpE,CAGA,YAAU,CACN,OAAO,KAAK,OACP,WAAW,IAAuB,EAClC,MAAO,QAA0B,QAAQ,OAAO,oBAAoB,KAAM,MAAM,CAAC,CAAC,CAC3F,CACH,CAGK,SAAU,oBAAoB,WAA6B,OAAqB,CAClF,MAAM,cAAgB,OAAO,IAAI,WAAW,EAAE,EAC9C,GAAI,cAAe,OAAO,cAE1B,MAAM,WAAa,OAAO,OAAA,EAAS,OAAO,MAC1C,OAAI,YAEG,IAAIC,KAAAA,SAAS,CAChB,KAAM,gBACN,cAAe,2BAAA,CAClB,CACL"}
+{"version":3,"file":"subRequest.cjs","names":[],"sources":["../../../src/subRequest.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 {RpcError} from '@mionjs/core';\nimport type {RunTypeError} from '@mionjs/core';\nimport type {CallSetup, RequestErrors, RouteSubRequest, SubRequest} from './types.ts';\nimport type {InjectedApiMetadata} from './types.ts';\n\nimport type {InputFromRef} from '@mionjs/core';\nimport type {MionClient} from './client.ts';\nimport {isInputFromRef} from './batch.ts';\n\nexport class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RouteSubRequest<any> {\n  pointer: string[];\n  id: string;\n  isResolved: boolean = false;\n  params: any[];\n  resolvedValue?: S;\n  error?: E;\n  serializedParams?: any[];\n  mappings: InputFromRef[] = [];\n\n  constructor(\n    parentProps: string[],\n    handlerId: string,\n    argArray: any[],\n    readonly client: MionClient\n  ) {\n    this.pointer = [...parentProps];\n    this.id = handlerId;\n    this.params = argArray.map((arg, index) => {\n      if (isInputFromRef(arg)) {\n        arg.toRequestId = this.id;\n        arg.paramIndex = index;\n        this.mappings.push(arg);\n        return null;\n      }\n      return arg;\n    });\n  }\n\n  /** `apiMetadata` is filled by the build when routes are bundled, never by hand. */\n  call(setup?: CallSetup, apiMetadata?: InjectedApiMetadata): Promise<any> {\n    this.client.useBundledApi(apiMetadata);\n    return this.client.execute(this as unknown as RouteSubRequest<any>, undefined, undefined, setup?.signal, setup?.timeout);\n  }\n\n  /** `apiMetadata` is filled by the build when routes are bundled, never by hand. */\n  typeErrors(apiMetadata?: InjectedApiMetadata): Promise<RunTypeError[]> {\n    this.client.useBundledApi(apiMetadata);\n    return this.client\n      .typeErrors(this as SubRequest<any>)\n      .catch((errors: RequestErrors) => Promise.reject(findSubRequestError(this, errors)));\n  }\n}\n\n/** Finds the most relevant error from the errors map for a given sub-request */\nexport function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string> {\n  const specificError = errors.get(subRequest.id);\n  if (specificError) return specificError;\n\n  const firstError = errors.values().next().value;\n  if (firstError) return firstError;\n\n  return new RpcError({\n    type: 'unknown-error',\n    publicMessage: 'An unknown error occurred',\n  });\n}\n"],"mappings":"2JAgBA,IAAa,eAAb,KAA4G,CAc/F,OAbX,QACA,GACA,WAAsB,GACtB,OACA,cACA,MACA,iBACA,SAA2B,CAAC,EAE5B,YACE,YACA,UACA,SACA,OACA,CADS,KAAA,OAAA,OAET,KAAK,QAAU,CAAC,GAAG,WAAW,EAC9B,KAAK,GAAK,UACV,KAAK,OAAS,SAAS,IAAA,CAAK,IAAK,QAC3B,kBAAA,eAAe,GAAG,GACpB,IAAI,YAAc,KAAK,GACvB,IAAI,WAAa,MACjB,KAAK,SAAS,KAAK,GAAG,EACf,MAEF,GACR,CACH,CAGA,KAAK,MAAmB,YAAiD,CACvE,YAAK,OAAO,cAAc,WAAW,EAC9B,KAAK,OAAO,QAAQ,KAAyC,OAAW,OAAW,OAAO,OAAQ,OAAO,OAAO,CACzH,CAGA,WAAW,YAA4D,CACrE,YAAK,OAAO,cAAc,WAAW,EAC9B,KAAK,OACT,WAAW,IAAuB,EAClC,MAAO,QAA0B,QAAQ,OAAO,oBAAoB,KAAM,MAAM,CAAC,CAAC,CACvF,CACF,EAGA,SAAgB,oBAAoB,WAA6B,OAAyC,CACxG,MAAM,cAAgB,OAAO,IAAI,WAAW,EAAE,EAC9C,GAAI,cAAe,OAAO,cAE1B,MAAM,WAAa,OAAO,OAAO,EAAE,KAAK,EAAE,MAC1C,OAAI,YAEG,IAAI,aAAA,SAAS,CAClB,KAAM,gBACN,cAAe,2BACjB,CAAC,CACH"}

package/.dist/cjs/src/subRequest.d.ts

@@ -1,8 +1,7 @@
-import { RpcError, RunTypeError, MapFromServerFnRef } from '@mionjs/core';
-import { CallSetup, MiddlewareSubRequest, RequestErrors, RouteSubRequest, SubRequest } from './types.ts';
+import { RpcError, RunTypeError, InputFromRef } from '@mionjs/core';
+import { CallSetup, RequestErrors, RouteSubRequest, SubRequest, InjectedApiMetadata } from './types.ts';
 import { MionClient } from './client.ts';
-import { TypedEvent } from './lib/typedEvent.ts';
-export declare class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RouteSubRequest<any>, MiddlewareSubRequest<any> {
+export declare class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RouteSubRequest<any> {
     readonly client: MionClient;
     pointer: string[];
     id: string;
@@ -11,13 +10,10 @@ export declare class MionSubRequest<S = any, E extends RpcError<string, any> = a
     resolvedValue?: S;
     error?: E;
     serializedParams?: any[];
-    mappings: MapFromServerFnRef[];
+    mappings: InputFromRef[];
     constructor(parentProps: string[], handlerId: string, argArray: any[], client: MionClient);
-    prefill(): TypedEvent<S, E>;
-    removePrefill(): Promise<void>;
-    call(setup?: CallSetup<any, any>): Promise<any>;
-    private executeWithOtherRoutes;
-    typeErrors(): Promise<RunTypeError[]>;
+    call(setup?: CallSetup, apiMetadata?: InjectedApiMetadata): Promise<any>;
+    typeErrors(apiMetadata?: InjectedApiMetadata): Promise<RunTypeError[]>;
 }
 export declare function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string>;
 //# sourceMappingURL=subRequest.d.ts.map

package/.dist/cjs/src/types.cjs

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=types.cjs.map