@mionjs/client 0.8.8 → 0.13.0

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

@@ -1,37 +1,32 @@
-import { RpcError, CoreRouterOptions, Prettify, RunTypeError, SerializerMode, ValidationError } from '@mionjs/core';
-import { PublicHeadersFn, PublicMiddleFn, RemoteApi, PublicRoute } from '@mionjs/router';
+import { HandlerType, RpcError, InputFromRef, Prettify, RunTypeError, ValidationError } from '@mionjs/core';
+import { PublicHeadersMiddleware, PublicMiddleware, RemoteApi, PublicRoute } from '@mionjs/router';
+import { InjectApiMetadata } from '@mionjs/run-types';
 import { TypedEvent } from './lib/typedEvent.ts';
-export type Result<RouteSuccess, RouteError, MiddleFnsResults extends Record<string, unknown> = Record<string, unknown>, MiddleFnsErrors extends Record<string, unknown> = Record<string, RpcError<string, unknown>>> = [RouteSuccess | undefined, RouteError | undefined, MiddleFnsResults | undefined, MiddleFnsErrors | undefined];
-export type MiddleFnSuccess<H> = H extends MiddlewareSubRequest<infer PH> ? HandlerSuccessResponse<PH> : never;
-export type MiddleFnError<H> = H extends MiddlewareSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> : never;
-export type WorkflowResult<Routes extends RouteSubRequest<any>[], MiddleFns extends Record<string, MiddlewareSubRequest<any>> = Record<string, MiddlewareSubRequest<any>>> = [
-    WorkflowRouteResults<Routes>,
-    WorkflowRouteErrors<Routes>,
-    {
-        [K in keyof MiddleFns]?: MiddleFnSuccess<MiddleFns[K]>;
-    } | undefined,
-    {
-        [K in keyof MiddleFns]?: MiddleFnError<MiddleFns[K]>;
-    } | undefined
+import { MIDDLEWARE_HOOKS } from './constants.ts';
+import { StorageEngine } from './lib/storage.ts';
+export type Result<RouteSuccess, RouteError, RA = RemoteApi> = [
+    RouteSuccess | undefined,
+    RouteError | undefined,
+    ClientResponse<RA>
 ];
-export type WorkflowRouteResults<Routes extends RouteSubRequest<any>[]> = {
-    [K in keyof Routes]: Routes[K] extends RouteSubRequest<infer PH> ? HandlerSuccessResponse<PH> | undefined : never;
+export type BatchResult<Routes extends RouteSubRequest<any>[]> = {
+    [K in keyof Routes]: Routes[K] extends RouteSubRequest<any> ? Awaited<ReturnType<Routes[K]['call']>> : never;
 };
-export type WorkflowRouteErrors<Routes extends RouteSubRequest<any>[]> = {
-    [K in keyof Routes]: Routes[K] extends RouteSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> | undefined : never;
-};
-export interface ClientOptions extends CoreRouterOptions {
+export type ClientFetchOptions = Omit<RequestInit, 'method' | 'body' | 'signal'>;
+export interface ClientOptions {
     baseURL: string;
     basePath: string;
     suffix: string;
-    autoGenerateErrorId: boolean;
-    fetchOptions: RequestInit;
+    fetchOptions: ClientFetchOptions;
     validateParams: boolean;
-    serializer: SerializerMode;
+    validateServerResponses: boolean;
+    sanitizeParams: boolean;
+    storageEngine: StorageEngine;
     timeout?: number;
 }
+export type InjectedApiMetadata = InjectApiMetadata<RemoteApi, string>;
 type PublicHandler = (...args: any[]) => Promise<any>;
-type PublicMethod = PublicRoute | PublicMiddleFn | PublicHeadersFn;
+type PublicMethod = PublicRoute | PublicMiddleware | PublicHeadersMiddleware;
 type ExtractHandler<PM extends PublicMethod> = PM extends {
     handler: infer H;
 } ? H : never;
@@ -46,7 +41,7 @@ export type RequestBody = {
 };
 export type RouteParamsType<PM extends PublicMethod> = Parameters<ExtractHandler<PM>>;
 export type RouteParamType<PM extends PublicMethod, Index extends number> = Parameters<ExtractHandler<PM>>[Index];
-export type HeadersParamsType<PM extends PublicHeadersFn> = Parameters<ExtractHandler<PM>>[0];
+export type HeadersParamsType<PM extends PublicHeadersMiddleware> = Parameters<ExtractHandler<PM>>[0];
 export type RouteReturnType<PM extends PublicMethod> = HandlerSuccessResponse<ExtractHandler<PM>>;
 export type HandlerResponse<PH extends PublicHandler> = Awaited<ReturnType<PH>>;
 export type HandlerSuccessResponse<PH extends PublicHandler> = Exclude<HandlerResponse<PH>, RpcError<string>>;
@@ -60,78 +55,95 @@ export type FailResponses<List extends SubRequest<any>[]> = {
     [P in keyof List]: FailResponse<List[P]>;
 };
 export type RequestErrors = Map<string, RpcError<string>>;
-export type ErrorHandler<E extends RpcError<string, any>> = (error: E) => void;
-export type UnknownErrorHandler = (error: RpcError<string, any>) => void;
-export type SuccessHandler<S> = (result: S) => void;
+export type ErrorOfType<E extends RpcError<string, any>, T extends E['type']> = E extends any ? T extends E['type'] ? E : never : never;
+export type ErrorHandler<E extends RpcError<string, any>> = (error: E, context: MiddlewareContext) => unknown;
+export type ResponseHandler<S> = (result: S, context: MiddlewareContext) => unknown;
+export interface MiddlewareContext extends CallContext {
+    retry(): boolean;
+}
+export type RequestHandler<P extends any[] = any[]> = (call: (...params: P) => void, context: CallContext) => void | Promise<void>;
+export interface CallContext {
+    readonly route?: RouteSubRequest<any>;
+    readonly batchSubRequests?: RouteSubRequest<any>[];
+    readonly subRequestList: Readonly<Record<string, SubRequest<any>>>;
+    readonly options: ClientOptions;
+    readonly signal?: AbortSignal;
+}
+export interface ClientCallContext extends CallContext {
+    readonly path: string;
+    readonly requestId: string;
+    readonly subRequestList: Record<string, SubRequest<any>>;
+    readonly thrownErrorIds: Set<string>;
+    httpResponse: Response | undefined;
+    response: ClientResponse<RemoteApi>;
+}
 type Simplify<T> = T extends any ? T : never;
 export type HandlerErrors<PH extends (...args: any[]) => Promise<any>> = Simplify<Extract<HandlerResponse<PH>, RpcError<string, any>> | ValidationError>;
-export interface SubRequest<PH extends PublicHandler> {
+export interface SubRequest<PH extends PublicHandler, Id extends string = string> {
     pointer: string[];
-    id: string;
+    id: Id;
     isResolved: boolean;
     params: Parameters<PH>;
     resolvedValue?: HandlerSuccessResponse<PH>;
     error?: HandlerFailResponse<PH>;
     serializedParams?: any[];
+    mappings?: InputFromRef[];
 }
-export interface CallSetup<H extends Record<string, MiddlewareSubRequest<any>> = Record<string, never>, OtherRoutes extends RouteSubRequest<any>[] = []> {
-    middleFns?: H;
-    otherRoutes?: [...OtherRoutes];
+export interface CallSetup {
     signal?: AbortSignal;
     timeout?: number;
 }
-export interface RoutesFlowBuilder<Routes extends RouteSubRequest<any>[]> {
-    call(setup?: {
-        middleFns?: never;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<WorkflowResult<Routes>>;
-    call<H extends Record<string, MiddlewareSubRequest<any>>>(setup: {
-        middleFns: H;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<WorkflowResult<Routes, H>>;
+export type ApiOf<Routes extends SubRequest<any>[]> = Routes[number] extends RouteSubRequest<any, any, infer RA> ? RA : never;
+export interface BatchBuilder<Routes extends RouteSubRequest<any>[]> {
+    call(setup?: CallSetup, apiMetadata?: InjectApiMetadata<ApiOf<Routes>, Routes[number]['id']>): Promise<BatchResult<Routes>>;
 }
-export interface RouteSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
-    typeErrors: () => Promise<RunTypeError[]>;
-    call(setup?: {
-        middleFns?: never;
-        otherRoutes?: never;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<Result<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>>>;
-    call<H extends Record<string, MiddlewareSubRequest<any>>>(setup: {
-        middleFns: H;
-        otherRoutes?: never;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<Result<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>, {
-        [K in keyof H]?: MiddleFnSuccess<H[K]>;
-    }, {
-        [K in keyof H]?: MiddleFnError<H[K]>;
-    }>>;
-    call<OtherRoutes extends RouteSubRequest<any>[], H extends Record<string, MiddlewareSubRequest<any>> = Record<string, never>>(setup: {
-        otherRoutes: [...OtherRoutes];
-        middleFns?: H;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<WorkflowResult<any, H>>;
+export interface RouteSubRequest<PH extends PublicHandler, Id extends string = string, RA extends RemoteApi = any> extends SubRequest<PH, Id> {
+    typeErrors(apiMetadata?: InjectApiMetadata<RA, Id>): Promise<RunTypeError[]>;
+    call(setup?: CallSetup, apiMetadata?: InjectApiMetadata<RA, Id>): Promise<Result<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>, RA>>;
 }
-export interface MiddlewareSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
-    typeErrors: () => Promise<RunTypeError[]>;
-    prefill: () => TypedEvent<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>>;
-    removePrefill: () => Promise<void>;
+export type MiddlewareSubRequest<PH extends PublicHandler, Id extends string = string> = SubRequest<PH, Id>;
+export type MiddlewareEvents<PH extends PublicHandler> = TypedEvent<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>, Parameters<PH>>;
+export interface ClientMiddleware<PH extends PublicHandler, Id extends string = string> extends Pick<MiddlewareEvents<PH>, (typeof MIDDLEWARE_HOOKS)[number]> {
 }
-export type NonClientRoute = never | PublicMiddleFn | PublicHeadersFn;
-export type ClientRoutes<RA extends RemoteApi> = Prettify<{
-    [Property in keyof RA as RA[Property] extends NonClientRoute ? never : Property]: RA[Property] extends PublicRoute ? (...params: Parameters<RA[Property]['handler']>) => RouteSubRequest<RA[Property]['handler']> : RA[Property] extends RemoteApi ? ClientRoutes<RA[Property]> : never;
+export type ClientMiddlewareOf<H extends (ctx: any, ...params: any[]) => any> = H extends (ctx: any, ...params: infer P) => infer R ? ClientMiddleware<(...params: P) => Promise<Awaited<R>>> : never;
+type RouteLeaf = {
+    type: typeof HandlerType.route;
+    handler: PublicHandler;
+};
+type MiddlewareLeaf = {
+    type: typeof HandlerType.middleware | typeof HandlerType.headersMiddleware;
+    handler: PublicHandler;
+};
+type AnyLeaf = {
+    type: number;
+};
+export type NonClientRoute = MiddlewareLeaf;
+export type ClientRoutes<RA, Prefix extends string = '', Root extends RemoteApi = RA extends RemoteApi ? RA : RemoteApi> = Prettify<{
+    [Property in keyof RA & string as RA[Property] extends NonClientRoute ? never : Property]: RA[Property] extends {
+        type: typeof HandlerType.route;
+        handler: infer H extends PublicHandler;
+    } ? (...params: Parameters<H>) => RouteSubRequest<H, `${Prefix}${Property & string}`, Root> : RA[Property] extends AnyLeaf ? never : ClientRoutes<RA[Property], `${Prefix}${Property & string}/`, Root>;
 }>;
-export type NonClientMiddleFn = never | PublicRoute | {
-    [key: string]: PublicRoute;
+export type NonClientMiddleware = RouteLeaf | {
+    [key: string]: RouteLeaf;
 };
-export type ClientMiddleFns<RA extends RemoteApi> = Prettify<{
-    [Property in keyof RA as RA[Property] extends NonClientMiddleFn ? never : Property]: RA[Property] extends PublicMiddleFn | PublicHeadersFn ? (...params: Parameters<RA[Property]['handler']>) => MiddlewareSubRequest<RA[Property]['handler']> : RA[Property] extends RemoteApi ? ClientMiddleFns<RA[Property]> : never;
+export type ClientMiddlewares<RA, Prefix extends string = ''> = Prettify<{
+    [Property in keyof RA & string as RA[Property] extends NonClientMiddleware ? never : Property]: RA[Property] extends {
+        type: typeof HandlerType.middleware | typeof HandlerType.headersMiddleware;
+        handler: infer H extends PublicHandler;
+    } ? ClientMiddleware<H, `${Prefix}${Property & string}`> : RA[Property] extends AnyLeaf ? never : ClientMiddlewares<RA[Property], `${Prefix}${Property & string}/`>;
 }>;
+export type ClientResponse<RA> = (string extends keyof RA ? {
+    [key: string]: unknown;
+} : ClientMiddlewareResponses<RA>) & {
+    '@thrownErrors'?: RpcError<string>[];
+};
+type ClientMiddlewareResponses<RA> = {
+    [Property in keyof RA & string as RA[Property] extends NonClientMiddleware ? never : Property]?: RA[Property] extends {
+        type: typeof HandlerType.middleware | typeof HandlerType.headersMiddleware;
+        handler: infer H extends PublicHandler;
+    } ? HandlerResponse<H> | ValidationError : RA[Property] extends AnyLeaf ? never : ClientMiddlewareResponses<RA[Property]>;
+};
 export type Cleaned<RMS extends RemoteApi> = {
     [Property in keyof RMS as RMS[Property] extends never ? never : Property]: RMS[Property];
 };
@@ -139,6 +151,5 @@ export type SuccessClientResponse<RS extends RouteSubRequest<any>, RHList extend
     SuccessResponse<RS>,
     ...SuccessResponses<RHList>
 ];
-export type PrefilledMiddleFnsCache = Map<string, SubRequest<any>>;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/.dist/esm/index.d.ts

@@ -1,13 +1,16 @@
 export * from './src/types.ts';
 export * from './src/constants.ts';
 export * from './src/lib/storage.ts';
+export * from './src/lib/metadataStore.ts';
+export * from './src/lib/persistentStorage.ts';
 export * from './src/lib/validation.ts';
 export * from './src/lib/serializer.ts';
 export * from './src/lib/clientMethodsMetadata.ts';
 export * from './src/lib/fetchRemoteMethodsMetadata.ts';
-export * from './src/request.ts';
+export * from './src/callContext.ts';
+export * from './src/dispatch.ts';
 export * from './src/client.ts';
 export * from './src/lib/typedEvent.ts';
 export * from './src/lib/handlersRegistry.ts';
-export * from './src/routesFlow.ts';
+export * from './src/batch.ts';
 //# sourceMappingURL=index.d.ts.map

package/.dist/esm/index.js

@@ -1,42 +1,61 @@
-import { DEFAULT_PREFILL_OPTIONS, MAX_GET_URL_LENGTH, ROUTES_FLOW_KEY, ROUTES_FLOW_PATH, STORAGE_KEY } from "./src/constants.js";
-import { MemoryStorage, getStorage, resetStorageInstance } from "./src/lib/storage.js";
-import { validateSubRequest, validateSubRequests } from "./src/lib/validation.js";
-import { deserializeResponseBody, serializeRequestBody } from "./src/lib/serializer.js";
-import { createMetadataSubRequest, extractAndProcessMetadata, restoreAllDependencies, restoreFromLocalStorage, storeDependencies, storeMethodsMetadata } from "./src/lib/clientMethodsMetadata.js";
+import { CLIENT_REQUEST_ERROR_ID, DEFAULT_CLIENT_OPTIONS, DEFAULT_STORAGE_ENGINE, MAX_GET_URL_LENGTH, METADATA_CACHE_EVICTION_ROUNDS, METADATA_CACHE_MAX_BYTES, MIDDLEWARE_HOOKS, STORAGE_KEY } from "./src/constants.js";
+import { IdbMetadataStore, MemoryMetadataStore, getMetadataStore, resetMetadataStore, setMetadataStoreForTesting } from "./src/lib/metadataStore.js";
+import { requestPersistenceWhenSilent, requestPersistentStorage } from "./src/lib/persistentStorage.js";
+import { getResponseError, validateSubRequest, validateSubRequests } from "./src/lib/validation.js";
+import { deserializeResponseBody, serializeRequestBody, wireFormReplacer } from "./src/lib/serializer.js";
+import { flushMetadataCache, forgetFetchedMetadata, hydrateMetadataCache, installMethodRows, purgeHydratedMetadata, resetMetadataCacheState, takeMetadataCacheError, wasHydratedFromCache } from "./src/lib/clientMethodsMetadata.js";
 import { fetchRemoteMethodsMetadata } from "./src/lib/fetchRemoteMethodsMetadata.js";
-import { MionClientRequest } from "./src/request.js";
-import { MionClient, initClient } from "./src/client.js";
-import { TypedEvent } from "./src/lib/typedEvent.js";
+import { addSubRequest, createCallContext, getRouteIds, getRoutePointers } from "./src/callContext.js";
+import { dispatchCall, dispatchTypeErrors, isMiddlewareInScope, routeSucceeded } from "./src/dispatch.js";
 import { HandlersRegistry } from "./src/lib/handlersRegistry.js";
-import { isMapFromRef, mapFrom, mapFromSymbol, routesFlow } from "./src/routesFlow.js";
+import { TypedEvent } from "./src/lib/typedEvent.js";
+import { batch, inputFrom, isInputFromRef } from "./src/batch.js";
+import { MionClient, initClient, setApiBundled } from "./src/client.js";
 export {
-  DEFAULT_PREFILL_OPTIONS,
+  CLIENT_REQUEST_ERROR_ID,
+  DEFAULT_CLIENT_OPTIONS,
+  DEFAULT_STORAGE_ENGINE,
   HandlersRegistry,
+  IdbMetadataStore,
   MAX_GET_URL_LENGTH,
-  MemoryStorage,
+  METADATA_CACHE_EVICTION_ROUNDS,
+  METADATA_CACHE_MAX_BYTES,
+  MIDDLEWARE_HOOKS,
+  MemoryMetadataStore,
   MionClient,
-  MionClientRequest,
-  ROUTES_FLOW_KEY,
-  ROUTES_FLOW_PATH,
   STORAGE_KEY,
   TypedEvent,
-  createMetadataSubRequest,
+  addSubRequest,
+  batch,
+  createCallContext,
   deserializeResponseBody,
-  extractAndProcessMetadata,
+  dispatchCall,
+  dispatchTypeErrors,
   fetchRemoteMethodsMetadata,
-  getStorage,
+  flushMetadataCache,
+  forgetFetchedMetadata,
+  getMetadataStore,
+  getResponseError,
+  getRouteIds,
+  getRoutePointers,
+  hydrateMetadataCache,
   initClient,
-  isMapFromRef,
-  mapFrom,
-  mapFromSymbol,
-  resetStorageInstance,
-  restoreAllDependencies,
-  restoreFromLocalStorage,
-  routesFlow,
+  inputFrom,
+  installMethodRows,
+  isInputFromRef,
+  isMiddlewareInScope,
+  purgeHydratedMetadata,
+  requestPersistenceWhenSilent,
+  requestPersistentStorage,
+  resetMetadataCacheState,
+  resetMetadataStore,
+  routeSucceeded,
   serializeRequestBody,
-  storeDependencies,
-  storeMethodsMetadata,
+  setApiBundled,
+  setMetadataStoreForTesting,
+  takeMetadataCacheError,
   validateSubRequest,
-  validateSubRequests
+  validateSubRequests,
+  wasHydratedFromCache,
+  wireFormReplacer
 };
-//# sourceMappingURL=index.js.map

package/.dist/esm/middlewares.d.ts

@@ -0,0 +1,3 @@
+export { useFetchMetadata } from './src/middlewares/fetchMetadata.ts';
+export { useSyncRoutes } from './src/middlewares/syncRoutes.ts';
+//# sourceMappingURL=middlewares.d.ts.map

package/.dist/esm/middlewares.js

@@ -0,0 +1,6 @@
+import { useFetchMetadata } from "./src/middlewares/fetchMetadata.js";
+import { useSyncRoutes } from "./src/middlewares/syncRoutes.js";
+export {
+  useFetchMetadata,
+  useSyncRoutes
+};

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

@@ -0,0 +1,7 @@
+import { PureFunction, InjectPureFnId, InjectBatchId } from '@mionjs/run-types';
+import { RouteSubRequest, BatchBuilder, SubRequest } from './types.ts';
+import { InputFromRef } from '@mionjs/core';
+export declare function batch<Routes extends RouteSubRequest<any>[]>(routes: [...Routes], batchId?: InjectBatchId<Routes>): BatchBuilder<Routes>;
+export declare function inputFrom<FromSR extends SubRequest<any>, MappedInput = any>(source: FromSR, mapper: PureFunction<(value: FromSR['resolvedValue']) => MappedInput>, id?: InjectPureFnId<(value: FromSR['resolvedValue']) => MappedInput>): InputFromRef<(value: FromSR['resolvedValue']) => MappedInput>;
+export declare function isInputFromRef(ref: any): ref is InputFromRef<any>;
+//# sourceMappingURL=batch.d.ts.map

package/.dist/esm/src/batch.js

@@ -0,0 +1,50 @@
+import { RpcError } from "@mionjs/core";
+function batch(routes, batchId) {
+  if (!routes || routes.length === 0) throw new RpcError({
+    type: "batch-empty-routes",
+    publicMessage: "batch() requires at least one route subrequest."
+  });
+  if (!batchId) throw new RpcError({
+    type: "batch-missing-id",
+    publicMessage: "batch() needs the mion build plugin (vite or next preset) to inject the batch id. Batches are compiled into the server at build time, so a client without the build cannot send one."
+  });
+  const firstSubRequest = routes[0];
+  if (!firstSubRequest.client) throw new RpcError({
+    type: "batch-missing-client",
+    publicMessage: "Could not extract MionClient from subrequest. Ensure subrequests are created via routes proxy."
+  });
+  const client = firstSubRequest.client;
+  for (let i = 1; i < routes.length; i++) if (routes[i].client !== client) throw new RpcError({
+    type: "batch-client-mismatch",
+    publicMessage: `All subrequests in a batch must use the same client instance. Subrequest at index ${i} has a different client.`
+  });
+  return { async call(setup, apiMetadata) {
+    return client.useBundledApi(apiMetadata), client.execute(void 0, routes, batchId, setup?.signal, setup?.timeout);
+  } };
+}
+var inputFromSymbol = /* @__PURE__ */ Symbol("InputFromRef");
+function inputFrom(source, mapper, id) {
+  if (mapper == null) throw new Error("inputFrom() requires an inline mapper function");
+  if (!id) throw new Error("inputFrom() requires the mion build plugin: no pure-fn id was injected at build time, so the server has no way to know which mapper to run.");
+  const ref = {
+    inputFromSymbol,
+    mapperKey: id,
+    fromRequestId: source.id,
+    toRequestId: "",
+    paramIndex: -1,
+    asArg() {
+      return ref;
+    }
+  };
+  return ref;
+}
+function isInputFromRef(ref) {
+  return ref && ref.inputFromSymbol === inputFromSymbol;
+}
+export {
+  batch,
+  inputFrom,
+  isInputFromRef
+};
+
+//# sourceMappingURL=batch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"batch.js","names":[],"sources":["../../../src/batch.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {RpcError} from '@mionjs/core';\nimport type {PureFunction, InjectPureFnId, InjectBatchId} from '@mionjs/run-types';\nimport type {CallSetup, RouteSubRequest, BatchBuilder, SubRequest} from './types.ts';\nimport type {InjectedApiMetadata} from './types.ts';\nimport type {MionSubRequest} from './subRequest.ts';\nimport type {InputFromRef} from '@mionjs/core';\n\n/** Runs several routes in ONE HTTP request. The build hashes the ordered route ids into `batchId`, which\n * names the batch in the table it compiled into the server; the request carries only that id. */\nexport function batch<Routes extends RouteSubRequest<any>[]>(\n  routes: [...Routes],\n  batchId?: InjectBatchId<Routes>\n): BatchBuilder<Routes> {\n  if (!routes || routes.length === 0) {\n    throw new RpcError({\n      type: 'batch-empty-routes',\n      publicMessage: 'batch() requires at least one route subrequest.',\n    });\n  }\n  if (!batchId) {\n    throw new RpcError({\n      type: 'batch-missing-id',\n      publicMessage:\n        'batch() needs the mion build plugin (vite or next preset) to inject the batch id. ' +\n        'Batches are compiled into the server at build time, so a client without the build cannot send one.',\n    });\n  }\n\n  const firstSubRequest = routes[0] as MionSubRequest;\n  if (!firstSubRequest.client) {\n    throw new RpcError({\n      type: 'batch-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  for (let i = 1; i < routes.length; i++) {\n    const subRequest = routes[i] as MionSubRequest;\n    if (subRequest.client !== client) {\n      throw new RpcError({\n        type: 'batch-client-mismatch',\n        publicMessage: `All subrequests in a batch must use the same client instance. Subrequest at index ${i} has a different client.`,\n      });\n    }\n  }\n\n  return {\n    // `apiMetadata` is filled by the build when routes are bundled, never by hand\n    async call(setup?: CallSetup, apiMetadata?: InjectedApiMetadata) {\n      client.useBundledApi(apiMetadata);\n      return client.execute(undefined, routes, batchId, setup?.signal, setup?.timeout);\n    },\n  };\n}\n\nconst inputFromSymbol = Symbol('InputFromRef');\n\n/** Feeds the output of one route SubRequest into the input of another within a batch. The mapper EXECUTES\n * ON THE SERVER, which only runs functions its own build baked in, so nothing about the mapper travels: the\n * build extracts the inline mapper, gives the call site its registration id and ships the body in the\n * batches manifest. */\nexport function inputFrom<FromSR extends SubRequest<any>, MappedInput = any>(\n  source: FromSR,\n  mapper: PureFunction<(value: FromSR['resolvedValue']) => MappedInput>,\n  id?: InjectPureFnId<(value: FromSR['resolvedValue']) => MappedInput>\n): InputFromRef<(value: FromSR['resolvedValue']) => MappedInput> {\n  // The build rewrites this argument into the mapper's generated entry tuple, not the function the caller wrote.\n  if (mapper == null) throw new Error('inputFrom() requires an inline mapper function');\n  if (!id)\n    throw new Error(\n      'inputFrom() requires the mion build plugin: no pure-fn id was injected at build time, ' +\n        'so the server has no way to know which mapper to run.'\n    );\n  const ref = {\n    inputFromSymbol,\n    mapperKey: id,\n    fromRequestId: source.id,\n    toRequestId: '',\n    paramIndex: -1, // set by MionSubRequest constructor when passed as a parameter\n    asArg() {\n      return ref as unknown as MappedInput;\n    },\n  } as unknown as InputFromRef<(value: FromSR['resolvedValue']) => MappedInput>;\n  return ref;\n}\n\nexport function isInputFromRef(ref: any): ref is InputFromRef<any> {\n  return ref && ref.inputFromSymbol === inputFromSymbol;\n}\n"],"mappings":";AAgBA,SAAgB,MACd,QACA,SACsB;AACtB,MAAI,CAAC,UAAU,OAAO,WAAW,EAC/B,OAAM,IAAI,SAAS;AAAA,IACjB,MAAM;AAAA,IACN,eAAe;AAAA,EACjB,CAAC;AAEH,MAAI,CAAC,QACH,OAAM,IAAI,SAAS;AAAA,IACjB,MAAM;AAAA,IACN,eACE;AAAA,EAEJ,CAAC;AAGH,QAAM,kBAAkB,OAAO,CAAA;AAC/B,MAAI,CAAC,gBAAgB,OACnB,OAAM,IAAI,SAAS;AAAA,IACjB,MAAM;AAAA,IACN,eAAe;AAAA,EACjB,CAAC;AAGH,QAAM,SAAS,gBAAgB;AAE/B,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,IAEjC,KADmB,OAAO,CAAA,EACX,WAAW,OACxB,OAAM,IAAI,SAAS;AAAA,IACjB,MAAM;AAAA,IACN,eAAe,qFAAqF,CAAA;AAAA,EACtG,CAAC;AAIL,SAAO,EAEL,MAAM,KAAK,OAAmB,aAAmC;AAC/D,kBAAO,cAAc,WAAW,GACzB,OAAO,QAAQ,QAAW,QAAQ,SAAS,OAAO,QAAQ,OAAO,OAAO;AAAA,EACjF,EACF;AACF;AAEA,IAAM,kBAAkB,uBAAO,cAAc;AAM7C,SAAgB,UACd,QACA,QACA,IAC+D;AAE/D,MAAI,UAAU,KAAM,OAAM,IAAI,MAAM,gDAAgD;AACpF,MAAI,CAAC,GACH,OAAM,IAAI,MACR,6IAEF;AACF,QAAM,MAAM;AAAA,IACV;AAAA,IACA,WAAW;AAAA,IACX,eAAe,OAAO;AAAA,IACtB,aAAa;AAAA,IACb,YAAY;AAAA,IACZ,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAgB,eAAe,KAAoC;AACjE,SAAO,OAAO,IAAI,oBAAoB;AACxC"}

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

@@ -0,0 +1,6 @@
+import { ClientCallContext, ClientOptions, RouteSubRequest, SubRequest } from './types.ts';
+export declare function createCallContext(options: ClientOptions, route?: RouteSubRequest<any>, batchSubRequests?: RouteSubRequest<any>[], batchId?: string, signal?: AbortSignal): ClientCallContext;
+export declare function addSubRequest(context: ClientCallContext, subRequest: SubRequest<any>): void;
+export declare function getRouteIds(context: ClientCallContext): string[];
+export declare function getRoutePointers(context: ClientCallContext): string[][];
+//# sourceMappingURL=callContext.d.ts.map

package/.dist/esm/src/callContext.js

@@ -0,0 +1,34 @@
+import { MION_BATCH_KEY, getRoutePath } from "@mionjs/core";
+function createCallContext(options, route, batchSubRequests, batchId, signal) {
+  const isBatch = !!batchSubRequests && batchSubRequests.length > 0, context = {
+    path: isBatch ? `${getRoutePath([MION_BATCH_KEY], options)}?id=${encodeURIComponent(batchId ?? "")}` : route ? getRoutePath(route.pointer, options) : "no-route",
+    requestId: isBatch ? MION_BATCH_KEY : route ? route.id : "no-route",
+    route,
+    batchSubRequests,
+    subRequestList: {},
+    options,
+    signal,
+    httpResponse: void 0,
+    response: {},
+    thrownErrorIds: /* @__PURE__ */ new Set()
+  };
+  return isBatch ? batchSubRequests.forEach((subRequest) => addSubRequest(context, subRequest)) : route && addSubRequest(context, route), context;
+}
+function addSubRequest(context, subRequest) {
+  if (subRequest.isResolved) throw new Error(`SubRequest ${subRequest.id} is already resolved`);
+  context.subRequestList[subRequest.id] = subRequest;
+}
+function getRouteIds(context) {
+  return context.batchSubRequests && context.batchSubRequests.length > 0 ? context.batchSubRequests.map((sr) => sr.id) : [context.requestId];
+}
+function getRoutePointers(context) {
+  return context.batchSubRequests && context.batchSubRequests.length > 0 ? context.batchSubRequests.map((sr) => sr.pointer) : context.route ? [context.route.pointer] : [];
+}
+export {
+  addSubRequest,
+  createCallContext,
+  getRouteIds,
+  getRoutePointers
+};
+
+//# sourceMappingURL=callContext.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callContext.js","names":[],"sources":["../../../src/callContext.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {MION_BATCH_KEY, getRoutePath} from '@mionjs/core';\nimport type {ClientCallContext, ClientOptions, RouteSubRequest, SubRequest} from './types.ts';\n\n/** `batchId` is build-injected and only ends up in the batch path */\nexport function createCallContext(\n  options: ClientOptions,\n  route?: RouteSubRequest<any>,\n  batchSubRequests?: RouteSubRequest<any>[],\n  batchId?: string,\n  signal?: AbortSignal\n): ClientCallContext {\n  const isBatch = !!batchSubRequests && batchSubRequests.length > 0;\n  const context: ClientCallContext = {\n    path: isBatch\n      ? `${getRoutePath([MION_BATCH_KEY], options)}?id=${encodeURIComponent(batchId ?? '')}`\n      : route\n        ? getRoutePath(route.pointer, options)\n        : 'no-route',\n    requestId: isBatch ? MION_BATCH_KEY : route ? route.id : 'no-route',\n    route,\n    batchSubRequests,\n    subRequestList: {},\n    options,\n    signal,\n    httpResponse: undefined,\n    response: {},\n    thrownErrorIds: new Set<string>(),\n  };\n  if (isBatch) batchSubRequests.forEach((subRequest) => addSubRequest(context, subRequest));\n  else if (route) addSubRequest(context, route);\n  return context;\n}\n\nexport function addSubRequest(context: ClientCallContext, subRequest: SubRequest<any>): void {\n  if (subRequest.isResolved) throw new Error(`SubRequest ${subRequest.id} is already resolved`);\n  context.subRequestList[subRequest.id] = subRequest;\n}\n\nexport function getRouteIds(context: ClientCallContext): string[] {\n  if (context.batchSubRequests && context.batchSubRequests.length > 0) return context.batchSubRequests.map((sr) => sr.id);\n  return [context.requestId];\n}\n\n/** Same order as getRouteIds() */\nexport function getRoutePointers(context: ClientCallContext): string[][] {\n  if (context.batchSubRequests && context.batchSubRequests.length > 0) return context.batchSubRequests.map((sr) => sr.pointer);\n  return context.route ? [context.route.pointer] : [];\n}\n"],"mappings":";AAWA,SAAgB,kBACd,SACA,OACA,kBACA,SACA,QACmB;AACnB,QAAM,UAAU,CAAC,CAAC,oBAAoB,iBAAiB,SAAS,GAC1D,UAA6B;AAAA,IACjC,MAAM,UACF,GAAG,aAAa,CAAC,cAAc,GAAG,OAAO,CAAA,OAAQ,mBAAmB,WAAW,EAAE,CAAA,KACjF,QACE,aAAa,MAAM,SAAS,OAAO,IACnC;AAAA,IACN,WAAW,UAAU,iBAAiB,QAAQ,MAAM,KAAK;AAAA,IACzD;AAAA,IACA;AAAA,IACA,gBAAgB,CAAC;AAAA,IACjB;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd,UAAU,CAAC;AAAA,IACX,gBAAgB,oBAAI,IAAY;AAAA,EAClC;AACA,SAAI,UAAS,iBAAiB,QAAA,CAAS,eAAe,cAAc,SAAS,UAAU,CAAC,IAC/E,SAAO,cAAc,SAAS,KAAK,GACrC;AACT;AAEA,SAAgB,cAAc,SAA4B,YAAmC;AAC3F,MAAI,WAAW,WAAY,OAAM,IAAI,MAAM,cAAc,WAAW,EAAA,sBAAwB;AAC5F,UAAQ,eAAe,WAAW,EAAA,IAAM;AAC1C;AAEA,SAAgB,YAAY,SAAsC;AAChE,SAAI,QAAQ,oBAAoB,QAAQ,iBAAiB,SAAS,IAAU,QAAQ,iBAAiB,IAAA,CAAK,OAAO,GAAG,EAAE,IAC/G,CAAC,QAAQ,SAAS;AAC3B;AAGA,SAAgB,iBAAiB,SAAwC;AACvE,SAAI,QAAQ,oBAAoB,QAAQ,iBAAiB,SAAS,IAAU,QAAQ,iBAAiB,IAAA,CAAK,OAAO,GAAG,OAAO,IACpH,QAAQ,QAAQ,CAAC,QAAQ,MAAM,OAAO,IAAI,CAAC;AACpD"}

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

@@ -1,31 +1,26 @@
-import { ClientOptions, MiddlewareSubRequest, InitClientOptions, RouteSubRequest, SubRequest, ClientRoutes, ClientMiddleFns } from './types.ts';
+import { ClientOptions, InjectedApiMetadata, InitClientOptions, RouteSubRequest, SubRequest, ClientRoutes, ClientMiddlewares } from './types.ts';
 import { RemoteApi } from '@mionjs/router';
+import { InjectBuildVersion } from '@mionjs/run-types';
 import { RunTypeError } from '@mionjs/core';
 import { HandlersRegistry } from './lib/handlersRegistry.ts';
-export declare function initClient<RM extends RemoteApi>(options: InitClientOptions): {
+export declare function setApiBundled(): void;
+export declare function initClient<RM extends RemoteApi>(options: InitClientOptions, buildVersion?: InjectBuildVersion<RM>): {
     client: MionClient;
     routes: ClientRoutes<RM>;
-    middleFns: ClientMiddleFns<RM>;
+    middlewares: ClientMiddlewares<RM>;
 };
 export declare class MionClient {
     private clientOptions;
     readonly handlersRegistry: HandlersRegistry;
-    readonly prefilledMiddleFnsCache: Map<string, SubRequest<any>>;
-    private pendingPrefills;
     private globalAbortController;
     private get globalSignal();
     constructor(clientOptions: ClientOptions);
+    get isApiBundled(): boolean;
+    useBundledApi(apiMetadata: InjectedApiMetadata | undefined): void;
     abort(): void;
     private composeSignal;
-    execute(routeSubRequest?: RouteSubRequest<any>, workflowSubRequests?: RouteSubRequest<any>[], middleFnsRecord?: Record<string, MiddlewareSubRequest<any>>, signal?: AbortSignal, timeout?: number): Promise<any>;
-    private executeRequest;
-    private getRouteIds;
-    private getAllMiddleFnsFromRequest;
-    private processMiddleFnsResponses;
-    private buildResult;
+    execute(routeSubRequest?: RouteSubRequest<any>, batchSubRequests?: RouteSubRequest<any>[], batchId?: string, signal?: AbortSignal, timeout?: number): Promise<any>;
     typeErrors<List extends SubRequest<any>[]>(...subRequest: List): Promise<RunTypeError[]>;
-    prefill<List extends MiddlewareSubRequest<any>[]>(...subRequest: List): Promise<void>;
-    removePrefill<List extends MiddlewareSubRequest<any>[]>(...subRequest: List): Promise<void>;
     destroy(): void;
 }
 //# sourceMappingURL=client.d.ts.map