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

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

@@ -1,14 +1,9 @@
-import { MION_ROUTES, isRpcError, RpcError, deserializeBinaryBody, routesCache, HandlerType, serializeBinaryBody as serializeBinaryBody$1 } from "@mionjs/core";
-import { DEFAULT_PREFILL_OPTIONS } from "./constants.js";
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
-const __ΩSerializedBody = ["SerializedBody", "P&WJw!y"], __ΩContentType = ["application/json; charset=utf-8", "application/octet-stream", "ContentType", 'P.!."Jw#y'], __ΩSerializedRequest = [() => __ΩSerializedBody, "body", () => __ΩContentType, "contentType", "SerializedRequest", 'Pn!4"n#4$Mw%y'];
+import { MION_ROUTES, isRpcError, RpcError, routesCache, deserializeBinaryBody, HandlerType, serializeBinaryBody as serializeBinaryBody$1 } from "@mionjs/core";
+import { DEFAULT_PREFILL_OPTIONS } from "../constants.js";
 function getSerializerMode(req) {
   const methodId = req.route?.id ?? req.workflowSubRequests?.[0]?.id, serializerMode = routesCache.getMethodJitFns(methodId)?.options.serializer || DEFAULT_PREFILL_OPTIONS.serializer;
   return serializerMode === "json" ? DEFAULT_PREFILL_OPTIONS.serializer : serializerMode;
 }
-getSerializerMode.__type = ["MionClientRequest", "req", "SerializerMode", "getSerializerMode", 'P"w!2""w#/$'];
 function serializeRequestBody(req) {
   const serializerMode = getSerializerMode(req);
   switch (serializerMode) {
@@ -27,7 +22,6 @@ function serializeRequestBody(req) {
       throw new Error(`Invalid serializer mode ${serializerMode}`);
   }
 }
-serializeRequestBody.__type = ["MionClientRequest", "req", () => __ΩSerializedRequest, "serializeRequestBody", 'P"w!2"n#/$'];
 function serializeBinaryBody(req) {
   const subRequestIds = Object.keys(req.subRequestList), body = {}, executionChain = [];
   for (const id of subRequestIds) {
@@ -35,10 +29,9 @@ function serializeBinaryBody(req) {
     const method = routesCache.useMethodJitFns(id);
     method.type === HandlerType.headersMiddleFn && method.headersParam && (params = getParamsWithoutHeadersSubset(params)), body[id] = params, executionChain.push(method);
   }
-  const workflowRouteIds = req.workflowSubRequests?.map(__assignType((sr) => sr.id, ["sr", "", 'P"2!"/"'])), { buffer } = serializeBinaryBody$1(req.path, executionChain, body, !1, workflowRouteIds);
+  const workflowRouteIds = req.workflowSubRequests?.map((sr) => sr.id), { buffer } = serializeBinaryBody$1(req.path, executionChain, body, !1, workflowRouteIds);
   return new Uint8Array(buffer);
 }
-serializeBinaryBody.__type = ["MionClientRequest", "req", "serializeBinaryBody", 'P"w!2"W/#'];
 async function deserializeResponseBody(response) {
   const contentType = response.headers.get("content-type"), isJson = contentType?.includes("application/json"), isBinary = contentType?.includes("application/octet-stream");
   let parsedBody;
@@ -52,14 +45,13 @@ async function deserializeResponseBody(response) {
   }
   if (isJson || !isJson && !isBinary) {
     const deserializedBody = {};
-    return Object.entries(parsedBody).forEach(__assignType(([methodId, returnValue]) => {
+    return Object.entries(parsedBody).forEach(([methodId, returnValue]) => {
       const method = routesCache.useMethodJitFns(methodId), deserialized = parseHandlerReturnValue(method, returnValue);
       deserializedBody[methodId] = deserialized;
-    }, ["param0", "", 'P"2!"/"'])), deserializedBody;
+    }), deserializedBody;
   }
   return parsedBody;
 }
-deserializeResponseBody.__type = ["response", "ResponseBody", "deserializeResponseBody", 'P!2!"w"`/#'];
 async function deserializeJsonResponseBody(response) {
   try {
     return await response.json();
@@ -70,12 +62,10 @@ async function deserializeJsonResponseBody(response) {
     });
   }
 }
-deserializeJsonResponseBody.__type = ["response", "deserializeJsonResponseBody", 'P!2!"`/"'];
 async function deserializeBinaryResponseBody(response) {
   const arrayBuffer = await response.arrayBuffer(), { body } = deserializeBinaryBody("client-response", arrayBuffer, !0);
   return body;
 }
-deserializeBinaryResponseBody.__type = ["response", "ResponseBody", "deserializeBinaryResponseBody", 'P!2!"w"`/#'];
 function stringifyBody(req) {
   const props = [], subRequestIds = Object.keys(req.subRequestList);
   for (let i = 0; i < subRequestIds.length; i++) {
@@ -100,18 +90,15 @@ function stringifyBody(req) {
   }
   return `{${props.join(",")}}`;
 }
-stringifyBody.__type = ["MionClientRequest", "req", "stringifyBody", 'P"w!2"&/#'];
 function getParamsWithoutHeadersSubset(params) {
   return !params || params.length === 0 ? [] : params.slice(1);
 }
-getParamsWithoutHeadersSubset.__type = ["params", "getParamsWithoutHeadersSubset", 'P"F2!"F/"'];
 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);
 }
-stringifyHandlerParams.__type = ["MethodWithJitFns", "method", "params", "stringifyHandlerParams", 'P"w!2""F2#&/$'];
 function parseHandlerReturnValue(method, returnValue) {
   if (!method.hasReturnData)
     return returnValue;
@@ -128,11 +115,7 @@ function parseHandlerReturnValue(method, returnValue) {
     });
   }
 }
-parseHandlerReturnValue.__type = ["MethodWithJitFns", "method", "returnValue", "parseHandlerReturnValue", 'P"w!2""2#"/$'];
 export {
-  __ΩContentType,
-  __ΩSerializedBody,
-  __ΩSerializedRequest,
   deserializeResponseBody,
   serializeRequestBody
 };

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

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.js","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';\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/** Determines the serializer mode to use for a request */\nfunction getSerializerMode(req: MionClientRequest<any, any>): SerializerMode {\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/** 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\n    switch (serializerMode) {\n        case 'json':\n        case 'stringifyJson':\n            return {\n                body: stringifyBody(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\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\n/** Deserializes the response body from a fetch Response object */\nexport async function deserializeResponseBody(response: Response): Promise<ResponseBody> {\n    const contentType = response.headers.get('content-type');\n    const isJson = contentType?.includes('application/json');\n    const isBinary = contentType?.includes('application/octet-stream');\n\n    let parsedBody: any;\n\n    if (isJson) {\n        parsedBody = await deserializeJsonResponseBody(response);\n    } else if (isBinary) {\n        parsedBody = await deserializeBinaryResponseBody(response);\n    } else {\n        parsedBody = await deserializeJsonResponseBody(response);\n    }\n\n    if (MION_ROUTES.thrownErrors in parsedBody) {\n        const unexpectedErrors = parsedBody[MION_ROUTES.thrownErrors];\n\n        if (MION_ROUTES.platformError in unexpectedErrors) {\n            const globalErrorValue = unexpectedErrors[MION_ROUTES.platformError];\n            const platformError = isRpcError(globalErrorValue) ? new RpcError(globalErrorValue) : globalErrorValue;\n            return {[MION_ROUTES.platformError]: platformError};\n        }\n\n        Object.assign(parsedBody, unexpectedErrors);\n        delete parsedBody[MION_ROUTES.thrownErrors];\n    }\n\n    if (isJson || (!isJson && !isBinary)) {\n        const deserializedBody: ResponseBody = {};\n        Object.entries(parsedBody).forEach(([methodId, returnValue]) => {\n            const method = routesCache.useMethodJitFns(methodId);\n            const deserialized = parseHandlerReturnValue(method, returnValue);\n            deserializedBody[methodId] = deserialized;\n        });\n        return deserializedBody;\n    }\n\n    return parsedBody;\n}\n\n/** Deserializes JSON response body */\nasync function deserializeJsonResponseBody(response: Response): Promise<any> {\n    try {\n        return await response.json();\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    return body;\n}\n\nfunction stringifyBody(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\n        if (method.type === HandlerType.headersMiddleFn && method.headersParam) {\n            params = getParamsWithoutHeadersSubset(params);\n        }\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/** 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 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\nfunction parseHandlerReturnValue(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":["coreSerializeBinaryBody","coreDeserializeBinaryBody"],"mappings":"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"}

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

@@ -1,6 +1,6 @@
 const STORAGE_GLOBAL_KEY = "__mion_storage__";
 class MemoryStorage {
-  data = (Map.Ω = [["&"], ["&"]], /* @__PURE__ */ new Map());
+  data = /* @__PURE__ */ new Map();
   get length() {
     return this.data.size;
   }
@@ -19,9 +19,6 @@ class MemoryStorage {
   key(index) {
     return [...this.data.keys()][index] ?? null;
   }
-  static __type = ["data", function() {
-    return Map.Ω = [["&"], ["&"]], /* @__PURE__ */ new Map();
-  }, "key", "getItem", "value", "setItem", "removeItem", "clear", "index", "MemoryStorage", `!3!;>"!P&2#P&,J0$P&2#&2%"0&P&2#"0'P"0(P'2)P&,J0#5w*`];
 }
 function getStorage() {
   const existing = globalThis[STORAGE_GLOBAL_KEY];
@@ -35,11 +32,9 @@ function getStorage() {
   }
   return globalThis[STORAGE_GLOBAL_KEY] = storage, storage;
 }
-getStorage.__type = [() => MemoryStorage, "getStorage", 'PP!P7!J/"'];
 function resetStorageInstance() {
   delete globalThis[STORAGE_GLOBAL_KEY];
 }
-resetStorageInstance.__type = ["resetStorageInstance", 'P"/!'];
 export {
   MemoryStorage,
   getStorage,

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sources":["../../../../src/lib/storage.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nconst STORAGE_GLOBAL_KEY = '__mion_storage__';\n\n/** In-memory Storage implementation for SSR/Node environments where localStorage is not available */\nexport class MemoryStorage {\n    private data = new Map<string, string>();\n    get length() {\n        return this.data.size;\n    }\n    getItem(key: string): string | null {\n        return this.data.get(key) ?? null;\n    }\n    setItem(key: string, value: string) {\n        this.data.set(key, value);\n    }\n    removeItem(key: string) {\n        this.data.delete(key);\n    }\n    clear() {\n        this.data.clear();\n    }\n    key(index: number): string | null {\n        return [...this.data.keys()][index] ?? null;\n    }\n}\n\n/** Returns localStorage if available, otherwise a MemoryStorage instance.\n * Uses globalThis to ensure the same instance is shared across module boundaries. */\nexport function getStorage(): Storage | MemoryStorage {\n    const existing = (globalThis as any)[STORAGE_GLOBAL_KEY];\n    if (existing) return existing;\n    let storage: Storage | MemoryStorage;\n    try {\n        if (typeof localStorage !== 'undefined') {\n            localStorage.setItem('__mion_test__', '1');\n            localStorage.removeItem('__mion_test__');\n            storage = localStorage;\n        } else {\n            storage = new MemoryStorage();\n        }\n    } catch {\n        storage = new MemoryStorage();\n    }\n    (globalThis as any)[STORAGE_GLOBAL_KEY] = storage;\n    return storage;\n}\n\n/** Reset storage instance, useful for testing */\nexport function resetStorageInstance() {\n    delete (globalThis as any)[STORAGE_GLOBAL_KEY];\n}\n"],"names":[],"mappings":"AAOA,MAAM,qBAAqB;MAGd,cAAa;AAAA,EACd,2BAAW,IAAA;AAAA,EACnB,IAAI,SAAM;AACN,WAAO,KAAK,KAAK;AAAA,EACrB;AAAA,EACA,QAAQ,KAAW;AACf,WAAO,KAAK,KAAK,IAAI,GAAG,KAAK;AAAA,EACjC;AAAA,EACA,QAAQ,KAAa,OAAa;AAC9B,SAAK,KAAK,IAAI,KAAK,KAAK;AAAA,EAC5B;AAAA,EACA,WAAW,KAAW;AAClB,SAAK,KAAK,OAAO,GAAG;AAAA,EACxB;AAAA,EACA,QAAK;AACD,SAAK,KAAK,MAAA;AAAA,EACd;AAAA,EACA,IAAI,OAAa;AACb,WAAO,CAAC,GAAG,KAAK,KAAK,MAAM,EAAE,KAAK,KAAK;AAAA,EAC3C;AACH;SAIe,aAAU;AACtB,QAAM,WAAY,WAAmB,kBAAkB;AACvD,MAAI;AAAU,WAAO;AACrB,MAAI;AACJ,MAAI;AACA,IAAI,OAAO,eAAiB,OACxB,aAAa,QAAQ,iBAAiB,GAAG,GACzC,aAAa,WAAW,eAAe,GACvC,UAAU,gBAEV,UAAU,IAAI,cAAA;AAAA,EAEtB,QAAQ;AACJ,cAAU,IAAI,cAAA;AAAA,EAClB;AACC,oBAAmB,kBAAkB,IAAI,SACnC;AACX;SAGgB,uBAAoB;AAChC,SAAQ,WAAmB,kBAAkB;AACjD;"}

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

@@ -1,11 +1,11 @@
 import { MION_ROUTES, routesCache, resetJitFnCaches, resetJitFunctionsCache, addAOTCaches, getJitFnHashes } from "@mionjs/core";
-import { getAOTCaches } from "./clientMethodsMetadata.js";
+import { getAOTCaches } from "../aot/aotCaches.js";
 function resetClientCaches() {
   const { jitFnsCache, pureFnsCache } = getAOTCaches(), mionRouteIds = new Set(Object.values(MION_ROUTES)), cache = routesCache.getCache();
   for (const key in cache)
     mionRouteIds.has(key) || delete cache[key];
   resetJitFnCaches(), resetJitFunctionsCache();
-  const neededJitHashes = (Set.Ω = [["&"]], /* @__PURE__ */ new Set()), neededPureFnKeys = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+  const neededJitHashes = /* @__PURE__ */ new Set(), neededPureFnKeys = /* @__PURE__ */ new Set();
   for (const routeId of mionRouteIds) {
     const meta = routesCache.getMetadata(routeId);
     meta && (collectJitDepsFromParentHash(meta.paramsJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), collectJitDepsFromParentHash(meta.returnJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), meta.headersParam && collectJitDepsFromParentHash(meta.headersParam.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), meta.headersReturn && collectJitDepsFromParentHash(meta.headersReturn.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache));
@@ -20,7 +20,6 @@ function resetClientCaches() {
   }
   (Object.keys(filteredJitFns).length > 0 || Object.keys(filteredPureFns).length > 0) && addAOTCaches(filteredJitFns, filteredPureFns);
 }
-resetClientCaches.__type = ["resetClientCaches", 'P"/!'];
 function collectJitDepsFromParentHash(parentHash, jitHashes, pureFnKeys, jitFnsCache) {
   if (!parentHash)
     return;
@@ -28,7 +27,6 @@ function collectJitDepsFromParentHash(parentHash, jitHashes, pureFnKeys, jitFnsC
   for (const individualHash of Object.values(hashes))
     collectJitDeps(individualHash, jitHashes, pureFnKeys, jitFnsCache);
 }
-collectJitDepsFromParentHash.__type = ["parentHash", "jitHashes", "pureFnKeys", "PersistedJitFunctionsCache", "jitFnsCache", "collectJitDepsFromParentHash", 'P&2!&D2"&D2#"w$2%"/&'];
 function collectJitDeps(hash, jitHashes, pureFnKeys, jitFnsCache) {
   if (!hash || jitHashes.has(hash))
     return;
@@ -41,7 +39,6 @@ function collectJitDeps(hash, jitHashes, pureFnKeys, jitFnsCache) {
       pureFnKeys.add(pureDep);
   }
 }
-collectJitDeps.__type = ["hash", "jitHashes", "pureFnKeys", "PersistedJitFunctionsCache", "jitFnsCache", "collectJitDeps", 'P&2!&D2"&D2#"w$2%"/&'];
 export {
   resetClientCaches
 };

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

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.js","sources":["../../../../src/lib/testUtils.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {addAOTCaches, resetJitFnCaches, resetJitFunctionsCache, MION_ROUTES, getJitFnHashes, routesCache} from '@mionjs/core';\nimport type {PersistedJitFunctionsCache} from '@mionjs/core';\nimport {getAOTCaches} from '../aot/aotCaches.ts';\n\n/**\n * Resets client caches preserving MION internal routes and their JIT dependencies.\n * Only for testing — simulates app restart without losing MION infrastructure.\n */\nexport function resetClientCaches() {\n    const {jitFnsCache, pureFnsCache} = getAOTCaches();\n    // Clear only user routes, keep internal MION_ROUTES (needed for fetch calls)\n    const mionRouteIds = new Set(Object.values(MION_ROUTES) as string[]);\n    const cache = routesCache.getCache();\n    for (const key in cache) {\n        if (!mionRouteIds.has(key)) delete cache[key];\n    }\n    // Full JIT reset is safe — only MION internal route JIT caches will be re-registered below\n    resetJitFnCaches();\n    resetJitFunctionsCache();\n    // Collect individual JIT hashes needed by MION internal routes and their transitive dependencies\n    const neededJitHashes = new Set<string>();\n    const neededPureFnKeys = new Set<string>();\n    for (const routeId of mionRouteIds) {\n        const meta = routesCache.getMetadata(routeId);\n        if (!meta) continue;\n        collectJitDepsFromParentHash(meta.paramsJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache);\n        collectJitDepsFromParentHash(meta.returnJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache);\n        if (meta.headersParam)\n            collectJitDepsFromParentHash(meta.headersParam.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache);\n        if (meta.headersReturn)\n            collectJitDepsFromParentHash(meta.headersReturn.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache);\n    }\n    // Re-register only the filtered AOT caches for MION internal routes\n    const filteredJitFns: Record<string, any> = {};\n    for (const hash of neededJitHashes) {\n        if (hash in jitFnsCache) filteredJitFns[hash] = jitFnsCache[hash];\n    }\n    const filteredPureFns: Record<string, Record<string, any>> = {};\n    for (const key of neededPureFnKeys) {\n        const [ns, fnHash] = key.split('::');\n        if (pureFnsCache[ns]?.[fnHash]) {\n            if (!filteredPureFns[ns]) filteredPureFns[ns] = {};\n            filteredPureFns[ns][fnHash] = pureFnsCache[ns][fnHash];\n        }\n    }\n    if (Object.keys(filteredJitFns).length > 0 || Object.keys(filteredPureFns).length > 0) {\n        addAOTCaches(filteredJitFns, filteredPureFns);\n    }\n}\n\n/** Expands a parent JIT hash into individual function hashes and collects their transitive dependencies */\nfunction collectJitDepsFromParentHash(\n    parentHash: string,\n    jitHashes: Set<string>,\n    pureFnKeys: Set<string>,\n    jitFnsCache: PersistedJitFunctionsCache\n) {\n    if (!parentHash) return;\n    const hashes = getJitFnHashes(parentHash);\n    for (const individualHash of Object.values(hashes) as string[]) {\n        collectJitDeps(individualHash, jitHashes, pureFnKeys, jitFnsCache);\n    }\n}\n\n/** Transitively collects JIT and pure function dependency hashes from the AOT cache */\nfunction collectJitDeps(hash: string, jitHashes: Set<string>, pureFnKeys: Set<string>, jitFnsCache: PersistedJitFunctionsCache) {\n    if (!hash || jitHashes.has(hash)) return;\n    jitHashes.add(hash);\n    const entry = jitFnsCache[hash];\n    if (!entry) return;\n    for (const dep of entry.jitDependencies) collectJitDeps(dep, jitHashes, pureFnKeys, jitFnsCache);\n    for (const pureDep of entry.pureFnDependencies) pureFnKeys.add(pureDep);\n}\n"],"names":[],"mappings":";;SAegB,oBAAiB;AAC7B,QAAM,EAAC,aAAa,aAAA,IAAgB,aAAA,GAE9B,eAAe,IAAI,IAAI,OAAO,OAAO,WAAW,CAAa,GAC7D,QAAQ,YAAY,SAAA;AAC1B,aAAW,OAAO;AACd,IAAK,aAAa,IAAI,GAAG,KAAG,OAAO,MAAM,GAAG;AAGhD,mBAAA,GACA,uBAAA;AAEA,QAAM,sCAAsB,IAAA,GACtB,uCAAuB,IAAA;AAC7B,aAAW,WAAW,cAAc;AAChC,UAAM,OAAO,YAAY,YAAY,OAAO;AAC5C,IAAK,SACL,6BAA6B,KAAK,eAAe,iBAAiB,kBAAkB,WAAW,GAC/F,6BAA6B,KAAK,eAAe,iBAAiB,kBAAkB,WAAW,GAC3F,KAAK,gBACL,6BAA6B,KAAK,aAAa,SAAS,iBAAiB,kBAAkB,WAAW,GACtG,KAAK,iBACL,6BAA6B,KAAK,cAAc,SAAS,iBAAiB,kBAAkB,WAAW;AAAA,EAC/G;AAEA,QAAM,iBAAsC,CAAA;AAC5C,aAAW,QAAQ;AACf,IAAI,QAAQ,gBAAa,eAAe,IAAI,IAAI,YAAY,IAAI;AAEpE,QAAM,kBAAuD,CAAA;AAC7D,aAAW,OAAO,kBAAkB;AAChC,UAAM,CAAC,IAAI,MAAM,IAAI,IAAI,MAAM,IAAI;AACnC,IAAI,aAAa,EAAE,IAAI,MAAM,MACpB,gBAAgB,EAAE,MAAG,gBAAgB,EAAE,IAAI,CAAA,IAChD,gBAAgB,EAAE,EAAE,MAAM,IAAI,aAAa,EAAE,EAAE,MAAM;AAAA,EAE7D;AACA,GAAI,OAAO,KAAK,cAAc,EAAE,SAAS,KAAK,OAAO,KAAK,eAAe,EAAE,SAAS,MAChF,aAAa,gBAAgB,eAAe;AAEpD;AAGA,SAAS,6BACL,YACA,WACA,YACA,aAAuC;AAEvC,MAAI,CAAC;AAAY;AACjB,QAAM,SAAS,eAAe,UAAU;AACxC,aAAW,kBAAkB,OAAO,OAAO,MAAM;AAC7C,mBAAe,gBAAgB,WAAW,YAAY,WAAW;AAEzE;AAGA,SAAS,eAAe,MAAc,WAAwB,YAAyB,aAAuC;AAC1H,MAAI,CAAC,QAAQ,UAAU,IAAI,IAAI;AAAG;AAClC,YAAU,IAAI,IAAI;AAClB,QAAM,QAAQ,YAAY,IAAI;AAC9B,MAAK,OACL;AAAA,eAAW,OAAO,MAAM;AAAiB,qBAAe,KAAK,WAAW,YAAY,WAAW;AAC/F,eAAW,WAAW,MAAM;AAAoB,iBAAW,IAAI,OAAO;AAAA;AAC1E;"}

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

@@ -1,6 +1,6 @@
 import { RpcError } from '@mionjs/core';
 import { HandlersRegistry } from './handlersRegistry.ts';
-import { SuccessHandler } from './types.ts';
+import { SuccessHandler } from '../types.ts';
 export declare class TypedEvent<S = void, E extends RpcError<string, any> = never> {
     private readonly handlerId;
     private readonly registry;

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

@@ -1,4 +1,3 @@
-const __ΩExtract = ["T", "U", "Extract", `l6e$!R!RPe#!e$"qk#'QRb!b"Pde"!p)w#y`];
 class TypedEvent {
   handlerId;
   registry;
@@ -33,7 +32,6 @@ class TypedEvent {
   hasSuccessHandler() {
     return this.registry.hasSuccessHandler(this.handlerId);
   }
-  static __type = ["S", "E", "handlerId", "HandlersRegistry", "registry", "constructor", "SuccessHandler", "handler", () => TypedEvent, "onSuccess", () => TypedEvent, "offSuccess", "errorType", () => __ΩExtract, "type", "error", "", () => TypedEvent, "onError", () => TypedEvent, "offError", "getHandlerId", "hasErrorHandler", "hasSuccessHandler", "TypedEvent", `$c!!c"P&2#;9"w$2%;9"0&P"w'2(Pe#!e#"7)0*PPe#!e#"7+0,P"2-Pe#"P"4/Mo.#20$/12(Pe#!e#"7203P"2-Pe#!e#"7405P&06P&2-)07P)085w9`];
 }
 export {
   TypedEvent

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

@@ -0,0 +1 @@
+{"version":3,"file":"typedEvent.js","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":"MAYa,WAAU;AAAA,EAEE;AAAA,EACA;AAAA,EAFrB,YACqB,WACA,UAA0B;AAD1B,SAAA,YAAA,WACA,KAAA,WAAA;AAAA,EAClB;AAAA;AAAA,EAGH,UAAU,SAA0B;AAChC,gBAAK,SAAS,gBAAgB,KAAK,WAAW,OAAO,GAC9C;AAAA,EACX;AAAA;AAAA,EAGA,aAAU;AACN,gBAAK,SAAS,kBAAkB,KAAK,SAAS,GACvC;AAAA,EACX;AAAA;AAAA,EAGA,QAA6B,WAAc,SAA+C;AACtF,gBAAK,SAAS,SAAS,KAAK,WAAW,WAAW,OAA4B,GACvE;AAAA,EACX;AAAA;AAAA,EAGA,SAA8B,WAAY;AACtC,gBAAK,SAAS,WAAW,KAAK,WAAW,SAAS,GAC3C;AAAA,EACX;AAAA;AAAA,EAGA,eAAY;AACR,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAGA,gBAAgB,WAAiB;AAC7B,WAAO,KAAK,SAAS,WAAW,KAAK,WAAW,SAAS;AAAA,EAC7D;AAAA;AAAA,EAGA,oBAAiB;AACb,WAAO,KAAK,SAAS,kBAAkB,KAAK,SAAS;AAAA,EACzD;AACH;"}

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

@@ -1,4 +1,4 @@
-import { RequestErrors, SubRequest } from './types.ts';
-import { MionClientRequest } from './request.ts';
+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;
 export declare function validateSubRequest(id: string, subRequest: SubRequest<any>, errors: RequestErrors): void;

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

@@ -1,20 +1,15 @@
 import { routesCache, RpcError } from "@mionjs/core";
-import { __ΩRequestErrors as ___RequestErrors, __ΩSubRequest as ___SubRequest } from "./types.js";
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
 function validateSubRequests(subRequestIds, req, errors, validateRouteMiddleFns = !0) {
-  req.options.validateParams && subRequestIds.forEach(__assignType((id) => {
+  req.options.validateParams && subRequestIds.forEach((id) => {
     const subRequest = req.subRequestList[id];
     validateSubRequest(id, subRequest, errors);
     const methodMeta = routesCache.getMetadata(id);
     if (validateRouteMiddleFns && methodMeta?.middleFnIds?.length) {
-      const validMiddleFnIds = methodMeta.middleFnIds.filter(__assignType((middleFnId) => middleFnId != null, ["middleFnId", "", 'P"2!"/"']));
+      const validMiddleFnIds = methodMeta.middleFnIds.filter((middleFnId) => middleFnId != null);
       validateSubRequests(validMiddleFnIds, req, errors, validateRouteMiddleFns);
     }
-  }, ["id", "", 'P"2!"/"']));
+  });
 }
-validateSubRequests.__type = ["subRequestIds", "MionClientRequest", "req", () => ___RequestErrors, "errors", "validateRouteMiddleFns", "validateSubRequests", `P&F2!"w"2#n$2%"2&$/'`];
 function validateSubRequest(id, subRequest, errors) {
   if (subRequest?.error || subRequest?.isResolved)
     return;
@@ -27,7 +22,6 @@ function validateSubRequest(id, subRequest, errors) {
   const error = validationResponse;
   errors.set(id, error), subRequest && (subRequest.error = error, subRequest.isResolved = !0);
 }
-validateSubRequest.__type = ["id", () => ___SubRequest, "subRequest", () => ___RequestErrors, "errors", "validateSubRequest", 'P&2!"o""2#n$2%$/&'];
 function getTypeErrors(id, params) {
   const method = routesCache.useMethodJitFns(id);
   if (!method.paramNames || method.paramNames.length === 0)
@@ -49,7 +43,6 @@ function getTypeErrors(id, params) {
       });
     }
 }
-getTypeErrors.__type = ["id", "params", "validation-error", "unexpected-validation-error", () => RpcError, "getTypeErrors", 'P&2!"F2"P$PP.#.$J7%J/&'];
 export {
   validateSubRequest,
   validateSubRequests

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","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":[],"mappings":";AAYM,SAAU,oBACZ,eACA,KACA,QACA,yBAAyB,IAAI;AAE7B,EAAK,IAAI,QAAQ,kBACjB,cAAc,QAAQ,CAAC,OAAM;AACzB,UAAM,aAAa,IAAI,eAAe,EAAE;AACxC,uBAAmB,IAAI,YAAY,MAAM;AACzC,UAAM,aAAa,YAAY,YAAY,EAAE;AAC7C,QAAI,0BAA0B,YAAY,aAAa,QAAQ;AAC3D,YAAM,mBAAmB,WAAW,YAAY,OAAO,CAAC,eAAe,cAAc,IAAI;AACzF,0BAAoB,kBAAkB,KAAK,QAAQ,sBAAsB;AAAA,IAC7E;AAAA,EACJ,CAAC;AAEL;SAGgB,mBAAmB,IAAY,YAA6B,QAAqB;AAC7F,MAAI,YAAY,SAAS,YAAY;AAAY;AAGjD,QAAM,WAAY,YAAoB;AACtC,MAAI,MAAM,QAAQ,QAAQ,KAAK,SAAS,SAAS;AAAG;AAEpD,QAAM,SAAS,YAAY,UAAU,CAAA,GAC/B,qBAAqB,cAAc,IAAI,MAAM;AACnD,MAAI,CAAC;AAAoB;AACzB,QAAM,QAAQ;AACd,SAAO,IAAI,IAAI,KAAK,GAChB,eACA,WAAW,QAAQ,OACnB,WAAW,aAAa;AAGhC;AAEA,SAAS,cAAc,IAAY,QAAa;AAC5C,QAAM,SAAS,YAAY,gBAAgB,EAAE;AAC7C,MAAI,CAAC,OAAO,cAAc,OAAO,WAAW,WAAW;AAAG;AAC1D,QAAM,YAAY,OAAO;AACzB,MAAI,WAAU,WAAW;AACzB,QAAI;AACA,YAAM,sBAAsB,UAAU,OAAO,GAAG,MAAM,KAAK,UAAU,WAAW,GAAG,MAAM;AACzF,UAAK,qBAA4B;AAC7B,eAAO,IAAI,SAAS;AAAA,UAChB,MAAM;AAAA,UACN,eAAe,yCAAyC,OAAO,EAAE;AAAA,UACjE,WAAW;AAAA,QAAA,CACd;AAAA,IAET,SAAS,GAAgB;AACrB,aAAO,IAAI,SAAS;AAAA,QAChB,MAAM;AAAA,QACN,eAAe,oDAAoD,OAAO,EAAE,MAAM,EAAE,OAAO;AAAA,MAAA,CAC9F;AAAA,IACL;AACJ;"}

package/.dist/esm/src/request.js

@@ -1,13 +1,8 @@
-import { __ΩSubRequest as ___SubRequest, __ΩClientOptions as ___ClientOptions, __ΩPrefilledMiddleFnsCache as ___PrefilledMiddleFnsCache, __ΩRSubRequest as ___RSubRequest, __ΩRequestErrors as ___RequestErrors } from "./types.js";
 import { getRoutePath, toBase64Url, MION_ROUTES, isRpcError, RpcError, routesCache, HandlerType, HeadersSubset } from "@mionjs/core";
-import { fetchRemoteMethodsMetadata } from "./clientMethodsMetadata.js";
-import { validateSubRequests } from "./validation.js";
-import { serializeRequestBody, deserializeResponseBody } from "./serializer.js";
+import { fetchRemoteMethodsMetadata } from "./lib/clientMethodsMetadata.js";
+import { validateSubRequests } from "./lib/validation.js";
+import { serializeRequestBody, deserializeResponseBody } from "./lib/serializer.js";
 import { ROUTES_FLOW_KEY, MAX_GET_URL_LENGTH } from "./constants.js";
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
 class MionClientRequest {
   options;
   prefilledMiddleFnsCache;
@@ -20,11 +15,11 @@ class MionClientRequest {
   response;
   constructor(options, prefilledMiddleFnsCache, route, middleFns, workflowSubRequests) {
     if (this.options = options, this.prefilledMiddleFnsCache = prefilledMiddleFnsCache, this.route = route, this.middleFns = middleFns, this.workflowSubRequests = workflowSubRequests, workflowSubRequests && workflowSubRequests.length > 0) {
-      const routePaths = workflowSubRequests.map(__assignType((sr) => getRoutePath(sr.pointer, this.options), ["sr", "", 'P"2!"/"'])), query = buildRoutesFlowQuery(routePaths, workflowSubRequests), flowPath = getRoutePath([ROUTES_FLOW_KEY], this.options);
-      this.path = `${flowPath}?data=${toBase64Url(JSON.stringify(query))}`, this.requestId = "mion-routes-flow", workflowSubRequests.forEach(__assignType((sr) => this.addSubRequest(sr), ["sr", "", 'P"2!"/"']));
+      const routePaths = workflowSubRequests.map((sr) => getRoutePath(sr.pointer, this.options)), query = buildRoutesFlowQuery(routePaths, workflowSubRequests), flowPath = getRoutePath([ROUTES_FLOW_KEY], this.options);
+      this.path = `${flowPath}?data=${toBase64Url(JSON.stringify(query))}`, this.requestId = "mion-routes-flow", workflowSubRequests.forEach((sr) => this.addSubRequest(sr));
     } else
       this.path = route ? getRoutePath(route.pointer, this.options) : "no-route", this.requestId = route ? route.id : "no-route", route && this.addSubRequest(route);
-    middleFns && middleFns.forEach(__assignType((middleFn) => this.addSubRequest(middleFn), ["middleFn", "", 'P"2!"/"']));
+    middleFns && middleFns.forEach((middleFn) => this.addSubRequest(middleFn));
   }
   /** Calls a remote route */
   async call() {
@@ -71,34 +66,34 @@ class MionClientRequest {
       const deserialized = await deserializeResponseBody(this.response);
       if (MION_ROUTES.platformError in deserialized) {
         const platformError = deserialized[MION_ROUTES.platformError];
-        return Object.entries(this.subRequestList).forEach(__assignType(([id, methodMeta]) => {
+        return Object.entries(this.subRequestList).forEach(([id, methodMeta]) => {
           methodMeta.isResolved = !0, methodMeta.error = platformError, errors.set(id, platformError);
-        }, ["param0", "", 'P"2!"/"'])), Promise.reject(errors);
+        }), Promise.reject(errors);
       }
-      return Object.entries(this.subRequestList).forEach(__assignType(([id, methodMeta]) => {
+      return Object.entries(this.subRequestList).forEach(([id, methodMeta]) => {
         const resp = this.getResponseValueFromBodyOrHeader(id, deserialized, this.response.headers);
         methodMeta.isResolved = !0, isRpcError(resp) ? (methodMeta.error = resp, errors.set(id, resp)) : methodMeta.resolvedValue = resp;
-      }, ["param0", "", 'P"2!"/"'])), Object.entries(deserialized).forEach(__assignType(([id, value]) => {
+      }), Object.entries(deserialized).forEach(([id, value]) => {
         !(id in this.subRequestList) && isRpcError(value) && errors.set(id, value);
-      }, ["param0", "", 'P"2!"/"'])), errors.size ? Promise.reject(errors) : deserialized;
+      }), errors.size ? Promise.reject(errors) : deserialized;
     } catch (error) {
       return this.onError(error, "Error parsing response", errors), Promise.reject(errors);
     }
   }
   /** Validate params */
   async validateParams(subReqList) {
-    subReqList && subReqList.forEach(__assignType((subRequest) => this.addSubRequest(subRequest), ["subRequest", "", 'P"2!"/"']));
+    subReqList && subReqList.forEach((subRequest) => this.addSubRequest(subRequest));
     const errors = /* @__PURE__ */ new Map();
     try {
       const subRequestIds = Object.keys(this.subRequestList);
-      return await fetchRemoteMethodsMetadata(subRequestIds, this.options), validateSubRequests(subRequestIds, this, errors, !1), Object.values(this.subRequestList).map(__assignType((subRequest) => subRequest.error?.errorData || [], ["subRequest", "", 'P"2!"/"'])).flat();
+      return await fetchRemoteMethodsMetadata(subRequestIds, this.options), validateSubRequests(subRequestIds, this, errors, !1), Object.values(this.subRequestList).map((subRequest) => subRequest.error?.errorData || []).flat();
     } catch (error) {
       return this.onError(error, "Error preparing request", errors), Promise.reject(errors);
     }
   }
   /** Prefills and stores SubRequest */
   async prefill(subReqList) {
-    subReqList && subReqList.forEach(__assignType((subRequest) => this.addSubRequest(subRequest), ["subRequest", "", 'P"2!"/"']));
+    subReqList && subReqList.forEach((subRequest) => this.addSubRequest(subRequest));
     const errors = /* @__PURE__ */ new Map();
     try {
       const subRequestIds = Object.keys(this.subRequestList);
@@ -109,7 +104,7 @@ class MionClientRequest {
   }
   /** Removes Prefills and stores SubRequest */
   async removePrefill(subRequests) {
-    subRequests && subRequests.forEach(__assignType((subRequest) => this.addSubRequest(subRequest), ["subRequest", "", 'P"2!"/"'])), this.removePrefilledMiddleFns();
+    subRequests && subRequests.forEach((subRequest) => this.addSubRequest(subRequest)), this.removePrefilledMiddleFns();
   }
   addSubRequest(subRequest) {
     if (subRequest.isResolved)
@@ -145,7 +140,7 @@ class MionClientRequest {
       }));
       return;
     }
-    (methodMeta.middleFnIds?.filter(__assignType((id) => !!id && this.requestId !== id, ["id", "", 'P"2!"/"'])) || []).forEach(__assignType((id) => {
+    (methodMeta.middleFnIds?.filter((id) => !!id && this.requestId !== id) || []).forEach((id) => {
       if (this.subRequestList[id])
         return;
       const cacheKey = this.getPrefilledMiddleFnCacheKey(id), cachedSubRequest = this.prefilledMiddleFnsCache.get(cacheKey);
@@ -158,11 +153,11 @@ class MionClientRequest {
         };
         this.addSubRequest(clonedSubRequest);
       }
-    }, ["id", "", 'P"2!"/"']));
+    });
   }
   /** Restore prefilled middleFns for all routes in a routesFlow, deduplicating by ID */
   restorePrefilledMiddleFnsForWorkflow(errors) {
-    const workflowRouteIds = new Set(this.workflowSubRequests.map(__assignType((sr) => sr.id, ["sr", "", 'P"2!"/"'])));
+    const workflowRouteIds = new Set(this.workflowSubRequests.map((sr) => sr.id));
     for (const routeSubRequest of this.workflowSubRequests) {
       const methodMeta = routesCache.getMetadata(routeSubRequest.id);
       if (!methodMeta) {
@@ -172,7 +167,7 @@ class MionClientRequest {
         }));
         continue;
       }
-      (methodMeta.middleFnIds?.filter(__assignType((id) => !!id && !workflowRouteIds.has(id), ["id", "", 'P"2!"/"'])) || []).forEach(__assignType((id) => {
+      (methodMeta.middleFnIds?.filter((id) => !!id && !workflowRouteIds.has(id)) || []).forEach((id) => {
         if (this.subRequestList[id])
           return;
         const cacheKey = this.getPrefilledMiddleFnCacheKey(id), cachedSubRequest = this.prefilledMiddleFnsCache.get(cacheKey);
@@ -185,11 +180,11 @@ class MionClientRequest {
           };
           this.addSubRequest(clonedSubRequest);
         }
-      }, ["id", "", 'P"2!"/"']));
+      });
     }
   }
   storePrefilledMiddleFns(errors) {
-    Object.keys(this.subRequestList).forEach(__assignType((id) => {
+    Object.keys(this.subRequestList).forEach((id) => {
       const subRequest = this.subRequestList[id], methodMeta = routesCache.getMetadata(id);
       if (!methodMeta)
         throw new Error(`Remote method ${id} not found.`);
@@ -202,13 +197,13 @@ class MionClientRequest {
       }
       const cacheKey = this.getPrefilledMiddleFnCacheKey(id);
       this.prefilledMiddleFnsCache.set(cacheKey, subRequest);
-    }, ["id", "", 'P"2!"/"']));
+    });
   }
   removePrefilledMiddleFns() {
-    Object.keys(this.subRequestList).forEach(__assignType((id) => {
+    Object.keys(this.subRequestList).forEach((id) => {
       const cacheKey = this.getPrefilledMiddleFnCacheKey(id);
       this.prefilledMiddleFnsCache.delete(cacheKey);
-    }, ["id", "", 'P"2!"/"']));
+    });
   }
   /** Returns true if the route is a query (isMutation === false) and not a routesFlow */
   isQueryRoute() {
@@ -217,9 +212,6 @@ class MionClientRequest {
   getPrefilledMiddleFnCacheKey(id) {
     return `${this.options.baseURL}:${id}`;
   }
-  static __type = ["RR", "MiddleFnRequestsList", "path", "requestId", () => ___SubRequest, "subRequestList", function() {
-    return {};
-  }, "response", () => ___ClientOptions, "options", () => ___PrefilledMiddleFnsCache, "prefilledMiddleFnsCache", "route", "middleFns", () => ___RSubRequest, "workflowSubRequests", "constructor", "ResponseBody", "call", () => ___SubRequest, "subReqList", "RunTypeError", "validateParams", () => ___SubRequest, "prefill", () => ___SubRequest, "subRequests", "removePrefill", () => ___SubRequest, "subRequest", "addSubRequest", "error", "stageMessage", () => ___RequestErrors, "errors", "onError", "id", "respBody", "headers", "getResponseValueFromBodyOrHeader", () => ___RequestErrors, "restorePrefilledMiddleFns", () => ___RequestErrors, "restorePrefilledMiddleFnsForWorkflow", () => ___RequestErrors, "storePrefilledMiddleFns", "removePrefilledMiddleFns", "isQueryRoute", "getPrefilledMiddleFnCacheKey", "MionClientRequest", 'b!b"&3#9&3$9P&"o%"LM3&9>\'P!-J3(Pn)2*:9n+2,;9e"!2-8:9e""2.8:9"o/"F208:9"01P"w2`03P"o4"F258"w6F`07P"o8"F258$`09P"o:"F2;8$`0<P"o="2>"0?P"2@&2AnB2C$0D;P&2E"w22F!2G"0H;PnI2C$0J;PnK2C$0L;PnM2C$0N;P$0O;P)0P;P&2E&0Q;5wR'];
 }
 function extractRequestHeaders(req) {
   const headers = {}, subRequestIds = Object.keys(req.subRequestList);
@@ -235,7 +227,6 @@ function extractRequestHeaders(req) {
   }
   return headers;
 }
-extractRequestHeaders.__type = [() => MionClientRequest, "req", () => __ΩRecord, "extractRequestHeaders", 'PP""7!2"&&o##/$'];
 function extractHeadersFromParams(params) {
   if (!params || params.length === 0)
     throw new RpcError({
@@ -250,7 +241,6 @@ function extractHeadersFromParams(params) {
     publicMessage: "HeadersFn first parameter must be a HeadersSubset instance or object with headers property."
   });
 }
-extractHeadersFromParams.__type = ["params", () => __ΩRecord, "extractHeadersFromParams", 'P"F2!&&o"#/#'];
 function reconstructHeadersSubsetFromResponse(methodId, responseHeaders) {
   const method = routesCache.getMetadata(methodId);
   if (!method?.headersReturn?.headerNames || method.headersReturn.headerNames.length === 0)
@@ -263,7 +253,6 @@ function reconstructHeadersSubsetFromResponse(methodId, responseHeaders) {
   if (Object.keys(headersMap).length > 0)
     return new HeadersSubset(headersMap);
 }
-reconstructHeadersSubsetFromResponse.__type = ["methodId", "responseHeaders", () => HeadersSubset, "reconstructHeadersSubsetFromResponse", 'P&2!!2"PP&&7#-J/$'];
 function buildRoutesFlowQuery(routePaths, workflowSubRequests) {
   const allMappings = [];
   for (const sr of workflowSubRequests) {
@@ -282,7 +271,6 @@ function buildRoutesFlowQuery(routePaths, workflowSubRequests) {
     mappings: allMappings.length > 0 ? allMappings : void 0
   };
 }
-buildRoutesFlowQuery.__type = ["routePaths", () => ___RSubRequest, "workflowSubRequests", "RoutesFlowQuery", "buildRoutesFlowQuery", 'P&F2!"o""F2#"w$/%'];
 export {
   MionClientRequest
 };

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

@@ -1 +1 @@
-{"version":3,"file":"request.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"request.js","sources":["../../../src/request.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 {ClientOptions, HSubRequest, SubRequest, RSubRequest, RequestErrors, PrefilledMiddleFnsCache} from './types.ts';\nimport type {RunTypeError, RoutesFlowQuery, RoutesFlowMapping} from '@mionjs/core';\nimport {RpcError, isRpcError, routesCache, MION_ROUTES, HandlerType, HeadersSubset, toBase64Url} from '@mionjs/core';\nimport {getRoutePath} from '@mionjs/core';\nimport {fetchRemoteMethodsMetadata} from './lib/clientMethodsMetadata.ts';\nimport {validateSubRequests} from './lib/validation.ts';\nimport {serializeRequestBody, deserializeResponseBody} from './lib/serializer.ts';\nimport {ROUTES_FLOW_KEY, MAX_GET_URL_LENGTH} from './constants.ts';\n\nexport class MionClientRequest<RR extends RSubRequest<any>, MiddleFnRequestsList extends HSubRequest<any>[]> {\n    readonly path: string;\n    readonly requestId: string;\n    readonly subRequestList: {[key: string]: SubRequest<any>} = {};\n    response: Response | undefined;\n\n    constructor(\n        public readonly options: ClientOptions,\n        private readonly prefilledMiddleFnsCache: PrefilledMiddleFnsCache,\n        public readonly route?: RR,\n        public readonly middleFns?: MiddleFnRequestsList,\n        /** Array of routesFlow subrequests when executing a routesFlow */\n        public readonly workflowSubRequests?: RSubRequest<any>[]\n    ) {\n        if (workflowSubRequests && workflowSubRequests.length > 0) {\n            const routePaths = workflowSubRequests.map((sr) => getRoutePath(sr.pointer, this.options));\n            const query = buildRoutesFlowQuery(routePaths, workflowSubRequests);\n            const flowPath = getRoutePath([ROUTES_FLOW_KEY], this.options);\n            this.path = `${flowPath}?data=${toBase64Url(JSON.stringify(query))}`;\n            this.requestId = 'mion-routes-flow';\n            workflowSubRequests.forEach((sr) => this.addSubRequest(sr));\n        } else {\n            this.path = route ? getRoutePath(route.pointer, this.options) : 'no-route';\n            this.requestId = route ? route.id : 'no-route';\n            if (route) this.addSubRequest(route);\n        }\n        if (middleFns) middleFns.forEach((middleFn) => this.addSubRequest(middleFn));\n    }\n\n    /** Calls a remote route */\n    async call(): Promise<ResponseBody> {\n        const errors: RequestErrors = new Map();\n\n        try {\n            const subRequestIds = Object.keys(this.subRequestList);\n            await fetchRemoteMethodsMetadata(subRequestIds, this.options);\n\n            this.restorePrefilledMiddleFns(errors);\n            if (errors.size) return Promise.reject(errors);\n\n            validateSubRequests(subRequestIds, this, errors);\n            if (errors.size) return Promise.reject(errors);\n        } catch (error: any) {\n            this.onError(error, 'Error preparing request', errors);\n            return Promise.reject(errors);\n        }\n\n        try {\n            const serialized = serializeRequestBody(this);\n            const headersFromParams = extractRequestHeaders(this);\n\n            const url = new URL(this.path, this.options.baseURL);\n            let fetchOptions: RequestInit;\n\n            if (this.isQueryRoute() && serialized.contentType.includes('json')) {\n                const encoded = toBase64Url(serialized.body as string);\n                const testUrl = new URL(this.path, this.options.baseURL);\n                testUrl.searchParams.set('data', encoded);\n\n                if (testUrl.toString().length <= MAX_GET_URL_LENGTH) {\n                    url.searchParams.set('data', encoded);\n                    fetchOptions = {\n                        ...this.options.fetchOptions,\n                        method: 'GET',\n                        headers: {...this.options.fetchOptions.headers, ...headersFromParams},\n                        body: undefined,\n                    };\n                } else {\n                    fetchOptions = {\n                        ...this.options.fetchOptions,\n                        method: 'POST',\n                        headers: {\n                            ...this.options.fetchOptions.headers,\n                            ...headersFromParams,\n                            'Content-Type': serialized.contentType,\n                        },\n                        body: serialized.body as BodyInit,\n                    };\n                }\n            } else {\n                fetchOptions = {\n                    ...this.options.fetchOptions,\n                    method: 'POST',\n                    headers: {...this.options.fetchOptions.headers, ...headersFromParams, 'Content-Type': serialized.contentType},\n                    body: serialized.body as BodyInit,\n                };\n            }\n            this.response = await fetch(url, fetchOptions);\n        } catch (error: any) {\n            this.onError(error, 'Error executing request', errors);\n            return Promise.reject(errors);\n        }\n\n        try {\n            const deserialized = await deserializeResponseBody(this.response);\n\n            if (MION_ROUTES.platformError in deserialized) {\n                const platformError = deserialized[MION_ROUTES.platformError];\n                Object.entries(this.subRequestList).forEach(([id, methodMeta]) => {\n                    methodMeta.isResolved = true;\n                    methodMeta.error = platformError as RpcError<string>;\n                    errors.set(id, platformError as RpcError<string>);\n                });\n                return Promise.reject(errors);\n            }\n\n            Object.entries(this.subRequestList).forEach(([id, methodMeta]) => {\n                const resp = this.getResponseValueFromBodyOrHeader(id, deserialized, (this.response as Response).headers);\n                methodMeta.isResolved = true;\n                if (isRpcError(resp)) {\n                    methodMeta.error = resp;\n                    errors.set(id, resp);\n                } else {\n                    methodMeta.resolvedValue = resp;\n                }\n            });\n\n            Object.entries(deserialized).forEach(([id, value]) => {\n                if (!(id in this.subRequestList) && isRpcError(value)) {\n                    errors.set(id, value);\n                }\n            });\n\n            if (errors.size) return Promise.reject(errors);\n            return deserialized;\n        } catch (error) {\n            this.onError(error, 'Error parsing response', errors);\n            return Promise.reject(errors);\n        }\n    }\n\n    /** Validate params */\n    async validateParams(subReqList?: SubRequest<any>[]): Promise<RunTypeError[]> {\n        if (subReqList) subReqList.forEach((subRequest) => this.addSubRequest(subRequest));\n        const errors: RequestErrors = new Map();\n        try {\n            const subRequestIds = Object.keys(this.subRequestList);\n            await fetchRemoteMethodsMetadata(subRequestIds, this.options);\n            validateSubRequests(subRequestIds, this, errors, false);\n            return Object.values(this.subRequestList)\n                .map((subRequest) => subRequest.error?.errorData || [])\n                .flat();\n        } catch (error: any) {\n            this.onError(error, 'Error preparing request', errors);\n            return Promise.reject(errors);\n        }\n    }\n\n    /** Prefills and stores SubRequest */\n    async prefill(subReqList?: SubRequest<any>[]): Promise<void> {\n        if (subReqList) subReqList.forEach((subRequest) => this.addSubRequest(subRequest));\n        const errors: RequestErrors = new Map();\n        try {\n            const subRequestIds = Object.keys(this.subRequestList);\n            await fetchRemoteMethodsMetadata(subRequestIds, this.options);\n\n            validateSubRequests(subRequestIds, this, errors, false);\n            if (errors.size) return Promise.reject(errors);\n\n            serializeRequestBody(this);\n\n            this.storePrefilledMiddleFns(errors);\n            if (errors.size) return Promise.reject(errors);\n\n            return;\n        } catch (error: any) {\n            this.onError(error, 'Error preparing request', errors);\n            return Promise.reject(errors);\n        }\n    }\n\n    /** Removes Prefills and stores SubRequest */\n    async removePrefill(subRequests?: SubRequest<any>[]): Promise<void> {\n        if (subRequests) subRequests.forEach((subRequest) => this.addSubRequest(subRequest));\n        this.removePrefilledMiddleFns();\n    }\n\n    addSubRequest(subRequest: SubRequest<any>) {\n        if (subRequest.isResolved) throw new Error(`SubRequest ${subRequest.id} is already resolved`);\n        this.subRequestList[subRequest.id] = subRequest;\n    }\n\n    private onError(error: any, stageMessage: string, errors: RequestErrors): void {\n        if (isRpcError(error)) {\n            errors.set(this.requestId, error);\n            return;\n        }\n        const message = error?.message ? `${stageMessage}: ${error.message}` : `${stageMessage}: Unknown Error`;\n        errors.set(\n            this.requestId,\n            new RpcError({\n                type: error?.name || 'unknown-error',\n                publicMessage: message,\n                originalError: error instanceof Error ? error : undefined,\n            })\n        );\n    }\n\n    private getResponseValueFromBodyOrHeader(id: string, respBody: ResponseBody, headers: Headers): any {\n        const headersSubset = reconstructHeadersSubsetFromResponse(id, headers);\n        if (headersSubset) return headersSubset;\n        return respBody[id];\n    }\n\n    private restorePrefilledMiddleFns(errors: RequestErrors): void {\n        if (this.workflowSubRequests && this.workflowSubRequests.length > 0) {\n            this.restorePrefilledMiddleFnsForWorkflow(errors);\n            return;\n        }\n\n        const methodMeta = routesCache.getMetadata(this.requestId);\n        if (!methodMeta) {\n            errors.set(\n                this.requestId,\n                new RpcError({\n                    type: 'route-metadata-not-found',\n                    publicMessage: `Metadata for Route '${this.requestId} not found.'.`,\n                })\n            );\n            return;\n        }\n        const missingIds = methodMeta.middleFnIds?.filter((id) => !!id && this.requestId !== id) || [];\n        missingIds.forEach((id) => {\n            const subRequest = this.subRequestList[id];\n            if (subRequest) return;\n            const cacheKey = this.getPrefilledMiddleFnCacheKey(id);\n            const cachedSubRequest = this.prefilledMiddleFnsCache.get(cacheKey);\n            if (cachedSubRequest) {\n                const clonedSubRequest: SubRequest<any> = {\n                    ...cachedSubRequest,\n                    isResolved: false,\n                    resolvedValue: undefined,\n                    error: undefined,\n                };\n                this.addSubRequest(clonedSubRequest);\n            }\n        });\n    }\n\n    /** Restore prefilled middleFns for all routes in a routesFlow, deduplicating by ID */\n    private restorePrefilledMiddleFnsForWorkflow(errors: RequestErrors): void {\n        const workflowRouteIds = new Set(this.workflowSubRequests!.map((sr) => sr.id));\n\n        for (const routeSubRequest of this.workflowSubRequests!) {\n            const methodMeta = routesCache.getMetadata(routeSubRequest.id);\n            if (!methodMeta) {\n                errors.set(\n                    routeSubRequest.id,\n                    new RpcError({\n                        type: 'route-metadata-not-found',\n                        publicMessage: `Metadata for Route '${routeSubRequest.id}' not found.`,\n                    })\n                );\n                continue;\n            }\n            const missingIds = methodMeta.middleFnIds?.filter((id) => !!id && !workflowRouteIds.has(id)) || [];\n            missingIds.forEach((id) => {\n                const subRequest = this.subRequestList[id];\n                if (subRequest) return;\n                const cacheKey = this.getPrefilledMiddleFnCacheKey(id);\n                const cachedSubRequest = this.prefilledMiddleFnsCache.get(cacheKey);\n                if (cachedSubRequest) {\n                    const clonedSubRequest: SubRequest<any> = {\n                        ...cachedSubRequest,\n                        isResolved: false,\n                        resolvedValue: undefined,\n                        error: undefined,\n                    };\n                    this.addSubRequest(clonedSubRequest);\n                }\n            });\n        }\n    }\n\n    private storePrefilledMiddleFns(errors: RequestErrors): void {\n        Object.keys(this.subRequestList).forEach((id) => {\n            const subRequest = this.subRequestList[id];\n            const methodMeta = routesCache.getMetadata(id);\n            if (!methodMeta) throw new Error(`Remote method ${id} not found.`);\n            if (methodMeta.type === HandlerType.route) {\n                errors.set(\n                    id,\n                    new RpcError({\n                        type: 'routes-cant-be-prefilled',\n                        publicMessage: `Remote method ${id} is a route and can't be prefilled.`,\n                    })\n                );\n                return;\n            }\n            const cacheKey = this.getPrefilledMiddleFnCacheKey(id);\n            this.prefilledMiddleFnsCache.set(cacheKey, subRequest);\n        });\n    }\n\n    private removePrefilledMiddleFns(): void {\n        Object.keys(this.subRequestList).forEach((id) => {\n            const cacheKey = this.getPrefilledMiddleFnCacheKey(id);\n            this.prefilledMiddleFnsCache.delete(cacheKey);\n        });\n    }\n\n    /** Returns true if the route is a query (isMutation === false) and not a routesFlow */\n    private isQueryRoute(): boolean {\n        if (this.workflowSubRequests) return false;\n        const meta = routesCache.getMetadata(this.requestId);\n        // strict false value required for queries\n        return meta?.options?.isMutation === false;\n    }\n\n    private getPrefilledMiddleFnCacheKey(id: string): string {\n        return `${this.options.baseURL}:${id}`;\n    }\n}\n\n/** Extracts headers from HeadersSubset params in headersFn methods */\nfunction extractRequestHeaders(req: MionClientRequest<any, any>): Record<string, string> {\n    const headers: Record<string, 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\n        const method = routesCache.getMetadata(id);\n        if (!method || method.type !== HandlerType.headersMiddleFn || !method.headersParam) continue;\n\n        const params = subRequest.params;\n        const extracted = extractHeadersFromParams(params);\n        Object.assign(headers, extracted);\n    }\n\n    return headers;\n}\n\n/** Extracts headers from a HeadersSubset parameter */\nfunction extractHeadersFromParams(params: any[]): Record<string, string> {\n    if (!params || params.length === 0) {\n        throw new RpcError({\n            type: 'missing-headers-param',\n            publicMessage: 'HeadersFn requires a HeadersSubset parameter.',\n        });\n    }\n\n    const firstParam = params[0];\n\n    if (firstParam instanceof HeadersSubset) {\n        return firstParam.headers as Record<string, string>;\n    }\n\n    if (firstParam && typeof firstParam === 'object' && 'headers' in firstParam && typeof firstParam.headers === 'object') {\n        return firstParam.headers as Record<string, string>;\n    }\n\n    throw new RpcError({\n        type: 'invalid-headers-param',\n        publicMessage: 'HeadersFn first parameter must be a HeadersSubset instance or object with headers property.',\n    });\n}\n\n/** Reconstructs a HeadersSubset from HTTP response headers for methods that return HeadersSubset */\nfunction reconstructHeadersSubsetFromResponse(\n    methodId: string,\n    responseHeaders: Headers\n): HeadersSubset<string, string> | undefined {\n    const method = routesCache.getMetadata(methodId);\n\n    if (!method?.headersReturn?.headerNames || method.headersReturn.headerNames.length === 0) {\n        return undefined;\n    }\n\n    const headerNames = method.headersReturn.headerNames;\n    const headersMap: Record<string, string> = {};\n\n    for (const name of headerNames) {\n        const value = responseHeaders.get(name);\n        if (value !== undefined && value !== null) {\n            headersMap[name] = value;\n        }\n    }\n\n    if (Object.keys(headersMap).length > 0) {\n        return new HeadersSubset(headersMap);\n    }\n\n    return undefined;\n}\n\n/** Builds a RoutesFlowQuery from route paths and subrequests, collecting any mapFrom mappings */\nfunction buildRoutesFlowQuery(routePaths: string[], workflowSubRequests: RSubRequest<any>[]): RoutesFlowQuery {\n    const allMappings: RoutesFlowMapping[] = [];\n    for (const sr of workflowSubRequests) {\n        // Duck-type check for mappings array (avoids circular import of MionSubRequest)\n        const mappings = (sr as any).mappings;\n        if (Array.isArray(mappings) && mappings.length > 0) {\n            for (const ref of mappings) {\n                allMappings.push({\n                    fromId: ref.fromRequestId,\n                    toId: ref.toRequestId,\n                    bodyHash: ref.bodyHash,\n                    paramIndex: ref.paramIndex,\n                });\n            }\n        }\n    }\n    return {\n        routes: routePaths,\n        mappings: allMappings.length > 0 ? allMappings : undefined,\n    };\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/routesFlow.js

@@ -1,7 +1,4 @@
-import { PURE_SERVER_FN_NAMESPACE, RpcError, __ΩMapFromServerFnRef as ___MapFromServerFnRef } from "@mionjs/core";
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
+import { PURE_SERVER_FN_NAMESPACE, RpcError } from "@mionjs/core";
 async function routesFlow(routeSubRequests, middleFns) {
   if (!routeSubRequests || routeSubRequests.length === 0)
     throw new RpcError({
@@ -26,7 +23,6 @@ async function routesFlow(routeSubRequests, middleFns) {
   });
   return [results ?? emptyResults, errors ?? emptyErrors, middleFnResults, middleFnErrors];
 }
-routesFlow.__type = ["routeSubRequests", "middleFns", "WorkflowResult", "routesFlow", 'PP"@G2!"2"8"w#`/$'];
 const mapFromSymbol = /* @__PURE__ */ Symbol("MapFromServerFnRef");
 function mapFrom(source, mapper, bodyHash) {
   if (!bodyHash)
@@ -41,17 +37,16 @@ function mapFrom(source, mapper, bodyHash) {
     fromRequestId: source.id,
     toRequestId: "",
     paramIndex: -1,
-    type: __assignType(function() {
+    // set by MionSubRequest constructor when passed as a parameter
+    type() {
       return ref;
-    }, ["type", 'P"/!'])
+    }
   };
   return ref;
 }
-mapFrom.__type = ["source", "resolvedValue", "value", "", "mapper", "bodyHash", () => ___MapFromServerFnRef, "resolvedValue", "mapFrom", `P"2!P"."f2#"/$2%&2&8P".(f2#"/$o'"/)`];
 function isMapFromRef(ref) {
   return ref && ref.mapFromSymbol === mapFromSymbol;
 }
-isMapFromRef.__type = ["ref", "isMapFromRef", 'P"2!!/"'];
 export {
   isMapFromRef,
   mapFrom,