@mionjs/client 0.8.0-alpha.0 → 0.8.4

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

@@ -1,104 +1,96 @@
-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 { getRoutePath, toBase64Url, routesCache, MION_ROUTES, isRpcError, RpcError, HandlerType, HeadersSubset } from "@mionjs/core";
+import { fetchRemoteMethodsMetadata } from "./lib/fetchRemoteMethodsMetadata.js";
+import { createMetadataSubRequest } 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;
   route;
   middleFns;
   workflowSubRequests;
+  signal;
   path;
   requestId;
   subRequestList = {};
   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!"/"']));
+  constructor(options, prefilledMiddleFnsCache, route, middleFns, workflowSubRequests, signal) {
+    if (this.options = options, this.prefilledMiddleFnsCache = prefilledMiddleFnsCache, this.route = route, this.middleFns = middleFns, this.workflowSubRequests = workflowSubRequests, this.signal = signal, workflowSubRequests && workflowSubRequests.length > 0) {
+      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() {
-    const errors = /* @__PURE__ */ new Map();
+    if (this.signal?.aborted) {
+      const errors = /* @__PURE__ */ new Map();
+      return this.onError(this.signal.reason ?? new DOMException("This operation was aborted", "AbortError"), "Request aborted", errors), Promise.reject(errors);
+    }
+    return this.makeCall(this.options.serializer);
+  }
+  /** Call flow that auto-detects missing metadata and uses optimistic serialization when needed */
+  async makeCall(originalSerializer, skipOptimistic) {
+    const errors = /* @__PURE__ */ new Map(), subRequestIds = Object.keys(this.subRequestList), isOptimistic = !subRequestIds.every((id) => routesCache.hasMetadata(id)) && !skipOptimistic;
     try {
-      const subRequestIds = Object.keys(this.subRequestList);
-      if (await fetchRemoteMethodsMetadata(subRequestIds, this.options), this.restorePrefilledMiddleFns(errors), errors.size || (validateSubRequests(subRequestIds, this, errors), errors.size))
+      if (isOptimistic) {
+        this.options.serializer = "optimistic", this.restorePrefilledMiddleFns();
+        const allSubRequestIds = Object.keys(this.subRequestList);
+        this.addSubRequest(createMetadataSubRequest(allSubRequestIds));
+      } else if (this.options.serializer = originalSerializer, await fetchRemoteMethodsMetadata(subRequestIds, this.options, this.signal), this.restorePrefilledMiddleFns(errors), errors.size || (validateSubRequests(subRequestIds, this, errors), errors.size))
         return Promise.reject(errors);
     } catch (error) {
       return this.onError(error, "Error preparing request", errors), Promise.reject(errors);
     }
     try {
-      const serialized = serializeRequestBody(this), headersFromParams = extractRequestHeaders(this), url = new URL(this.path, this.options.baseURL);
-      let fetchOptions;
-      if (this.isQueryRoute() && serialized.contentType.includes("json")) {
-        const encoded = toBase64Url(serialized.body), testUrl = new URL(this.path, this.options.baseURL);
-        testUrl.searchParams.set("data", encoded), testUrl.toString().length <= MAX_GET_URL_LENGTH ? (url.searchParams.set("data", encoded), fetchOptions = {
-          ...this.options.fetchOptions,
-          method: "GET",
-          headers: { ...this.options.fetchOptions.headers, ...headersFromParams },
-          body: void 0
-        }) : fetchOptions = {
-          ...this.options.fetchOptions,
-          method: "POST",
-          headers: {
-            ...this.options.fetchOptions.headers,
-            ...headersFromParams,
-            "Content-Type": serialized.contentType
-          },
-          body: serialized.body
-        };
-      } else
-        fetchOptions = {
-          ...this.options.fetchOptions,
-          method: "POST",
-          headers: { ...this.options.fetchOptions.headers, ...headersFromParams, "Content-Type": serialized.contentType },
-          body: serialized.body
-        };
+      let serialized;
+      try {
+        serialized = serializeRequestBody(this);
+      } catch (serializeError) {
+        if (isOptimistic)
+          return delete this.subRequestList[MION_ROUTES.methodsMetadata], this.makeCall(originalSerializer, !0);
+        throw serializeError;
+      }
+      const headersFromParams = extractRequestHeaders(this), url = new URL(this.path, this.options.baseURL), fetchOptions = buildFetchOptions(url, serialized, headersFromParams, this.options, isOptimistic, this.isQueryRoute(), this.signal);
       this.response = await fetch(url, fetchOptions);
     } catch (error) {
       return this.onError(error, "Error executing request", errors), Promise.reject(errors);
     }
     try {
-      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]) => {
-          methodMeta.isResolved = !0, methodMeta.error = platformError, errors.set(id, platformError);
-        }, ["param0", "", 'P"2!"/"'])), Promise.reject(errors);
-      }
-      return Object.entries(this.subRequestList).forEach(__assignType(([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]) => {
-        !(id in this.subRequestList) && isRpcError(value) && errors.set(id, value);
-      }, ["param0", "", 'P"2!"/"'])), errors.size ? Promise.reject(errors) : deserialized;
+      if (this.signal?.aborted)
+        return this.onError(this.signal.reason, "Request aborted", errors), Promise.reject(errors);
+      const deserialized = await deserializeResponseBody(this.response, this.options);
+      return this.handlePlatformError(deserialized, errors) ? Promise.reject(errors) : isOptimistic && !this.signal?.aborted && this.shouldRetryWithProperSerialization(deserialized) ? this.retryWithProperSerialization(originalSerializer) : (this.resolveSubRequests(deserialized, errors, isOptimistic ? MION_ROUTES.methodsMetadata : void 0), errors.size ? Promise.reject(errors) : deserialized);
     } catch (error) {
       return this.onError(error, "Error parsing response", errors), Promise.reject(errors);
     }
   }
+  /** Checks if the response contains errors that require retry with proper JIT serialization */
+  shouldRetryWithProperSerialization(deserialized) {
+    return Object.values(deserialized).some((value) => isRpcError(value) && (value.type === "serialization-error" || value.type === "validation-error" || value.type === "parsing-json-request-error"));
+  }
+  /** Retries the request with proper JIT serialization after metadata has been cached */
+  async retryWithProperSerialization(originalSerializer) {
+    return delete this.subRequestList[MION_ROUTES.methodsMetadata], Object.values(this.subRequestList).forEach((sr) => {
+      sr.isResolved = !1, sr.resolvedValue = void 0, sr.error = void 0;
+    }), this.makeCall(originalSerializer);
+  }
   /** 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,14 +101,53 @@ 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)
       throw new Error(`SubRequest ${subRequest.id} is already resolved`);
     this.subRequestList[subRequest.id] = subRequest;
   }
+  /** Checks for platform-level errors and propagates them to all subrequests. Returns true if a platform error was found */
+  handlePlatformError(deserialized, errors) {
+    if (!(MION_ROUTES.platformError in deserialized))
+      return !1;
+    const platformError = deserialized[MION_ROUTES.platformError];
+    return Object.entries(this.subRequestList).forEach(([id, methodMeta]) => {
+      methodMeta.isResolved = !0, methodMeta.error = platformError, errors.set(id, platformError);
+    }), !0;
+  }
+  /** Resolves sub request values from the deserialized response body and collects errors */
+  resolveSubRequests(deserialized, errors, skipId) {
+    Object.entries(this.subRequestList).forEach(([id, methodMeta]) => {
+      if (id === skipId)
+        return;
+      const resp = this.getResponseValueFromBodyOrHeader(id, deserialized, this.response.headers);
+      methodMeta.isResolved = !0, isRpcError(resp) ? (methodMeta.error = resp, errors.set(id, resp)) : methodMeta.resolvedValue = resp;
+    }), Object.entries(deserialized).forEach(([id, value]) => {
+      !(id in this.subRequestList) && isRpcError(value) && errors.set(id, value);
+    });
+  }
   onError(error, stageMessage, errors) {
+    const reason = this.signal?.aborted ? this.signal.reason : void 0;
+    if (reason instanceof DOMException) {
+      if (reason.name === "TimeoutError") {
+        errors.set(this.requestId, new RpcError({
+          type: "request-timeout",
+          publicMessage: "Request timed out",
+          originalError: error instanceof Error ? error : void 0
+        }));
+        return;
+      }
+      if (reason.name === "AbortError") {
+        errors.set(this.requestId, new RpcError({
+          type: "request-aborted",
+          publicMessage: "Request was aborted",
+          originalError: error instanceof Error ? error : void 0
+        }));
+        return;
+      }
+    }
     if (isRpcError(error)) {
       errors.set(this.requestId, error);
       return;
@@ -132,6 +163,7 @@ class MionClientRequest {
     const headersSubset = reconstructHeadersSubsetFromResponse(id, headers);
     return headersSubset || respBody[id];
   }
+  /** When errors is omitted, silently skips routes without cached metadata (used by optimistic flow) */
   restorePrefilledMiddleFns(errors) {
     if (this.workflowSubRequests && this.workflowSubRequests.length > 0) {
       this.restorePrefilledMiddleFnsForWorkflow(errors);
@@ -139,13 +171,13 @@ class MionClientRequest {
     }
     const methodMeta = routesCache.getMetadata(this.requestId);
     if (!methodMeta) {
-      errors.set(this.requestId, new RpcError({
+      errors && errors.set(this.requestId, new RpcError({
         type: "route-metadata-not-found",
         publicMessage: `Metadata for Route '${this.requestId} not found.'.`
       }));
       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,21 +190,21 @@ 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) {
-        errors.set(routeSubRequest.id, new RpcError({
+        errors && errors.set(routeSubRequest.id, new RpcError({
           type: "route-metadata-not-found",
           publicMessage: `Metadata for Route '${routeSubRequest.id}' not found.`
         }));
         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 +217,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 +234,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 +249,26 @@ 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 buildFetchOptions(url, serialized, headersFromParams, options, isOptimistic, isQuery, signal) {
+  if (!isOptimistic && isQuery && serialized.contentType.includes("json")) {
+    const encoded = toBase64Url(serialized.body), testUrl = new URL(url.pathname + url.search, url.origin);
+    if (testUrl.searchParams.set("data", encoded), testUrl.toString().length <= MAX_GET_URL_LENGTH)
+      return url.searchParams.set("data", encoded), {
+        ...options.fetchOptions,
+        method: "GET",
+        headers: { ...options.fetchOptions.headers, ...headersFromParams },
+        body: void 0,
+        signal
+      };
+  }
+  return {
+    ...options.fetchOptions,
+    method: "POST",
+    headers: { ...options.fetchOptions.headers, ...headersFromParams, "Content-Type": serialized.contentType },
+    body: serialized.body,
+    signal
+  };
 }
 function extractRequestHeaders(req) {
   const headers = {}, subRequestIds = Object.keys(req.subRequestList);
@@ -235,7 +284,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 +298,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 +310,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 +328,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 {\n    ClientOptions,\n    MiddlewareSubRequest,\n    SubRequest,\n    RouteSubRequest,\n    RequestErrors,\n    PrefilledMiddleFnsCache,\n} from './types.ts';\nimport type {RunTypeError, RoutesFlowQuery, RoutesFlowMapping} from '@mionjs/core';\nimport {RpcError, isRpcError, routesCache, MION_ROUTES, HandlerType, HeadersSubset, toBase64Url} from '@mionjs/core';\nimport type {SerializerMode} from '@mionjs/core';\nimport {getRoutePath} from '@mionjs/core';\nimport {fetchRemoteMethodsMetadata} from './lib/fetchRemoteMethodsMetadata.ts';\nimport {createMetadataSubRequest} 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 RouteSubRequest<any>, MiddleFnRequestsList extends MiddlewareSubRequest<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?: RouteSubRequest<any>[],\n        /** Composed abort signal for this request */\n        public readonly signal?: AbortSignal\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        if (this.signal?.aborted) {\n            const errors: RequestErrors = new Map();\n            this.onError(\n                this.signal.reason ?? new DOMException('This operation was aborted', 'AbortError'),\n                'Request aborted',\n                errors\n            );\n            return Promise.reject(errors);\n        }\n        return this.makeCall(this.options.serializer);\n    }\n\n    /** Call flow that auto-detects missing metadata and uses optimistic serialization when needed */\n    private async makeCall(originalSerializer: SerializerMode, skipOptimistic?: boolean): Promise<ResponseBody> {\n        const errors: RequestErrors = new Map();\n        const subRequestIds = Object.keys(this.subRequestList);\n        const allCached = subRequestIds.every((id) => routesCache.hasMetadata(id));\n        const isOptimistic = !allCached && !skipOptimistic;\n\n        try {\n            if (isOptimistic) {\n                (this.options as any).serializer = 'optimistic';\n                this.restorePrefilledMiddleFns();\n                // Add metadata subrequest (after prefilled restore so we include all IDs)\n                const allSubRequestIds = Object.keys(this.subRequestList);\n                this.addSubRequest(createMetadataSubRequest(allSubRequestIds));\n            } else {\n                (this.options as any).serializer = originalSerializer;\n                await fetchRemoteMethodsMetadata(subRequestIds, this.options, this.signal);\n                this.restorePrefilledMiddleFns(errors);\n                if (errors.size) return Promise.reject(errors);\n                validateSubRequests(subRequestIds, this, errors);\n                if (errors.size) return Promise.reject(errors);\n            }\n        } catch (error: any) {\n            this.onError(error, 'Error preparing request', errors);\n            return Promise.reject(errors);\n        }\n\n        try {\n            let serialized: ReturnType<typeof serializeRequestBody>;\n            try {\n                serialized = serializeRequestBody(this);\n            } catch (serializeError) {\n                if (isOptimistic) {\n                    // JSON.stringify failed → fall back to standard, will fetch metadata\n                    delete this.subRequestList[MION_ROUTES.methodsMetadata];\n                    return this.makeCall(originalSerializer, true);\n                }\n                throw serializeError;\n            }\n\n            const headersFromParams = extractRequestHeaders(this);\n            const url = new URL(this.path, this.options.baseURL);\n            const fetchOptions = buildFetchOptions(\n                url,\n                serialized,\n                headersFromParams,\n                this.options,\n                isOptimistic,\n                this.isQueryRoute(),\n                this.signal\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            // If the signal already aborted while fetch was in flight, don't try to read a possibly\n            // truncated response body — surface the abort directly.\n            if (this.signal?.aborted) {\n                this.onError(this.signal.reason, 'Request aborted', errors);\n                return Promise.reject(errors);\n            }\n            const deserialized = await deserializeResponseBody(this.response, this.options);\n            if (this.handlePlatformError(deserialized, errors)) return Promise.reject(errors);\n\n            // Never retry an aborted request — the user explicitly canceled it.\n            if (isOptimistic && !this.signal?.aborted && this.shouldRetryWithProperSerialization(deserialized)) {\n                return this.retryWithProperSerialization(originalSerializer);\n            }\n\n            this.resolveSubRequests(deserialized, errors, isOptimistic ? MION_ROUTES.methodsMetadata : undefined);\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    /** Checks if the response contains errors that require retry with proper JIT serialization */\n    private shouldRetryWithProperSerialization(deserialized: ResponseBody): boolean {\n        return Object.values(deserialized).some(\n            (value) =>\n                isRpcError(value) &&\n                (value.type === 'serialization-error' ||\n                    value.type === 'validation-error' ||\n                    value.type === 'parsing-json-request-error')\n        );\n    }\n\n    /** Retries the request with proper JIT serialization after metadata has been cached */\n    private async retryWithProperSerialization(originalSerializer: SerializerMode): Promise<ResponseBody> {\n        delete this.subRequestList[MION_ROUTES.methodsMetadata];\n        Object.values(this.subRequestList).forEach((sr) => {\n            sr.isResolved = false;\n            sr.resolvedValue = undefined;\n            sr.error = undefined;\n        });\n        return this.makeCall(originalSerializer);\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    /** Checks for platform-level errors and propagates them to all subrequests. Returns true if a platform error was found */\n    private handlePlatformError(deserialized: ResponseBody, errors: RequestErrors): boolean {\n        if (!(MION_ROUTES.platformError in deserialized)) return false;\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 true;\n    }\n\n    /** Resolves sub request values from the deserialized response body and collects errors */\n    private resolveSubRequests(deserialized: ResponseBody, errors: RequestErrors, skipId?: string): void {\n        Object.entries(this.subRequestList).forEach(([id, methodMeta]) => {\n            if (id === skipId) return;\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\n    private onError(error: any, stageMessage: string, errors: RequestErrors): void {\n        // Detect abort/timeout via signal.reason FIRST. We must do this before the isRpcError early return\n        // because errors that surface from later stages (deserialization, retry, etc.) may already be\n        // wrapped as RpcError but the user-facing reason is still abort/timeout.\n        const reason = this.signal?.aborted ? this.signal.reason : undefined;\n        if (reason instanceof DOMException) {\n            if (reason.name === 'TimeoutError') {\n                errors.set(\n                    this.requestId,\n                    new RpcError({\n                        type: 'request-timeout',\n                        publicMessage: 'Request timed out',\n                        originalError: error instanceof Error ? error : undefined,\n                    })\n                );\n                return;\n            }\n            if (reason.name === 'AbortError') {\n                errors.set(\n                    this.requestId,\n                    new RpcError({\n                        type: 'request-aborted',\n                        publicMessage: 'Request was aborted',\n                        originalError: error instanceof Error ? error : undefined,\n                    })\n                );\n                return;\n            }\n        }\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    /** When errors is omitted, silently skips routes without cached metadata (used by optimistic flow) */\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            if (errors) {\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            }\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                if (errors) {\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                }\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/**\n * Builds the RequestInit options for the fetch call, choosing between GET and POST:\n * - GET (query): Used for non-mutation routes (isMutation === false) with JSON serialization,\n *   where the base64url-encoded body fits within the URL length limit. The serialized data is\n *   sent as a `?data=` query parameter, with no request body.\n * - POST (mutation/route call): Used for all other cases: mutations, optimistic requests,\n *   routesFlow calls, non-JSON serializers, or when the GET URL would exceed MAX_GET_URL_LENGTH.\n *   The serialized data is sent in the request body with the appropriate Content-Type header.\n */\nfunction buildFetchOptions(\n    url: URL,\n    serialized: ReturnType<typeof serializeRequestBody>,\n    headersFromParams: Record<string, string>,\n    options: ClientOptions,\n    isOptimistic: boolean,\n    isQuery: boolean,\n    signal?: AbortSignal\n): RequestInit {\n    if (!isOptimistic && isQuery && serialized.contentType.includes('json')) {\n        const encoded = toBase64Url(serialized.body as string);\n        const testUrl = new URL(url.pathname + url.search, url.origin);\n        testUrl.searchParams.set('data', encoded);\n\n        if (testUrl.toString().length <= MAX_GET_URL_LENGTH) {\n            url.searchParams.set('data', encoded);\n            return {\n                ...options.fetchOptions,\n                method: 'GET',\n                headers: {...options.fetchOptions.headers, ...headersFromParams},\n                body: undefined,\n                signal,\n            };\n        }\n    }\n\n    return {\n        ...options.fetchOptions,\n        method: 'POST',\n        headers: {...options.fetchOptions.headers, ...headersFromParams, 'Content-Type': serialized.contentType},\n        body: serialized.body as BodyInit,\n        signal,\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: RouteSubRequest<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.d.ts

@@ -1,6 +1,6 @@
-import { HSubRequest, RSubRequest, SubRequest, WorkflowResult } from './types.ts';
+import { RouteSubRequest, RoutesFlowBuilder, SubRequest } from './types.ts';
 import { MapFromServerFnRef } from '@mionjs/core';
-export declare function routesFlow<Routes extends RSubRequest<any>[], MiddleFns extends Record<string, HSubRequest<any>> = Record<string, never>>(routeSubRequests: [...Routes], middleFns?: MiddleFns): Promise<WorkflowResult<Routes, MiddleFns>>;
+export declare function routesFlow<Routes extends RouteSubRequest<any>[]>(routeSubRequests: [...Routes]): RoutesFlowBuilder<Routes>;
 export declare const mapFromSymbol: unique symbol;
 export declare function mapFrom<FromSR extends SubRequest<any>, MappedInput>(source: FromSR, mapper: (value: FromSR['resolvedValue']) => MappedInput, bodyHash?: string): MapFromServerFnRef<(value: FromSR['resolvedValue']) => MappedInput>;
 export declare function isMapFromRef(ref: any): ref is MapFromServerFnRef<any>;

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

@@ -1,8 +1,5 @@
-import { PURE_SERVER_FN_NAMESPACE, RpcError, __ΩMapFromServerFnRef as ___MapFromServerFnRef } from "@mionjs/core";
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
-async function routesFlow(routeSubRequests, middleFns) {
+import { PURE_SERVER_FN_NAMESPACE, RpcError } from "@mionjs/core";
+function routesFlow(routeSubRequests) {
   if (!routeSubRequests || routeSubRequests.length === 0)
     throw new RpcError({
       type: "routesFlow-empty-routes",
@@ -21,12 +18,15 @@ async function routesFlow(routeSubRequests, middleFns) {
         type: "routesFlow-client-mismatch",
         publicMessage: `All subrequests in a routesFlow must use the same client instance. Subrequest at index ${i} has a different client.`
       });
-  const [results, errors, middleFnResults, middleFnErrors] = await client.executeCallWithWorkflow(routeSubRequests, middleFns ?? {}), emptyResults = routeSubRequests.map(() => {
-  }), emptyErrors = routeSubRequests.map(() => {
-  });
-  return [results ?? emptyResults, errors ?? emptyErrors, middleFnResults, middleFnErrors];
+  return {
+    async call(setup) {
+      const middleFns = setup?.middleFns ?? {}, [results, errors, middleFnResults, middleFnErrors] = await client.execute(void 0, routeSubRequests, middleFns, setup?.signal, setup?.timeout), emptyResults = routeSubRequests.map(() => {
+      }), emptyErrors = routeSubRequests.map(() => {
+      });
+      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 +41,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,

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

@@ -1 +1 @@
-{"version":3,"file":"routesFlow.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"routesFlow.js","sources":["../../../src/routesFlow.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 {PURE_SERVER_FN_NAMESPACE, RpcError} from '@mionjs/core';\nimport type {MiddlewareSubRequest, RouteSubRequest, RoutesFlowBuilder, SubRequest} from './types.ts';\nimport type {MionSubRequest} from './subRequest.ts';\nimport {MapFromServerFnRef} from '@mionjs/core';\n\n/** Creates a RoutesFlowBuilder for deferred execution of multiple routes in a single HTTP request */\nexport function routesFlow<Routes extends RouteSubRequest<any>[]>(routeSubRequests: [...Routes]): RoutesFlowBuilder<Routes> {\n    if (!routeSubRequests || routeSubRequests.length === 0) {\n        throw new RpcError({\n            type: 'routesFlow-empty-routes',\n            publicMessage: 'RoutesFlow requires at least one route subrequest.',\n        });\n    }\n\n    const firstSubRequest = routeSubRequests[0] as MionSubRequest;\n    if (!firstSubRequest.client) {\n        throw new RpcError({\n            type: 'routesFlow-missing-client',\n            publicMessage: 'Could not extract MionClient from subrequest. Ensure subrequests are created via routes proxy.',\n        });\n    }\n\n    const client = firstSubRequest.client;\n\n    // Validate all subrequests use the same client instance\n    for (let i = 1; i < routeSubRequests.length; i++) {\n        const subRequest = routeSubRequests[i] as MionSubRequest;\n        if (subRequest.client !== client) {\n            throw new RpcError({\n                type: 'routesFlow-client-mismatch',\n                publicMessage: `All subrequests in a routesFlow must use the same client instance. Subrequest at index ${i} has a different client.`,\n            });\n        }\n    }\n\n    return {\n        async call(setup?: {middleFns?: Record<string, MiddlewareSubRequest<any>>; signal?: AbortSignal; timeout?: number}) {\n            const middleFns = setup?.middleFns ?? {};\n            const [results, errors, middleFnResults, middleFnErrors] = await client.execute(\n                undefined,\n                routeSubRequests as any,\n                middleFns as any,\n                setup?.signal,\n                setup?.timeout\n            );\n            const emptyResults = routeSubRequests.map(() => undefined);\n            const emptyErrors = routeSubRequests.map(() => undefined);\n            return [results ?? emptyResults, errors ?? emptyErrors, middleFnResults, middleFnErrors] as any;\n        },\n    };\n}\n\nexport const mapFromSymbol = Symbol('MapFromServerFnRef');\n\n// ╔══════════════════════════════════════════════════════════════════════════════╗\n// ║  WARNING: This function's call signature is parsed by the mion vite plugin  ║\n// ║  at build time (see devtools/src/vite-plugin/extractPureFn.ts).             ║\n// ║  Do NOT rename, change the parameter order, or modify the function          ║\n// ║  signature without updating the corresponding AST extraction and            ║\n// ║  transformer logic in @mionjs/devtools.                                    ║\n// ╚══════════════════════════════════════════════════════════════════════════════╝\n/**\n * Maps the output of one route SubRequest to the input of another within a routesFlow.\n * The mapper function must be pure (same rules as pureServerFn).\n * The bodyHash is injected at build time by the mion vite plugin.\n */\n\nexport function mapFrom<FromSR extends SubRequest<any>, MappedInput>(\n    source: FromSR,\n    mapper: (value: FromSR['resolvedValue']) => MappedInput,\n    bodyHash?: string // injected by mion vite plugin\n): MapFromServerFnRef<(value: FromSR['resolvedValue']) => MappedInput> {\n    // Important: bodyHash is injected at build time by mion vite plugin\n    if (!bodyHash) throw new Error('mapFrom() requires mion vite plugin transform to inject bodyHash');\n    const ref: MapFromServerFnRef<(value: FromSR['resolvedValue']) => MappedInput> = {\n        mapFromSymbol,\n        namespace: PURE_SERVER_FN_NAMESPACE,\n        fnName: bodyHash,\n        bodyHash,\n        pureFn: mapper,\n        isFactory: false,\n        fromRequestId: source.id,\n        toRequestId: '',\n        paramIndex: -1, // set by MionSubRequest constructor when passed as a parameter\n        type() {\n            return ref as unknown as MappedInput;\n        },\n    };\n    return ref;\n}\n\nexport function isMapFromRef(ref: any): ref is MapFromServerFnRef<any> {\n    return ref && ref.mapFromSymbol === mapFromSymbol;\n}\n"],"names":[],"mappings":";AAaM,SAAU,WAAkD,kBAA6B;AAC3F,MAAI,CAAC,oBAAoB,iBAAiB,WAAW;AACjD,UAAM,IAAI,SAAS;AAAA,MACf,MAAM;AAAA,MACN,eAAe;AAAA,IAAA,CAClB;AAGL,QAAM,kBAAkB,iBAAiB,CAAC;AAC1C,MAAI,CAAC,gBAAgB;AACjB,UAAM,IAAI,SAAS;AAAA,MACf,MAAM;AAAA,MACN,eAAe;AAAA,IAAA,CAClB;AAGL,QAAM,SAAS,gBAAgB;AAG/B,WAAS,IAAI,GAAG,IAAI,iBAAiB,QAAQ;AAEzC,QADmB,iBAAiB,CAAC,EACtB,WAAW;AACtB,YAAM,IAAI,SAAS;AAAA,QACf,MAAM;AAAA,QACN,eAAe,0FAA0F,CAAC;AAAA,MAAA,CAC7G;AAIT,SAAO;AAAA,IACH,MAAM,KAAK,OAAuG;AAC9G,YAAM,YAAY,OAAO,aAAa,CAAA,GAChC,CAAC,SAAS,QAAQ,iBAAiB,cAAc,IAAI,MAAM,OAAO,QACpE,QACA,kBACA,WACA,OAAO,QACP,OAAO,OAAO,GAEZ,eAAe,iBAAiB,IAAI,MAAA;AAAA,OAAe,GACnD,cAAc,iBAAiB,IAAI,MAAA;AAAA,OAAe;AACxD,aAAO,CAAC,WAAW,cAAc,UAAU,aAAa,iBAAiB,cAAc;AAAA,IAC3F;AAAA,EAAA;AAER;AAEO,MAAM,uCAAuB,oBAAoB;AAelD,SAAU,QACZ,QACA,QACA;AAGA,MAAI,CAAC;AAAU,UAAM,IAAI,MAAM,kEAAkE;AACjG,QAAM,MAA2E;AAAA,IAC7E;AAAA,IACA,WAAW;AAAA,IACX,QAAQ;AAAA,IACR;AAAA,IACA,QAAQ;AAAA,IACR,WAAW;AAAA,IACX,eAAe,OAAO;AAAA,IACtB,aAAa;AAAA,IACb,YAAY;AAAA;AAAA,IACZ,OAAI;AACA,aAAO;AAAA,IACX;AAAA,EAAA;AAEJ,SAAO;AACX;AAEM,SAAU,aAAa,KAAQ;AACjC,SAAO,OAAO,IAAI,kBAAkB;AACxC;"}

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

@@ -1,8 +1,8 @@
 import { RpcError, RunTypeError, MapFromServerFnRef } from '@mionjs/core';
-import { CallWithMiddleFnsResult, HSubRequest, RequestErrors, Result, RSubRequest, SubRequest, WorkflowResult } from './types.ts';
+import { CallSetup, MiddlewareSubRequest, RequestErrors, RouteSubRequest, SubRequest } from './types.ts';
 import { MionClient } from './client.ts';
-import { TypedEvent } from './typedEvent.ts';
-export declare class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RSubRequest<any>, HSubRequest<any> {
+import { TypedEvent } from './lib/typedEvent.ts';
+export declare class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RouteSubRequest<any>, MiddlewareSubRequest<any> {
     readonly client: MionClient;
     pointer: string[];
     id: string;
@@ -15,9 +15,8 @@ export declare class MionSubRequest<S = any, E extends RpcError<string, any> = a
     constructor(parentProps: string[], handlerId: string, argArray: any[], client: MionClient);
     prefill(): TypedEvent<S, E>;
     removePrefill(): Promise<void>;
-    call(): Promise<Result<S, E>>;
-    callWithMiddleFns<H extends Record<string, HSubRequest<any>>>(middleFns: H): Promise<CallWithMiddleFnsResult<S, E, H>>;
-    callWithWorkflow<OtherRoutes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(otherRoutes: [...OtherRoutes], middleFns?: H): Promise<WorkflowResult<[RSubRequest<any>, ...OtherRoutes], H>>;
+    call(setup?: CallSetup<any, any>): Promise<any>;
+    private executeWithOtherRoutes;
     typeErrors(): Promise<RunTypeError[]>;
 }
 export declare function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string>;

package/.dist/esm/src/subRequest.js

@@ -1,9 +1,6 @@
 import { RpcError } from "@mionjs/core";
-import { TypedEvent } from "./typedEvent.js";
+import { TypedEvent } from "./lib/typedEvent.js";
 import { isMapFromRef } from "./routesFlow.js";
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
 class MionSubRequest {
   client;
   pointer;
@@ -15,45 +12,34 @@ class MionSubRequest {
   serializedParams;
   mappings = [];
   constructor(parentProps, handlerId, argArray, client) {
-    this.client = client, this.pointer = [...parentProps], this.id = handlerId, this.params = argArray.map(__assignType((arg, index) => isMapFromRef(arg) ? (arg.toRequestId = this.id, arg.paramIndex = index, this.mappings.push(arg), null) : arg, ["arg", "index", "", 'P"2!"2""/#']));
+    this.client = client, this.pointer = [...parentProps], this.id = handlerId, this.params = argArray.map((arg, index) => isMapFromRef(arg) ? (arg.toRequestId = this.id, arg.paramIndex = index, this.mappings.push(arg), null) : arg);
   }
   /** Prefills MiddleFn's parameters and returns TypedEvent for event handler registration */
   prefill() {
-    const typedEvent = (TypedEvent.Ω = [["!"], ["!"]], new TypedEvent(this.id, this.client.handlersRegistry));
-    return this.client.prefill(this).catch(__assignType((errors) => {
+    const typedEvent = new TypedEvent(this.id, this.client.handlersRegistry);
+    return this.client.prefill(this).catch((errors) => {
       console.error("Prefill error:", findSubRequestError(this, errors));
-    }, ["RequestErrors", "errors", "", 'P"w!2""/#'])), typedEvent;
+    }), typedEvent;
   }
   /** Removes prefilled value and clears any registered error handlers for this middleFn */
   removePrefill() {
     return this.client.handlersRegistry.clearHandlers(this.id), this.client.removePrefill(this);
   }
-  /** Calls a remote route and returns a Result 4-tuple with full typing preserved */
-  call() {
-    return this.client.executeCall(this);
-  }
-  /** Calls a remote route with middleFns and returns a fully-typed 4-tuple result */
-  callWithMiddleFns(middleFns) {
-    if (Object.keys(middleFns).length === 0)
-      throw new Error("callWithMiddleFns requires at least one middleFn. Use call() instead for requests without middleFns.");
-    return this.client.executeCallWithMiddleFns(this, middleFns);
+  /** Calls a remote route with optional setup (middleFns, otherRoutes, signal, timeout) */
+  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);
   }
-  /** Calls this route as part of a routesFlow with other routes in a single HTTP request */
-  async callWithWorkflow(otherRoutes, middleFns) {
-    const allRoutes = [this, ...otherRoutes], [results, errors, middleFnResults, middleFnErrors] = await this.client.executeCallWithWorkflow(allRoutes, middleFns ?? {}), emptyResults = allRoutes.map(() => {
+  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, middleFnResults, middleFnErrors];
+    return [results ?? emptyResults, errors ?? emptyErrors, mfR, mfE];
   }
   /** Validates parameters and returns type errors */
   typeErrors() {
-    return this.client.typeErrors(this).catch(__assignType((errors) => Promise.reject(findSubRequestError(this, errors)), ["RequestErrors", "errors", "", 'P"w!2""/#']));
+    return this.client.typeErrors(this).catch((errors) => Promise.reject(findSubRequestError(this, errors)));
   }
-  static __type = ["S", "E", "pointer", "id", "isResolved", function() {
-    return !1;
-  }, "params", "resolvedValue", "error", "serializedParams", "MapFromServerFnRef", "mappings", function() {
-    return [];
-  }, "parentProps", "handlerId", "argArray", "MionClient", "client", "constructor", () => TypedEvent, "prefill", "removePrefill", "Result", "call", "middleFns", "CallWithMiddleFnsResult", "callWithMiddleFns", "otherRoutes", "WorkflowResult", "callWithWorkflow", "RunTypeError", "typeErrors", "RSubRequest", "HSubRequest", "MionSubRequest", '"c!"c"&F3#&3$)3%>&"F3\'e!!3(8e!"3)8"F3*8"w+F3,>-P&F2.&2/"F20"w1229"03PPe#!e#"7405P$`06P"w7`08P"29"w:`0;PP"@G2<"298"w=`0>P"w?F`0@5"wA"wBx#wC'];
 }
 function findSubRequestError(subRequest, errors) {
   const specificError = errors.get(subRequest.id);
@@ -65,7 +51,6 @@ function findSubRequestError(subRequest, errors) {
     publicMessage: "An unknown error occurred"
   });
 }
-findSubRequestError.__type = ["SubRequest", "subRequest", "RequestErrors", "errors", () => RpcError, "findSubRequestError", 'P"w!2""w#2$P&7%/&'];
 export {
   MionSubRequest,
   findSubRequestError