@mionjs/client 0.8.8 → 0.13.0

package/.dist/esm/src/dispatch.js

@@ -0,0 +1,390 @@
+import { CLIENT_REQUEST_ERROR_ID } from "./constants.js";
+import { getMethod, hasMethod } from "./lib/methods.js";
+import { getResponseError, validateSubRequests } from "./lib/validation.js";
+import { extractRequestHeaders, headersToRecord, reconstructHeadersSubsetFromResponse } from "./lib/headers.js";
+import { deserializeResponseBody, serializeRequestBody } from "./lib/serializer.js";
+import { addSubRequest, createCallContext, getRouteIds, getRoutePointers } from "./callContext.js";
+import { noteServerApiVersion, reportApiVersionMismatch, takeApiVersionError } from "./lib/apiBuildVersion.js";
+import { getMetadataFetcher } from "./lib/metadataFetcher.js";
+import { sanitizeSubRequests } from "./lib/sanitize.js";
+import { addThrownError, deleteResponseValue, getResponseValue, hasResponseValue, setResponseValue } from "./lib/clientResponse.js";
+import { BUILD_VERSION_HEADER, MION_ROUTES, ROUTER_ITEM_SEPARATOR_CHAR, RpcError, isRpcError, toBase64Url } from "@mionjs/core";
+import { takeBundledApiError } from "#bundled-api";
+async function dispatchCall(context, handlersRegistry) {
+  const metadata = getMetadataFetcher(handlersRegistry)?.startCall(context), state = {
+    context,
+    handlersRegistry,
+    metadata,
+    askedRequestHandlers: /* @__PURE__ */ new Set(),
+    sent: !1
+  }, retriedBy = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    let errors;
+    try {
+      await runCall(state);
+    } catch (requestErrors) {
+      errors = requestErrors;
+    }
+    if (metadata && await resendsForMetadata(state, metadata, errors, retriedBy)) {
+      retriedBy.add(metadata.id), resetAttempt(state);
+      continue;
+    }
+    const hooks = await runMiddlewareResponses(state, getMiddlewareSubRequests(context), errors, retriedBy);
+    if (!hooks.retryIds.length) return buildResult(state, hooks.errors);
+    hooks.retryIds.forEach((id) => retriedBy.add(id)), resetForMiddlewareRetry(state);
+  }
+}
+async function dispatchTypeErrors(options, subRequests, handlersRegistry) {
+  const context = createCallContext(options);
+  subRequests.forEach((subRequest) => addSubRequest(context, subRequest));
+  const errors = /* @__PURE__ */ new Map();
+  try {
+    const subRequestIds = Object.keys(context.subRequestList);
+    return await loadMethodsMetadata(getMetadataFetcher(handlersRegistry)?.startCall(context), subRequestIds), sanitizeSubRequests(subRequestIds, context), validateSubRequests(subRequestIds, context, errors, !1), Object.values(context.subRequestList).map((subRequest) => subRequest.error?.errorData?.typeErrors || []).flat();
+  } catch (error) {
+    return onError(context, error, "Error preparing request", errors), Promise.reject(errors);
+  }
+}
+async function runCall(state) {
+  const { signal } = state.context;
+  if (signal?.aborted) {
+    const errors = /* @__PURE__ */ new Map();
+    return onError(state.context, signal.reason ?? new DOMException("This operation was aborted", "AbortError"), "Request aborted", errors), Promise.reject(errors);
+  }
+  return makeCall(state);
+}
+async function makeCall(state, skipOptimistic) {
+  const { context, metadata } = state, { options, signal } = context, errors = /* @__PURE__ */ new Map();
+  let isOptimistic = !1;
+  try {
+    const prepared = await metadata?.prepare(!!skipOptimistic), subRequestIds = prepared?.ids ?? Object.keys(context.subRequestList);
+    if (isOptimistic = !!prepared?.optimistic, signal?.aborted)
+      return onError(context, signal.reason ?? new DOMException("This operation was aborted", "AbortError"), "Request aborted", errors), Promise.reject(errors);
+    if (isOptimistic) {
+      const running = runRequestHandlers(state, getScopedRequestHandlerIds(state));
+      if (running && await running, signal?.aborted)
+        return onError(context, signal.reason, "Request aborted", errors), Promise.reject(errors);
+      metadata?.askRows();
+    } else {
+      await loadMethodsMetadata(metadata, subRequestIds, signal);
+      const chainIds = getChainMiddlewareIds(context, errors);
+      if (errors.size) return Promise.reject(errors);
+      const beforeHandlers = new Set(Object.keys(context.subRequestList)), running = runRequestHandlers(state, chainIds);
+      if (running && await running, signal?.aborted)
+        return onError(context, signal.reason, "Request aborted", errors), Promise.reject(errors);
+      const addedIds = Object.keys(context.subRequestList).filter((id) => !beforeHandlers.has(id)), allIds = [...subRequestIds, ...addedIds];
+      if (await loadMethodsMetadata(metadata, allIds, signal), sanitizeSubRequests(allIds, context), validateSubRequests(allIds, context, errors), errors.forEach((error, id) => setResponseValue(context.response, id, error)), errors.size) return Promise.reject(errors);
+    }
+  } catch (error) {
+    return onError(context, error, "Error preparing request", errors), Promise.reject(errors);
+  }
+  let response;
+  try {
+    let serialized;
+    try {
+      serialized = serializeRequestBody(context, isOptimistic);
+    } catch (serializeError) {
+      if (isOptimistic) return makeCall(state, !0);
+      throw serializeError;
+    }
+    const headersFromParams = extractRequestHeaders(context), url = new URL(context.path, options.baseURL), fetchOptions = buildFetchOptions(url, serialized, headersFromParams, options, isOptimistic, isQueryRoute(context), signal);
+    state.sent = !0, response = await fetch(url, fetchOptions), context.httpResponse = response;
+  } catch (error) {
+    return onError(context, error, "Error executing request", errors), Promise.reject(errors);
+  }
+  try {
+    if (signal?.aborted)
+      return onError(context, signal.reason, "Request aborted", errors), Promise.reject(errors);
+    const deserialized = await deserializeResponseBody(response, options, metadata && ((body) => metadata.readRows(body)));
+    return handlePlatformError(context, deserialized, errors) || (noteServerApiVersion(options.baseURL, response.headers.get(BUILD_VERSION_HEADER)) && !metadata && reportApiVersionMismatch(options.baseURL), addParamlessMiddlewares(context), resolveSubRequests(context, deserialized, errors), errors.size) ? Promise.reject(errors) : deserialized;
+  } catch (error) {
+    return onError(context, error, "Error parsing response", errors), Promise.reject(errors);
+  }
+}
+async function loadMethodsMetadata(metadata, methodIds, signal) {
+  const missing = methodIds.filter((id) => !hasMethod(id));
+  if (missing.length) {
+    if (metadata) return metadata.fetchRows(missing, signal);
+    throw new RpcError({
+      type: "route-metadata-not-found",
+      publicMessage: `No metadata for ${missing.map((id) => `'${id}'`).join(", ")}: the build did not bundle it and the client does not fetch it. Call the route where the build can see it, or set up useFetchMetadata from '@mionjs/client/middlewares'.`
+    });
+  }
+}
+async function resendsForMetadata(state, metadata, errors, retriedBy) {
+  return !errors || !state.sent || retriedBy.has(metadata.id) ? !1 : await metadata.shouldResend(errors).catch(() => !1) && isRetrySafe(state, errors);
+}
+function handlePlatformError(context, deserialized, errors) {
+  if (!(MION_ROUTES.platformError in deserialized)) return !1;
+  const platformError = deserialized[MION_ROUTES.platformError];
+  return Object.values(context.subRequestList).forEach((methodMeta) => methodMeta.isResolved = !0), setThrownError(context, CLIENT_REQUEST_ERROR_ID, platformError, errors), !0;
+}
+function setThrownError(context, id, error, errors) {
+  errors.set(id, error), context.thrownErrorIds.add(id), addThrownError(context.response, error);
+}
+function addParamlessMiddlewares(context) {
+  for (const id of getChainMiddlewareIds(context)) {
+    const method = getMethod(id);
+    context.subRequestList[id] || !method || method.paramsCount || method.headersParam || !method.hasReturnData || addSubRequest(context, {
+      pointer: method.pointer,
+      id,
+      isResolved: !1,
+      params: []
+    });
+  }
+}
+function resolveSubRequests(context, deserialized, errors) {
+  const { response, subRequestList } = context;
+  for (const [id, value] of Object.entries(deserialized)) id !== MION_ROUTES.thrownErrors && setResponseValue(response, id, value);
+  for (const [id, thrownError] of Object.entries(deserialized[MION_ROUTES.thrownErrors] ?? {})) {
+    const subRequest = Object.hasOwn(subRequestList, id) ? subRequestList[id] : void 0;
+    subRequest && (subRequest.isResolved = !0, subRequest.error = thrownError), thrownError.type === "validation-error" && setResponseValue(response, id, thrownError) ? errors.set(id, thrownError) : setThrownError(context, id, thrownError, errors);
+  }
+  const checkAnswers = context.options.validateServerResponses, mayHaveStopped = checkAnswers && (errors.size > 0 || Object.values(deserialized).some((value) => isRpcError(value)));
+  Object.entries(subRequestList).forEach(([id, methodMeta]) => {
+    if (errors.has(id)) return;
+    const headersSubset = reconstructHeadersSubsetFromResponse(id, context.httpResponse.headers);
+    headersSubset && setResponseValue(response, id, headersSubset);
+    const resp = headersSubset ?? getResponseValue(response, id);
+    if (methodMeta.isResolved = !0, isRpcError(resp)) {
+      methodMeta.error = resp, errors.set(id, resp);
+      return;
+    }
+    const responseError = checkAnswers && (hasResponseValue(response, id) || !mayHaveStopped) ? getResponseError(id, resp) : void 0;
+    responseError ? (methodMeta.error = responseError, deleteResponseValue(response, id), setThrownError(context, id, responseError, errors)) : methodMeta.resolvedValue = resp;
+  }), Object.entries(deserialized).forEach(([id, value]) => {
+    id === MION_ROUTES.thrownErrors || Object.hasOwn(subRequestList, id) || isRpcError(value) && errors.set(id, value);
+  });
+}
+function onError(context, error, stageMessage, errors) {
+  const reason = context.signal?.aborted ? context.signal.reason : void 0;
+  if (reason instanceof DOMException) {
+    if (reason.name === "TimeoutError") {
+      setThrownError(context, CLIENT_REQUEST_ERROR_ID, new RpcError({
+        type: "request-timeout",
+        publicMessage: "Request timed out",
+        originalError: error instanceof Error ? error : void 0
+      }), errors);
+      return;
+    }
+    if (reason.name === "AbortError") {
+      setThrownError(context, CLIENT_REQUEST_ERROR_ID, new RpcError({
+        type: "request-aborted",
+        publicMessage: "Request was aborted",
+        originalError: error instanceof Error ? error : void 0
+      }), errors);
+      return;
+    }
+  }
+  if (isRpcError(error)) {
+    setThrownError(context, CLIENT_REQUEST_ERROR_ID, error, errors);
+    return;
+  }
+  const message = error?.message ? `${stageMessage}: ${error.message}` : `${stageMessage}: Unknown Error`;
+  setThrownError(context, CLIENT_REQUEST_ERROR_ID, new RpcError({
+    type: error?.name || "unknown-error",
+    publicMessage: message,
+    originalError: error instanceof Error ? error : void 0
+  }), errors);
+}
+function isQueryRoute(context) {
+  return context.batchSubRequests ? !1 : getMethod(context.requestId)?.options?.isMutation === !1;
+}
+function getChainMiddlewareIds(context, errors) {
+  const routeIds = new Set(getRouteIds(context)), chainIds = /* @__PURE__ */ new Set();
+  for (const routeId of routeIds) {
+    const methodMeta = getMethod(routeId);
+    if (!methodMeta) {
+      errors && setThrownError(context, routeId, new RpcError({
+        type: "route-metadata-not-found",
+        publicMessage: `Metadata for Route '${routeId}' not found.`
+      }), errors);
+      continue;
+    }
+    methodMeta.middlewareIds?.forEach((id) => !!id && !routeIds.has(id) && chainIds.add(id));
+  }
+  return [...chainIds];
+}
+function getScopedRequestHandlerIds(state) {
+  const routeIds = new Set(getRouteIds(state.context)), routePointers = getRoutePointers(state.context);
+  return state.handlersRegistry.getRequestHandlerIds().filter((id) => {
+    if (routeIds.has(id)) return !1;
+    const middlewarePointer = id.split(ROUTER_ITEM_SEPARATOR_CHAR);
+    return routePointers.some((routePointer) => isMiddlewareInScope(middlewarePointer, routePointer));
+  });
+}
+function runRequestHandlers(state, ids) {
+  const pending = [];
+  for (const id of ids) {
+    if (state.context.subRequestList[id] || state.askedRequestHandlers.has(id)) continue;
+    const entry = state.handlersRegistry.getRequestHandler(id);
+    if (!entry) continue;
+    state.askedRequestHandlers.add(id);
+    const running = runRequestHandler(state.context, id, entry);
+    running && pending.push(running);
+  }
+  if (pending.length) return Promise.all(pending).then(() => {
+  });
+}
+function runRequestHandler(context, id, entry) {
+  let subRequest, isOpen = !0;
+  const call = (...params) => {
+    isOpen && (subRequest = entry.createSubRequest(params));
+  }, finish = () => {
+    isOpen = !1, subRequest && addSubRequest(context, subRequest);
+  }, fail = (error) => {
+    throw isOpen = !1, requestHandlerError(id, error);
+  };
+  let returned;
+  try {
+    returned = entry.handler(call, context);
+  } catch (error) {
+    return fail(error);
+  }
+  return isPromiseLike(returned) ? Promise.resolve(returned).then(finish, fail) : finish();
+}
+function isPromiseLike(value) {
+  return !!value && typeof value.then == "function";
+}
+function requestHandlerError(id, error) {
+  return isRpcError(error) ? error : new RpcError({
+    type: "middleware-on-request-failed",
+    publicMessage: `onRequest for middleware '${id}' failed: ${error instanceof Error ? error.message : String(error)}`,
+    originalError: error instanceof Error ? error : void 0
+  });
+}
+function isMiddlewareInScope(middlewarePointer, routePointer) {
+  const groupDepth = middlewarePointer.length - 1;
+  if (groupDepth >= routePointer.length) return !1;
+  for (let i = 0; i < groupDepth; i++) if (middlewarePointer[i] !== routePointer[i]) return !1;
+  return !0;
+}
+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 <= 4096)
+      return url.searchParams.set("data", encoded), {
+        ...options.fetchOptions,
+        method: "GET",
+        headers: {
+          ...headersToRecord(options.fetchOptions.headers),
+          ...headersFromParams
+        },
+        body: void 0,
+        signal
+      };
+  }
+  return {
+    ...options.fetchOptions,
+    method: "POST",
+    headers: {
+      ...headersToRecord(options.fetchOptions.headers),
+      ...headersFromParams,
+      "Content-Type": serialized.contentType
+    },
+    body: serialized.body,
+    signal
+  };
+}
+function getMiddlewareSubRequests(context) {
+  const routeIds = /* @__PURE__ */ new Set();
+  return context.route && routeIds.add(context.route.id), context.batchSubRequests && context.batchSubRequests.forEach((sr) => routeIds.add(sr.id)), Object.entries(context.subRequestList).filter(([id]) => !routeIds.has(id)).map(([, subRequest]) => subRequest);
+}
+async function runMiddlewareResponses(state, middlewareSubRequests, errors, retriedBy) {
+  const { context, handlersRegistry } = state, retryIds = [], pending = [];
+  let retrySafe;
+  const requestRetry = (id) => retriedBy.has(id) || (retrySafe ??= isRetrySafe(state, errors), !retrySafe) ? !1 : (retryIds.includes(id) || retryIds.push(id), !0), baseContext = {
+    route: context.route,
+    batchSubRequests: context.batchSubRequests,
+    subRequestList: context.subRequestList,
+    options: context.options,
+    signal: context.signal,
+    retry: () => !1
+  };
+  for (const middleware of middlewareSubRequests) {
+    const id = middleware.id, middlewareError = errors?.get(id), isErrorHandler = !!middlewareError;
+    if (isErrorHandler && context.thrownErrorIds.has(id) || !isErrorHandler && middleware.resolvedValue === void 0) continue;
+    const handlerName = isErrorHandler ? "onError" : "onResponse", handlers = isErrorHandler ? handlersRegistry.getErrorHandlers(id, middlewareError.type) : handlersRegistry.getResponseHandlers(id);
+    for (const handler of handlers) {
+      let isOpen = !0;
+      const middlewareContext = {
+        ...baseContext,
+        retry: () => isOpen && requestRetry(id)
+      }, fail = (error) => {
+        isOpen = !1, errors ??= /* @__PURE__ */ new Map(), setThrownError(context, CLIENT_REQUEST_ERROR_ID, middlewareHandlerError(handlerName, id, error), errors);
+      };
+      let returned;
+      try {
+        returned = handler(isErrorHandler ? middlewareError : middleware.resolvedValue, middlewareContext);
+      } catch (error) {
+        fail(error);
+        continue;
+      }
+      if (!isPromiseLike(returned)) {
+        isOpen = !1;
+        continue;
+      }
+      pending.push(Promise.resolve(returned).then(() => {
+        isOpen = !1;
+      }, (error) => fail(error)));
+    }
+  }
+  return pending.length && await Promise.all(pending), errors?.has("mion-client-request") && retryIds.length && (retryIds.length = 0), {
+    errors,
+    retryIds
+  };
+}
+function isRetrySafe(state, errors) {
+  return state.sent ? getRouteIds(state.context).every((id) => getMethod(id)?.options?.isMutation === !1 || !routeSucceeded(state.context, id, errors)) : !0;
+}
+function routeSucceeded(context, routeId, errors) {
+  const errorType = errors?.get(routeId)?.type;
+  return errorType === "response-validation-error" || errorType === "headers-validation-error" ? !0 : errors?.has(routeId) ? !1 : context.subRequestList[routeId]?.resolvedValue !== void 0 ? !0 : !errors?.size;
+}
+function resetForMiddlewareRetry(state) {
+  const { context } = state, routeIds = new Set(getRouteIds(context));
+  for (const id of Object.keys(context.subRequestList)) routeIds.has(id) || delete context.subRequestList[id];
+  state.askedRequestHandlers.clear(), resetAttempt(state);
+}
+function resetAttempt(state) {
+  const { context } = state;
+  Object.values(context.subRequestList).forEach((subRequest) => {
+    subRequest.isResolved = !1, subRequest.resolvedValue = void 0, subRequest.error = void 0;
+  }), context.thrownErrorIds.clear(), context.httpResponse = void 0, context.response = {}, state.sent = !1;
+}
+function middlewareHandlerError(handlerName, id, error) {
+  if (isRpcError(error)) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new RpcError({
+    type: handlerName === "onError" ? "middleware-on-error-failed" : "middleware-on-response-failed",
+    publicMessage: `${handlerName} for middleware '${id}' failed: ${message}`,
+    originalError: error instanceof Error ? error : void 0
+  });
+}
+function buildResult(state, errors) {
+  const { route: routeSubRequest, batchSubRequests, thrownErrorIds, response } = state.context, declaredErrorFor = (id) => {
+    const error = errors?.get(id);
+    return error && !thrownErrorIds.has(id) ? error : void 0;
+  };
+  return [
+    takeBundledApiError(),
+    takeApiVersionError(),
+    state.metadata?.takeError()
+  ].forEach((error) => error && addThrownError(response, error)), batchSubRequests ? batchSubRequests.map((batchRoute) => [
+    batchRoute.resolvedValue,
+    declaredErrorFor(batchRoute.id),
+    response
+  ]) : [
+    routeSubRequest?.resolvedValue,
+    routeSubRequest && declaredErrorFor(routeSubRequest.id),
+    response
+  ];
+}
+export {
+  dispatchCall,
+  dispatchTypeErrors,
+  isMiddlewareInScope,
+  routeSucceeded
+};
+
+//# sourceMappingURL=dispatch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.js","names":[],"sources":["../../../src/dispatch.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {ResponseBody} from '@mionjs/router';\nimport type {\n  BatchResult,\n  ClientCallContext,\n  ClientOptions,\n  MiddlewareContext,\n  MiddlewareSubRequest,\n  RequestErrors,\n  Result,\n  RouteSubRequest,\n  SubRequest,\n} from './types.ts';\nimport type {HandlersRegistry, RequestHandlerEntry} from './lib/handlersRegistry.ts';\nimport type {RunTypeError} from '@mionjs/core';\nimport {RpcError, isRpcError, MION_ROUTES, toBase64Url, BUILD_VERSION_HEADER, ROUTER_ITEM_SEPARATOR_CHAR} from '@mionjs/core';\nimport {addSubRequest, createCallContext, getRouteIds, getRoutePointers} from './callContext.ts';\nimport {noteServerApiVersion, reportApiVersionMismatch, takeApiVersionError} from './lib/apiBuildVersion.ts';\nimport {getMethod, hasMethod} from './lib/methods.ts';\nimport {getMetadataFetcher, type MetadataCall} from './lib/metadataFetcher.ts';\nimport {getResponseError, validateSubRequests} from './lib/validation.ts';\nimport {sanitizeSubRequests} from './lib/sanitize.ts';\nimport {serializeRequestBody, deserializeResponseBody} from './lib/serializer.ts';\nimport {MAX_GET_URL_LENGTH, CLIENT_REQUEST_ERROR_ID} from './constants.ts';\nimport {extractRequestHeaders, headersToRecord, reconstructHeadersSubsetFromResponse} from './lib/headers.ts';\nimport {addThrownError, deleteResponseValue, getResponseValue, hasResponseValue, setResponseValue} from './lib/clientResponse.ts';\nimport {takeBundledApiError} from '#bundled-api';\n\n/** One call's retry state: it belongs to the dispatch, never to the context onRequest hooks see */\ninterface DispatchState {\n  readonly context: ClientCallContext;\n  readonly handlersRegistry: HandlersRegistry;\n  /** set only when the client set up `useFetchMetadata` */\n  readonly metadata: MetadataCall | undefined;\n  /** middlewares whose onRequest already ran, so a retry never asks twice */\n  readonly askedRequestHandlers: Set<string>;\n  /** the current attempt reached fetch, so the server may have run its routes */\n  sent: boolean;\n}\n\n// ############# DISPATCH #############\n\nexport async function dispatchCall(\n  context: ClientCallContext,\n  handlersRegistry: HandlersRegistry\n): Promise<BatchResult<any> | Result<any, any>> {\n  const metadata = getMetadataFetcher(handlersRegistry)?.startCall(context);\n  const state: DispatchState = {\n    context,\n    handlersRegistry,\n    metadata,\n    askedRequestHandlers: new Set<string>(),\n    sent: false,\n  };\n  // a middleware whose hook asked for a retry never gets another one in this call\n  const retriedBy = new Set<string>();\n  for (;;) {\n    let errors: RequestErrors | undefined;\n    try {\n      await runCall(state);\n    } catch (requestErrors: any) {\n      errors = requestErrors;\n    }\n    // before any hook sees the failed attempt: a resend with fresh rows is the metadata's own, not a hook's\n    if (metadata && (await resendsForMetadata(state, metadata, errors, retriedBy))) {\n      retriedBy.add(metadata.id);\n      // keeps what onRequest hooks sent: the params did not change, only how they are written\n      resetAttempt(state);\n      continue;\n    }\n    const hooks = await runMiddlewareResponses(state, getMiddlewareSubRequests(context), errors, retriedBy);\n    if (!hooks.retryIds.length) return buildResult(state, hooks.errors);\n    hooks.retryIds.forEach((id) => retriedBy.add(id));\n    resetForMiddlewareRetry(state);\n  }\n}\n\n/** Validates params locally without sending anything */\nexport async function dispatchTypeErrors(\n  options: ClientOptions,\n  subRequests: SubRequest<any>[],\n  handlersRegistry?: HandlersRegistry\n): Promise<RunTypeError[]> {\n  const context = createCallContext(options);\n  subRequests.forEach((subRequest) => addSubRequest(context, subRequest));\n  const errors: RequestErrors = new Map();\n  try {\n    const subRequestIds = Object.keys(context.subRequestList);\n    await loadMethodsMetadata(getMetadataFetcher(handlersRegistry)?.startCall(context), subRequestIds);\n    sanitizeSubRequests(subRequestIds, context);\n    validateSubRequests(subRequestIds, context, errors, false);\n    return Object.values(context.subRequestList)\n      .map((subRequest) => subRequest.error?.errorData?.typeErrors || [])\n      .flat();\n  } catch (error: any) {\n    onError(context, error, 'Error preparing request', errors);\n    return Promise.reject(errors);\n  }\n}\n\nasync function runCall(state: DispatchState): Promise<ResponseBody> {\n  const {signal} = state.context;\n  if (signal?.aborted) {\n    const errors: RequestErrors = new Map();\n    onError(\n      state.context,\n      signal.reason ?? new DOMException('This operation was aborted', 'AbortError'),\n      'Request aborted',\n      errors\n    );\n    return Promise.reject(errors);\n  }\n  return makeCall(state);\n}\n\nasync function makeCall(state: DispatchState, skipOptimistic?: boolean): Promise<ResponseBody> {\n  const {context, metadata} = state;\n  const {options, signal} = context;\n  const errors: RequestErrors = new Map();\n  let isOptimistic = false;\n\n  try {\n    const prepared = await metadata?.prepare(!!skipOptimistic);\n    const subRequestIds = prepared?.ids ?? Object.keys(context.subRequestList);\n    isOptimistic = !!prepared?.optimistic;\n    if (signal?.aborted) {\n      onError(context, signal.reason ?? new DOMException('This operation was aborted', 'AbortError'), 'Request aborted', errors);\n      return Promise.reject(errors);\n    }\n    if (isOptimistic) {\n      // No chain before metadata, so scope picks the middlewares; a missed one costs the resend, an extra is ignored.\n      const running = runRequestHandlers(state, getScopedRequestHandlerIds(state));\n      if (running) await running;\n      if (signal?.aborted) {\n        onError(context, signal.reason, 'Request aborted', errors);\n        return Promise.reject(errors);\n      }\n      metadata?.askRows();\n    } else {\n      await loadMethodsMetadata(metadata, subRequestIds, signal);\n      const chainIds = getChainMiddlewareIds(context, errors);\n      if (errors.size) return Promise.reject(errors);\n      const beforeHandlers = new Set(Object.keys(context.subRequestList));\n      const running = runRequestHandlers(state, chainIds);\n      if (running) await running;\n      if (signal?.aborted) {\n        onError(context, signal.reason, 'Request aborted', errors);\n        return Promise.reject(errors);\n      }\n      const addedIds = Object.keys(context.subRequestList).filter((id) => !beforeHandlers.has(id));\n      const allIds = [...subRequestIds, ...addedIds];\n      await loadMethodsMetadata(metadata, allIds, signal);\n      sanitizeSubRequests(allIds, context);\n      validateSubRequests(allIds, context, errors);\n      // a validation error is typed, so it sits at its own path like a returned one\n      errors.forEach((error, id) => setResponseValue(context.response, id, error));\n      if (errors.size) return Promise.reject(errors);\n    }\n  } catch (error: any) {\n    onError(context, error, 'Error preparing request', errors);\n    return Promise.reject(errors);\n  }\n\n  let response: Response;\n  try {\n    let serialized: ReturnType<typeof serializeRequestBody>;\n    try {\n      serialized = serializeRequestBody(context, isOptimistic);\n    } catch (serializeError) {\n      // plain JSON.stringify failed and nothing was sent: fetch the rows first, then send the real encoders\n      if (isOptimistic) return makeCall(state, true);\n      throw serializeError;\n    }\n\n    const headersFromParams = extractRequestHeaders(context);\n    const url = new URL(context.path, options.baseURL);\n    const fetchOptions = buildFetchOptions(\n      url,\n      serialized,\n      headersFromParams,\n      options,\n      isOptimistic,\n      isQueryRoute(context),\n      signal\n    );\n    state.sent = true;\n    response = await fetch(url, fetchOptions);\n    context.httpResponse = response;\n  } catch (error: any) {\n    onError(context, error, 'Error executing request', errors);\n    return Promise.reject(errors);\n  }\n\n  try {\n    // A body read after an in-flight abort may be truncated, so report the abort instead.\n    if (signal?.aborted) {\n      onError(context, signal.reason, 'Request aborted', errors);\n      return Promise.reject(errors);\n    }\n    const deserialized = await deserializeResponseBody(response, options, metadata && ((body) => metadata.readRows(body)));\n    if (handlePlatformError(context, deserialized, errors)) return Promise.reject(errors);\n    // without the metadata middleware the client cannot check routes one by one, so the whole API is reported\n    if (noteServerApiVersion(options.baseURL, response.headers.get(BUILD_VERSION_HEADER)) && !metadata)\n      reportApiVersionMismatch(options.baseURL);\n    addParamlessMiddlewares(context);\n    resolveSubRequests(context, deserialized, errors);\n    if (errors.size) return Promise.reject(errors);\n    return deserialized;\n  } catch (error) {\n    onError(context, error, 'Error parsing response', errors);\n    return Promise.reject(errors);\n  }\n}\n\n/** Rows missing for any id: fetched when the client set up metadata fetching, a clear error otherwise. */\nasync function loadMethodsMetadata(metadata: MetadataCall | undefined, methodIds: string[], signal?: AbortSignal): Promise<void> {\n  const missing = methodIds.filter((id) => !hasMethod(id));\n  if (!missing.length) return;\n  if (metadata) return metadata.fetchRows(missing, signal);\n  throw new RpcError({\n    type: 'route-metadata-not-found',\n    publicMessage:\n      `No metadata for ${missing.map((id) => `'${id}'`).join(', ')}: the build did not bundle it and the client does not fetch it. ` +\n      `Call the route where the build can see it, or set up useFetchMetadata from '@mionjs/client/middlewares'.`,\n  });\n}\n\n/** A metadata resend fixes an attempt that failed on the wire, once per call, never re-running a success. */\nasync function resendsForMetadata(\n  state: DispatchState,\n  metadata: MetadataCall,\n  errors: RequestErrors | undefined,\n  retriedBy: ReadonlySet<string>\n): Promise<boolean> {\n  if (!errors || !state.sent || retriedBy.has(metadata.id)) return false;\n  // a storage engine the app supplied can throw, and a call never rejects\n  const resend = await metadata.shouldResend(errors).catch(() => false);\n  return resend && isRetrySafe(state, errors);\n}\n\n/** A platform error is request-scoped: one entry, not one per subrequest */\nfunction handlePlatformError(context: ClientCallContext, deserialized: ResponseBody, errors: RequestErrors): boolean {\n  if (!(MION_ROUTES.platformError in deserialized)) return false;\n  const platformError = deserialized[MION_ROUTES.platformError];\n  Object.values(context.subRequestList).forEach((methodMeta) => (methodMeta.isResolved = true));\n  setThrownError(context, CLIENT_REQUEST_ERROR_ID, platformError as RpcError<string>, errors);\n  return true;\n}\n\n/** An untyped error: only `@thrownErrors`, never a typed slot or a listener */\nfunction setThrownError(context: ClientCallContext, id: string, error: RpcError<string>, errors: RequestErrors): void {\n  errors.set(id, error);\n  context.thrownErrorIds.add(id);\n  addThrownError(context.response, error);\n}\n\n/** A middleware with no params gets no onRequest call, yet its answer and declared errors are the caller's */\nfunction addParamlessMiddlewares(context: ClientCallContext): void {\n  for (const id of getChainMiddlewareIds(context)) {\n    const method = getMethod(id);\n    if (context.subRequestList[id] || !method || method.paramsCount || method.headersParam || !method.hasReturnData) continue;\n    addSubRequest(context, {pointer: method.pointer, id, isResolved: false, params: []});\n  }\n}\n\n/** A thrown validation error is typed, so it moves to its path */\nfunction resolveSubRequests(context: ClientCallContext, deserialized: ResponseBody, errors: RequestErrors): void {\n  const {response, subRequestList} = context;\n  for (const [id, value] of Object.entries(deserialized)) {\n    if (id !== MION_ROUTES.thrownErrors) setResponseValue(response, id, value);\n  }\n  for (const [id, thrownError] of Object.entries(deserialized[MION_ROUTES.thrownErrors] ?? {})) {\n    // a response key is untrusted: only an own entry is one of this request's subrequests\n    const subRequest = Object.hasOwn(subRequestList, id) ? subRequestList[id] : undefined;\n    if (subRequest) {\n      subRequest.isResolved = true;\n      subRequest.error = thrownError;\n    }\n    if (thrownError.type === 'validation-error' && setResponseValue(response, id, thrownError)) errors.set(id, thrownError);\n    else setThrownError(context, id, thrownError, errors);\n  }\n\n  const checkAnswers = context.options.validateServerResponses;\n  // the halting brand never travels, so after any error an absent member may never have run\n  const mayHaveStopped = checkAnswers && (errors.size > 0 || Object.values(deserialized).some((value) => isRpcError(value)));\n  Object.entries(subRequestList).forEach(([id, methodMeta]) => {\n    if (errors.has(id)) return;\n    // a headers answer proves the member ran, so it is checked like a body one\n    const headersSubset = reconstructHeadersSubsetFromResponse(id, (context.httpResponse as Response).headers);\n    if (headersSubset) setResponseValue(response, id, headersSubset);\n    const resp = headersSubset ?? getResponseValue(response, id);\n    methodMeta.isResolved = true;\n    if (isRpcError(resp)) {\n      methodMeta.error = resp;\n      errors.set(id, resp);\n      return;\n    }\n    const responseError =\n      checkAnswers && (hasResponseValue(response, id) || !mayHaveStopped) ? getResponseError(id, resp) : undefined;\n    if (responseError) {\n      methodMeta.error = responseError;\n      deleteResponseValue(response, id);\n      setThrownError(context, id, responseError, errors);\n    } else {\n      methodMeta.resolvedValue = resp;\n    }\n  });\n\n  // an error for an id this request never asked for stays at its path; the map only feeds the retry rules\n  Object.entries(deserialized).forEach(([id, value]) => {\n    if (id === MION_ROUTES.thrownErrors || Object.hasOwn(subRequestList, id)) return;\n    if (isRpcError(value)) errors.set(id, value);\n  });\n}\n\nfunction onError(context: ClientCallContext, error: any, stageMessage: string, errors: RequestErrors): void {\n  // Check signal.reason before the isRpcError return: a later stage may have wrapped the abort as an RpcError.\n  const reason = context.signal?.aborted ? context.signal.reason : undefined;\n  if (reason instanceof DOMException) {\n    if (reason.name === 'TimeoutError') {\n      setThrownError(\n        context,\n        CLIENT_REQUEST_ERROR_ID,\n        new RpcError({\n          type: 'request-timeout',\n          publicMessage: 'Request timed out',\n          originalError: error instanceof Error ? error : undefined,\n        }),\n        errors\n      );\n      return;\n    }\n    if (reason.name === 'AbortError') {\n      setThrownError(\n        context,\n        CLIENT_REQUEST_ERROR_ID,\n        new RpcError({\n          type: 'request-aborted',\n          publicMessage: 'Request was aborted',\n          originalError: error instanceof Error ? error : undefined,\n        }),\n        errors\n      );\n      return;\n    }\n  }\n  if (isRpcError(error)) {\n    setThrownError(context, CLIENT_REQUEST_ERROR_ID, error, errors);\n    return;\n  }\n  const message = error?.message ? `${stageMessage}: ${error.message}` : `${stageMessage}: Unknown Error`;\n  setThrownError(\n    context,\n    CLIENT_REQUEST_ERROR_ID,\n    new RpcError({\n      type: error?.name || 'unknown-error',\n      publicMessage: message,\n      originalError: error instanceof Error ? error : undefined,\n    }),\n    errors\n  );\n}\n\nfunction isQueryRoute(context: ClientCallContext): boolean {\n  if (context.batchSubRequests) return false;\n  const meta = getMethod(context.requestId);\n  // strict false value required for queries\n  return meta?.options?.isMutation === false;\n}\n\n// ############# ON REQUEST HOOKS #############\n\n/** The middlewares the cached metadata lists in the route's chain (standard flow) */\nfunction getChainMiddlewareIds(context: ClientCallContext, errors?: RequestErrors): string[] {\n  const routeIds = new Set(getRouteIds(context));\n  const chainIds = new Set<string>();\n  for (const routeId of routeIds) {\n    const methodMeta = getMethod(routeId);\n    if (!methodMeta) {\n      // without errors (after the answer) a missing row only means no chain to read\n      if (errors) {\n        setThrownError(\n          context,\n          routeId,\n          new RpcError({\n            type: 'route-metadata-not-found',\n            publicMessage: `Metadata for Route '${routeId}' not found.`,\n          }),\n          errors\n        );\n      }\n      continue;\n    }\n    methodMeta.middlewareIds?.forEach((id) => !!id && !routeIds.has(id) && chainIds.add(id));\n  }\n  return [...chainIds];\n}\n\n/** Optimistic flow: the chain is not cached yet, but a middleware's group is part of its pointer */\nfunction getScopedRequestHandlerIds(state: DispatchState): string[] {\n  const routeIds = new Set(getRouteIds(state.context));\n  const routePointers = getRoutePointers(state.context);\n  return state.handlersRegistry.getRequestHandlerIds().filter((id) => {\n    if (routeIds.has(id)) return false;\n    const middlewarePointer = id.split(ROUTER_ITEM_SEPARATOR_CHAR);\n    return routePointers.some((routePointer) => isMiddlewareInScope(middlewarePointer, routePointer));\n  });\n}\n\n/** Runs each middleware's onRequest once per call, in chain order; awaits only when one returns a promise */\nfunction runRequestHandlers(state: DispatchState, ids: string[]): Promise<void> | void {\n  const pending: Promise<void>[] = [];\n  for (const id of ids) {\n    if (state.context.subRequestList[id] || state.askedRequestHandlers.has(id)) continue;\n    const entry = state.handlersRegistry.getRequestHandler(id);\n    if (!entry) continue;\n    state.askedRequestHandlers.add(id);\n    const running = runRequestHandler(state.context, id, entry);\n    if (running) pending.push(running);\n  }\n  if (pending.length) return Promise.all(pending).then(() => undefined);\n}\n\nfunction runRequestHandler(context: ClientCallContext, id: string, entry: RequestHandlerEntry): Promise<void> | void {\n  let subRequest: SubRequest<any> | undefined;\n  let isOpen = true;\n  // the last call wins; a call after the handler finished belongs to no request\n  const call = (...params: any[]) => {\n    if (isOpen) subRequest = entry.createSubRequest(params);\n  };\n  const finish = () => {\n    isOpen = false;\n    if (subRequest) addSubRequest(context, subRequest);\n  };\n  const fail = (error: unknown): never => {\n    isOpen = false;\n    throw requestHandlerError(id, error);\n  };\n  let returned: void | Promise<void>;\n  try {\n    returned = entry.handler(call, context);\n  } catch (error) {\n    return fail(error);\n  }\n  if (!isPromiseLike(returned)) return finish();\n  return Promise.resolve(returned).then(finish, fail);\n}\n\nfunction isPromiseLike(value: unknown): value is PromiseLike<unknown> {\n  return !!value && typeof (value as PromiseLike<unknown>).then === 'function';\n}\n\n/** The result lands in @thrownErrors */\nfunction requestHandlerError(id: string, error: unknown): RpcError<string> {\n  if (isRpcError(error)) return error;\n  const message = error instanceof Error ? error.message : String(error);\n  return new RpcError({\n    type: 'middleware-on-request-failed',\n    publicMessage: `onRequest for middleware '${id}' failed: ${message}`,\n    originalError: error instanceof Error ? error : undefined,\n  });\n}\n\n/** A middleware's scope is its pointer minus the last segment; a route is in scope when its pointer starts with it */\nexport function isMiddlewareInScope(middlewarePointer: string[], routePointer: string[]): boolean {\n  const groupDepth = middlewarePointer.length - 1;\n  if (groupDepth >= routePointer.length) return false;\n  for (let i = 0; i < groupDepth; i++) if (middlewarePointer[i] !== routePointer[i]) return false;\n  return true;\n}\n\n// ############# FETCH #############\n\n/** GET only for a JSON query whose URL fits MAX_GET_URL_LENGTH; mutations, optimistic calls and batches POST */\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: {...headersToRecord(options.fetchOptions.headers), ...headersFromParams},\n        body: undefined,\n        signal,\n      };\n    }\n  }\n\n  return {\n    ...options.fetchOptions,\n    method: 'POST',\n    headers: {...headersToRecord(options.fetchOptions.headers), ...headersFromParams, 'Content-Type': serialized.contentType},\n    body: serialized.body as BodyInit,\n    signal,\n  };\n}\n\n// ############# RESULT #############\n\nfunction getMiddlewareSubRequests(context: ClientCallContext): MiddlewareSubRequest<any>[] {\n  const routeIds = new Set<string>();\n  if (context.route) routeIds.add(context.route.id);\n  if (context.batchSubRequests) context.batchSubRequests.forEach((sr) => routeIds.add(sr.id));\n  return Object.entries(context.subRequestList)\n    .filter(([id]) => !routeIds.has(id))\n    .map(([, subRequest]) => subRequest as MiddlewareSubRequest<any>);\n}\n\ninterface MiddlewareResponsesOutcome {\n  errors: RequestErrors | undefined;\n  /** middlewares whose hook asked for a retry that was allowed */\n  retryIds: string[];\n}\n\n/** onError fires only for declared (returned) errors; thrown ones reach @thrownErrors only */\nasync function runMiddlewareResponses(\n  state: DispatchState,\n  middlewareSubRequests: MiddlewareSubRequest<any>[],\n  errors: RequestErrors | undefined,\n  retriedBy: ReadonlySet<string>\n): Promise<MiddlewareResponsesOutcome> {\n  const {context, handlersRegistry} = state;\n  const retryIds: string[] = [];\n  const pending: Promise<void>[] = [];\n  let retrySafe: boolean | undefined;\n  /** Records the retry and says whether it will happen; the rule is worked out once per attempt */\n  const requestRetry = (id: string): boolean => {\n    if (retriedBy.has(id)) return false;\n    retrySafe ??= isRetrySafe(state, errors);\n    if (!retrySafe) return false;\n    if (!retryIds.includes(id)) retryIds.push(id);\n    return true;\n  };\n  // every middleware gets this context, with its own retry\n  const baseContext: MiddlewareContext = {\n    route: context.route,\n    batchSubRequests: context.batchSubRequests,\n    subRequestList: context.subRequestList,\n    options: context.options,\n    signal: context.signal,\n    retry: () => false,\n  };\n  for (const middleware of middlewareSubRequests) {\n    const id = middleware.id;\n    const middlewareError = errors?.get(id);\n    const isErrorHandler = !!middlewareError;\n    if (isErrorHandler && context.thrownErrorIds.has(id)) continue;\n    if (!isErrorHandler && middleware.resolvedValue === undefined) continue;\n    const handlerName = isErrorHandler ? 'onError' : 'onResponse';\n    const handlers = isErrorHandler\n      ? handlersRegistry.getErrorHandlers(id, middlewareError.type)\n      : handlersRegistry.getResponseHandlers(id);\n    // a failing handler does not stop the rest\n    for (const handler of handlers) {\n      // a retry asked after the handler finished belongs to no attempt\n      let isOpen = true;\n      const middlewareContext: MiddlewareContext = {...baseContext, retry: () => isOpen && requestRetry(id)};\n      const fail = (error: unknown) => {\n        isOpen = false;\n        errors ??= new Map();\n        setThrownError(context, CLIENT_REQUEST_ERROR_ID, middlewareHandlerError(handlerName, id, error), errors);\n      };\n      let returned: unknown;\n      try {\n        returned = isErrorHandler\n          ? handler(middlewareError, middlewareContext)\n          : handler(middleware.resolvedValue, middlewareContext);\n      } catch (error) {\n        fail(error);\n        continue;\n      }\n      if (!isPromiseLike(returned)) {\n        isOpen = false;\n        continue;\n      }\n      pending.push(\n        Promise.resolve(returned).then(\n          () => {\n            isOpen = false;\n          },\n          (error) => fail(error)\n        )\n      );\n    }\n  }\n  if (pending.length) await Promise.all(pending);\n  // a failed handler ends the call: its error is the answer, not a resend\n  if (errors?.has(CLIENT_REQUEST_ERROR_ID) && retryIds.length) retryIds.length = 0;\n  return {errors, retryIds};\n}\n\n/** Safe when nothing was sent, or when every route is a query or did not succeed */\nfunction isRetrySafe(state: DispatchState, errors: RequestErrors | undefined): boolean {\n  if (!state.sent) return true;\n  return getRouteIds(state.context).every(\n    (id) => getMethod(id)?.options?.isMutation === false || !routeSucceeded(state.context, id, errors)\n  );\n}\n\n/** A void route answers nothing, so any error in the response counts it as failed */\nexport function routeSucceeded(context: ClientCallContext, routeId: string, errors: RequestErrors | undefined): boolean {\n  const errorType = errors?.get(routeId)?.type;\n  // the handler ran: its answer was refused, or the headers it built failed their check\n  if (errorType === 'response-validation-error' || errorType === 'headers-validation-error') return true;\n  if (errors?.has(routeId)) return false;\n  if (context.subRequestList[routeId]?.resolvedValue !== undefined) return true;\n  return !errors?.size;\n}\n\n/** Hook-driven retries ask every onRequest again: a hook usually retries because what it sends changed */\nfunction resetForMiddlewareRetry(state: DispatchState): void {\n  const {context} = state;\n  const routeIds = new Set(getRouteIds(context));\n  for (const id of Object.keys(context.subRequestList)) {\n    if (!routeIds.has(id)) delete context.subRequestList[id];\n  }\n  state.askedRequestHandlers.clear();\n  resetAttempt(state);\n}\n\nfunction resetAttempt(state: DispatchState): void {\n  const {context} = state;\n  Object.values(context.subRequestList).forEach((subRequest) => {\n    subRequest.isResolved = false;\n    subRequest.resolvedValue = undefined;\n    subRequest.error = undefined;\n  });\n  context.thrownErrorIds.clear();\n  context.httpResponse = undefined;\n  context.response = {};\n  state.sent = false;\n}\n\n/** The result lands in @thrownErrors */\nfunction middlewareHandlerError(handlerName: 'onResponse' | 'onError', id: string, error: unknown): RpcError<string> {\n  if (isRpcError(error)) return error;\n  const message = error instanceof Error ? error.message : String(error);\n  return new RpcError({\n    type: handlerName === 'onError' ? 'middleware-on-error-failed' : 'middleware-on-response-failed',\n    publicMessage: `${handlerName} for middleware '${id}' failed: ${message}`,\n    originalError: error instanceof Error ? error : undefined,\n  });\n}\n\n/** Slot rules are pinned in test/errorDispatch.spec.ts */\nfunction buildResult(\n  state: DispatchState,\n  errors: RequestErrors | undefined\n): BatchResult<RouteSubRequest<any>[]> | Result<any, any> {\n  const {route: routeSubRequest, batchSubRequests, thrownErrorIds, response} = state.context;\n  const declaredErrorFor = (id: string): RpcError<string> | undefined => {\n    const error = errors?.get(id);\n    return error && !thrownErrorIds.has(id) ? error : undefined;\n  };\n\n  // framework errors the router never saw: the call ran, so they are reported here rather than rejecting\n  const frameworkErrors = [takeBundledApiError(), takeApiVersionError(), state.metadata?.takeError()];\n  frameworkErrors.forEach((error) => error && addThrownError(response, error));\n\n  // every batch entry is a call() Result sharing the same response\n  if (batchSubRequests)\n    return batchSubRequests.map(\n      (batchRoute): Result<any, any> => [batchRoute.resolvedValue, declaredErrorFor(batchRoute.id), response]\n    );\n  return [routeSubRequest?.resolvedValue, routeSubRequest && declaredErrorFor(routeSubRequest.id), response];\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import { RpcError } from '@mionjs/core';
+export declare function setApiBuildVersion(version: string | undefined): void;
+export declare function getApiBuildVersion(): string | undefined;
+export declare function noteServerApiVersion(baseURL: string, serverVersion: string | undefined | null): boolean;
+export declare function hasApiVersionMismatch(baseURL: string): boolean;
+export declare function reportApiVersionMismatch(baseURL: string): void;
+export declare function stashApiVersionError(error: RpcError<'api-version-mismatch'>): void;
+export declare function takeApiVersionError(): RpcError<'api-version-mismatch'> | undefined;
+export declare function resetApiBuildVersion(): void;
+//# sourceMappingURL=apiBuildVersion.d.ts.map

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

@@ -0,0 +1,43 @@
+import { RpcError } from "@mionjs/core";
+var apiBuildVersion, mismatchedServers = /* @__PURE__ */ new Set(), mismatchError;
+function setApiBuildVersion(version) {
+  apiBuildVersion = version || void 0;
+}
+function getApiBuildVersion() {
+  return apiBuildVersion;
+}
+function noteServerApiVersion(baseURL, serverVersion) {
+  return !serverVersion || !apiBuildVersion || serverVersion === apiBuildVersion ? !1 : (mismatchedServers.add(baseURL), !0);
+}
+function hasApiVersionMismatch(baseURL) {
+  return mismatchedServers.has(baseURL);
+}
+var reportedServers = /* @__PURE__ */ new Set();
+function reportApiVersionMismatch(baseURL) {
+  reportedServers.has(baseURL) || (reportedServers.add(baseURL), mismatchError = new RpcError({
+    type: "api-version-mismatch",
+    publicMessage: `The server at ${baseURL || "this origin"} runs a different build of the API than this client was built against. Reload the app or rebuild the client against the current API.`
+  }));
+}
+function stashApiVersionError(error) {
+  mismatchError = error;
+}
+function takeApiVersionError() {
+  const error = mismatchError;
+  return mismatchError = void 0, error;
+}
+function resetApiBuildVersion() {
+  apiBuildVersion = void 0, mismatchedServers.clear(), reportedServers.clear(), mismatchError = void 0;
+}
+export {
+  getApiBuildVersion,
+  hasApiVersionMismatch,
+  noteServerApiVersion,
+  reportApiVersionMismatch,
+  resetApiBuildVersion,
+  setApiBuildVersion,
+  stashApiVersionError,
+  takeApiVersionError
+};
+
+//# sourceMappingURL=apiBuildVersion.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apiBuildVersion.js","names":[],"sources":["../../../../src/lib/apiBuildVersion.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\n// The version check rides every response, so it cannot be lazily loaded; what a mismatch then does lives in\n// apiVersionRecovery.ts, behind `#metadata-from-server`. Split from client.ts: request.ts\n// must not pull the client in. One build version per program, one mismatch per server.\n\nimport {RpcError} from '@mionjs/core';\n\n/** The API version this client was built against, injected at `initClient` by the build. */\nlet apiBuildVersion: string | undefined;\n/** baseURLs that answered with a version other than this build's. */\nconst mismatchedServers = new Set<string>();\nlet mismatchError: RpcError<'api-version-mismatch'> | undefined;\n\n/** Called by generated code, never by hand: the value comes from the API's types. */\nexport function setApiBuildVersion(version: string | undefined): void {\n  apiBuildVersion = version || undefined;\n}\n\nexport function getApiBuildVersion(): string | undefined {\n  return apiBuildVersion;\n}\n\n/** A missing version on either side answers false: an end with no version knows too little to call it a mismatch. */\nexport function noteServerApiVersion(baseURL: string, serverVersion: string | undefined | null): boolean {\n  if (!serverVersion || !apiBuildVersion || serverVersion === apiBuildVersion) return false;\n  mismatchedServers.add(baseURL);\n  return true;\n}\n\n/** Whether the recovery module is worth loading: nothing else in this file reaches it. */\nexport function hasApiVersionMismatch(baseURL: string): boolean {\n  return mismatchedServers.has(baseURL);\n}\n\n/** baseURLs whose mismatch was already reported for the whole API. */\nconst reportedServers = new Set<string>();\n\n/** Without the metadata middleware no route can be checked alone, so the whole API is reported, once per server. */\nexport function reportApiVersionMismatch(baseURL: string): void {\n  if (reportedServers.has(baseURL)) return;\n  reportedServers.add(baseURL);\n  mismatchError = new RpcError({\n    type: 'api-version-mismatch',\n    publicMessage:\n      `The server at ${baseURL || 'this origin'} runs a different build of the API than this client was built against. ` +\n      `Reload the app or rebuild the client against the current API.`,\n  });\n}\n\n/** Held for the next call's @thrownErrors, beside the bundled-API error: the call itself ran. */\nexport function stashApiVersionError(error: RpcError<'api-version-mismatch'>): void {\n  mismatchError = error;\n}\n\n/** The mismatch error, reported once. */\nexport function takeApiVersionError(): RpcError<'api-version-mismatch'> | undefined {\n  const error = mismatchError;\n  mismatchError = undefined;\n  return error;\n}\n\n/** Tests only: forgets the injected version and the mismatch. */\nexport function resetApiBuildVersion(): void {\n  apiBuildVersion = undefined;\n  mismatchedServers.clear();\n  reportedServers.clear();\n  mismatchError = undefined;\n}\n"],"mappings":";AAcA,IAAI,iBAEE,oBAAoB,oBAAI,IAAY,GACtC;AAGJ,SAAgB,mBAAmB,SAAmC;AACpE,oBAAkB,WAAW;AAC/B;AAEA,SAAgB,qBAAyC;AACvD,SAAO;AACT;AAGA,SAAgB,qBAAqB,SAAiB,eAAmD;AACvG,SAAI,CAAC,iBAAiB,CAAC,mBAAmB,kBAAkB,kBAAwB,MACpF,kBAAkB,IAAI,OAAO,GACtB;AACT;AAGA,SAAgB,sBAAsB,SAA0B;AAC9D,SAAO,kBAAkB,IAAI,OAAO;AACtC;AAGA,IAAM,kBAAkB,oBAAI,IAAY;AAGxC,SAAgB,yBAAyB,SAAuB;AAC9D,EAAI,gBAAgB,IAAI,OAAO,MAC/B,gBAAgB,IAAI,OAAO,GAC3B,gBAAgB,IAAI,SAAS;AAAA,IAC3B,MAAM;AAAA,IACN,eACE,iBAAiB,WAAW,aAAA;AAAA,EAEhC,CAAC;AACH;AAGA,SAAgB,qBAAqB,OAA+C;AAClF,kBAAgB;AAClB;AAGA,SAAgB,sBAAoE;AAClF,QAAM,QAAQ;AACd,yBAAgB,QACT;AACT;AAGA,SAAgB,uBAA6B;AAC3C,oBAAkB,QAClB,kBAAkB,MAAM,GACxB,gBAAgB,MAAM,GACtB,gBAAgB;AAClB"}

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

@@ -0,0 +1,7 @@
+import { MethodWithOptions, SerializableMethodsData } from '@mionjs/core';
+import { ClientOptions } from '../types.ts';
+export declare function unverifiedIds(baseURL: string, ids: string[]): string[];
+export declare function resetApiVersionRecovery(): void;
+export declare function verifyMethodRows(options: ClientOptions, asked: string[], data: SerializableMethodsData): void;
+export declare function rowsAgree(held: MethodWithOptions | undefined, served: MethodWithOptions | undefined): boolean;
+//# sourceMappingURL=apiVersionRecovery.d.ts.map

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

@@ -0,0 +1,43 @@
+import { getMethod, isBundledMethod } from "./methods.js";
+import { installMethodRows } from "./clientMethodsMetadata.js";
+import { stashApiVersionError } from "./apiBuildVersion.js";
+import { RpcError } from "@mionjs/core";
+var verifiedIds = /* @__PURE__ */ new Map();
+function verifiedBy(baseURL) {
+  let ids = verifiedIds.get(baseURL);
+  return ids || verifiedIds.set(baseURL, ids = /* @__PURE__ */ new Set()), ids;
+}
+function unverifiedIds(baseURL, ids) {
+  const verified = verifiedBy(baseURL);
+  return ids.filter((id) => !verified.has(id));
+}
+function resetApiVersionRecovery() {
+  verifiedIds.clear();
+}
+function verifyMethodRows(options, asked, data) {
+  const verified = verifiedBy(options.baseURL);
+  for (const id of asked) verified.add(id);
+  const stale = asked.filter((id) => !rowsAgree(getMethod(id), data.methods[id]));
+  if (!stale.length) return;
+  const fetched = stale.filter((id) => !isBundledMethod(id));
+  fetched.length && installMethodRows(data, options, fetched);
+  const bundled = stale.filter((id) => isBundledMethod(id));
+  bundled.length && stashApiVersionError(staleRoutesError(bundled));
+}
+function rowsAgree(held, served) {
+  return !!held?.syncId && held.syncId === served?.syncId;
+}
+function staleRoutesError(stale) {
+  return new RpcError({
+    type: "api-version-mismatch",
+    publicMessage: `This mion client carries routes compiled against an older version of the API: the server answers with a different build version, and ${stale.map((id) => `"${id}"`).join(", ")} no longer matches what it declares. Reload the app or rebuild the client against the current API.`
+  });
+}
+export {
+  resetApiVersionRecovery,
+  rowsAgree,
+  unverifiedIds,
+  verifyMethodRows
+};
+
+//# sourceMappingURL=apiVersionRecovery.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apiVersionRecovery.js","names":[],"sources":["../../../../src/lib/apiVersionRecovery.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\n// Rides the `#metadata-from-server` chunk: like the fetch, it runs only when the bundle comes up short.\n\nimport {RpcError} from '@mionjs/core';\nimport type {MethodWithOptions, SerializableMethodsData} from '@mionjs/core';\nimport type {ClientOptions} from '../types.ts';\nimport {stashApiVersionError} from './apiBuildVersion.ts';\nimport {getMethod, isBundledMethod} from './methods.ts';\nimport {installMethodRows} from './clientMethodsMetadata.ts';\n\n/** Ids each baseURL confirmed: a route is checked once per server, on its first use after the mismatch. */\nconst verifiedIds = new Map<string, Set<string>>();\n\nfunction verifiedBy(baseURL: string): Set<string> {\n  let ids = verifiedIds.get(baseURL);\n  if (!ids) verifiedIds.set(baseURL, (ids = new Set()));\n  return ids;\n}\n\n/** The ids to ask the server to confirm, out of the ones this request calls. */\nexport function unverifiedIds(baseURL: string, ids: string[]): string[] {\n  const verified = verifiedBy(baseURL);\n  return ids.filter((id) => !verified.has(id));\n}\n\n/** Tests only: forgets which routes were confirmed. */\nexport function resetApiVersionRecovery(): void {\n  verifiedIds.clear();\n}\n\n/** A fetched row is a cache: replaced and saved. A bundled one is what the calling code was built against: reported. */\nexport function verifyMethodRows(options: ClientOptions, asked: string[], data: SerializableMethodsData): void {\n  const verified = verifiedBy(options.baseURL);\n  for (const id of asked) verified.add(id);\n  // Only the asked ids: comparing the middleware riding along would report a route this call never uses.\n  const stale = asked.filter((id) => !rowsAgree(getMethod(id), data.methods[id] as MethodWithOptions | undefined));\n  if (!stale.length) return;\n  const fetched = stale.filter((id) => !isBundledMethod(id));\n  if (fetched.length) installMethodRows(data, options, fetched);\n  const bundled = stale.filter((id) => isBundledMethod(id));\n  if (bundled.length) stashApiVersionError(staleRoutesError(bundled));\n}\n\n/** Sync id only: it covers the types and wire formats; a row or id missing on either end never agrees. */\nexport function rowsAgree(held: MethodWithOptions | undefined, served: MethodWithOptions | undefined): boolean {\n  return !!held?.syncId && held.syncId === served?.syncId;\n}\n\nfunction staleRoutesError(stale: string[]): RpcError<'api-version-mismatch'> {\n  return new RpcError({\n    type: 'api-version-mismatch',\n    publicMessage:\n      `This mion client carries routes compiled against an older version of the API: the server answers with a ` +\n      `different build version, and ${stale.map((id) => `\"${id}\"`).join(', ')} no longer matches what it declares. ` +\n      `Reload the app or rebuild the client against the current API.`,\n  });\n}\n"],"mappings":";;;;AAiBA,IAAM,cAAc,oBAAI,IAAyB;AAEjD,SAAS,WAAW,SAA8B;AAChD,MAAI,MAAM,YAAY,IAAI,OAAO;AACjC,SAAK,OAAK,YAAY,IAAI,SAAU,MAAM,oBAAI,IAAI,CAAE,GAC7C;AACT;AAGA,SAAgB,cAAc,SAAiB,KAAyB;AACtE,QAAM,WAAW,WAAW,OAAO;AACnC,SAAO,IAAI,OAAA,CAAQ,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;AAC7C;AAGA,SAAgB,0BAAgC;AAC9C,cAAY,MAAM;AACpB;AAGA,SAAgB,iBAAiB,SAAwB,OAAiB,MAAqC;AAC7G,QAAM,WAAW,WAAW,QAAQ,OAAO;AAC3C,aAAW,MAAM,MAAO,UAAS,IAAI,EAAE;AAEvC,QAAM,QAAQ,MAAM,OAAA,CAAQ,OAAO,CAAC,UAAU,UAAU,EAAE,GAAG,KAAK,QAAQ,EAAA,CAAoC,CAAC;AAC/G,MAAI,CAAC,MAAM,OAAQ;AACnB,QAAM,UAAU,MAAM,OAAA,CAAQ,OAAO,CAAC,gBAAgB,EAAE,CAAC;AACzD,EAAI,QAAQ,UAAQ,kBAAkB,MAAM,SAAS,OAAO;AAC5D,QAAM,UAAU,MAAM,OAAA,CAAQ,OAAO,gBAAgB,EAAE,CAAC;AACxD,EAAI,QAAQ,UAAQ,qBAAqB,iBAAiB,OAAO,CAAC;AACpE;AAGA,SAAgB,UAAU,MAAqC,QAAgD;AAC7G,SAAO,CAAC,CAAC,MAAM,UAAU,KAAK,WAAW,QAAQ;AACnD;AAEA,SAAS,iBAAiB,OAAmD;AAC3E,SAAO,IAAI,SAAS;AAAA,IAClB,MAAM;AAAA,IACN,eACE,wIACgC,MAAM,IAAA,CAAK,OAAO,IAAI,EAAA,GAAK,EAAE,KAAK,IAAI,CAAA;AAAA,EAE1E,CAAC;AACH"}

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

@@ -0,0 +1,12 @@
+import { RpcError, MethodWithOptions, RtMarkerPayload } from '@mionjs/core';
+import { InjectedApiMetadata } from '../types.ts';
+export interface BundledMethod extends Pick<MethodWithOptions, 'id' | 'pointer' | 'nestLevel' | 'type' | 'isAsync' | 'options' | 'middlewareIds'> {
+    rtFns: RtMarkerPayload;
+}
+export interface BundledApiPayload {
+    methods: BundledMethod[];
+}
+export declare function registerBundledApi(payload: InjectedApiMetadata): void;
+export declare function takeBundledApiError(): RpcError<string> | undefined;
+export declare function resetBundledApi(): void;
+//# sourceMappingURL=bundledApi.d.ts.map