@mionjs/client 0.13.2 → 0.14.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"metadataFromServerLoader.cjs","names":[],"sources":["../../../../src/lib/metadataFromServerLoader.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 {RpcError} from '@mionjs/core';\n\n// Reaches the lane through `#metadata-from-server`, an @mionjs/client `imports` entry no consumer alias can collide with.\n\ntype MetadataFromServer = typeof import('./metadataFromServer.ts');\n\nlet laneModule: MetadataFromServer | undefined;\nlet loading: Promise<MetadataFromServer> | undefined;\n\n/** Awaited inside the request's own try, so a failed load reaches @thrownErrors; it is forgotten for a retry. */\nexport function loadMetadataFromServer(): Promise<MetadataFromServer> {\n  if (laneModule) return Promise.resolve(laneModule);\n  loading ??= (import('#metadata-from-server') as Promise<MetadataFromServer>)\n    .then((loaded) => {\n      laneModule = loaded;\n      return loaded;\n    })\n    .catch((error) => {\n      loading = undefined;\n      throw laneLoadError(error);\n    });\n  return loading;\n}\n\n/** The lane if a call already loaded it, never loading it. */\nexport function loadedMetadataFromServer(): MetadataFromServer | undefined {\n  return laneModule;\n}\n\n/** Forgets the loaded lane. Tests only: simulates a process that never reached it. */\nexport function resetMetadataFromServer(): void {\n  laneModule = undefined;\n  loading = undefined;\n}\n\nfunction laneLoadError(error: unknown): RpcError<'metadata-load-error'> {\n  return new RpcError({\n    type: 'metadata-load-error',\n    publicMessage:\n      'Could not load the code that asks the server how a route works. Build with client routes bundled to ship every route the client calls, or check that the app can load its own chunks.',\n    originalError: error instanceof Error ? error : undefined,\n  });\n}\n"],"mappings":"60BAaA,IAAI,WACA,QAGJ,SAAgB,wBAAsD,CACpE,OAAI,WAAmB,QAAQ,QAAQ,UAAU,GACjD,UAAa,OAAO,uBAAA,EACjB,KAAM,SACL,WAAa,OACN,OACR,EACA,MAAO,OAAU,CAChB,cAAU,OACJ,cAAc,KAAK,CAC3B,CAAC,EACI,QACT,CAGA,SAAgB,0BAA2D,CACzE,OAAO,UACT,CAGA,SAAgB,yBAAgC,CAC9C,WAAa,OACb,QAAU,MACZ,CAEA,SAAS,cAAc,MAAiD,CACtE,OAAO,IAAI,aAAA,SAAS,CAClB,KAAM,sBACN,cACE,wLACF,cAAe,iBAAiB,MAAQ,MAAQ,MAClD,CAAC,CACH"}

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

@@ -1,6 +0,0 @@
-type MetadataFromServer = typeof import('./metadataFromServer.ts');
-export declare function loadMetadataFromServer(): Promise<MetadataFromServer>;
-export declare function loadedMetadataFromServer(): MetadataFromServer | undefined;
-export declare function resetMetadataFromServer(): void;
-export {};
-//# sourceMappingURL=metadataFromServerLoader.d.ts.map

package/.dist/cjs/src/lib/metadataStore.cjs

@@ -1,3 +0,0 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_constants=require("../constants.cjs");var STORE_GLOBAL_KEY="__mion_metadata_store__",OBJECT_STORE="metadata",DB_VERSION=1,OPEN_TIMEOUT_MS=3e3,MemoryMetadataStore=class{kind="memory";records=new Map;async readAll(baseURL){const result=[];for(const record of this.records.values())record.baseURL===baseURL&&result.push(record);return result}async write(records){for(const record of records)this.records.set(recordMapKey(record.baseURL,record.kind,record.id),record)}async remove(baseURL,keys){for(const[kind,id]of keys)this.records.delete(recordMapKey(baseURL,kind,id))}async clear(baseURL){if(baseURL===void 0){this.records.clear();return}for(const[key,record]of this.records)record.baseURL===baseURL&&this.records.delete(key)}};function recordMapKey(baseURL,kind,id){return`${baseURL}\0${kind}\0${id}`}var IdbMetadataStore=class{db;kind="indexeddb";constructor(db){this.db=db}readAll(baseURL){return this.transact("readonly",store=>{const range=IDBKeyRange.bound([baseURL],[baseURL,[]],!1,!0);return store.getAll(range)})}write(records){return records.length?this.transact("readwrite",store=>{let last=store.put(records[0]);for(let i=1;i<records.length;i++)last=store.put(records[i]);return last}).then(()=>{}):Promise.resolve()}remove(baseURL,keys){return keys.length?this.transact("readwrite",store=>{let last=store.delete([baseURL,keys[0][0],keys[0][1]]);for(let i=1;i<keys.length;i++)last=store.delete([baseURL,keys[i][0],keys[i][1]]);return last}).then(()=>{}):Promise.resolve()}clear(baseURL){return this.transact("readwrite",store=>baseURL===void 0?store.clear():store.delete(IDBKeyRange.bound([baseURL],[baseURL,[]],!1,!0))).then(()=>{})}transact(mode,run){return new Promise((resolve,reject)=>{let transaction;try{transaction=this.db.transaction(OBJECT_STORE,mode)}catch(error){return reject(error)}let result;try{const request=run(transaction.objectStore(OBJECT_STORE));request.onsuccess=()=>result=request.result}catch(error){return transaction.abort(),reject(error)}transaction.oncomplete=()=>resolve(result),transaction.onabort=()=>reject(transaction.error??new Error("mion metadata cache transaction aborted")),transaction.onerror=()=>reject(transaction.error??new Error("mion metadata cache transaction failed"))})}};function openDatabase(){return typeof indexedDB>"u"?Promise.resolve(void 0):new Promise(resolve=>{let settled=!1;const settle=db=>{settled||(settled=!0,resolve(db))},timer=setTimeout(()=>settle(void 0),OPEN_TIMEOUT_MS),done=db=>{clearTimeout(timer),settle(db)};let request;try{request=indexedDB.open(require_src_constants.STORAGE_KEY,DB_VERSION)}catch{return clearTimeout(timer),settle(void 0)}request.onupgradeneeded=()=>{const db=request.result;db.objectStoreNames.contains(OBJECT_STORE)&&db.deleteObjectStore(OBJECT_STORE),db.createObjectStore(OBJECT_STORE,{keyPath:["baseURL","kind","id"]})},request.onsuccess=()=>{const db=request.result;db.onversionchange=()=>db.close(),done(db)},request.onerror=()=>done(void 0),request.onblocked=()=>done(void 0)})}async function openEngine(engine){if(engine==="memory")return new MemoryMetadataStore;if(engine==="indexeddb"){const db=await openDatabase();return db?new IdbMetadataStore(db):new MemoryMetadataStore}return await engine()??new MemoryMetadataStore}function getRegistry(){let registry=globalThis[STORE_GLOBAL_KEY];return registry||(registry={byEngine:new Map},globalThis[STORE_GLOBAL_KEY]=registry),registry}function getMetadataStore(engine=require_src_constants.DEFAULT_STORAGE_ENGINE){const registry=getRegistry();if(registry.override)return registry.override;const existing=registry.byEngine.get(engine);if(existing)return existing;const pending=openEngine(engine).catch(()=>new MemoryMetadataStore);return registry.byEngine.set(engine,pending),pending}function setMetadataStoreForTesting(store){getRegistry().override=Promise.resolve(store)}async function resetMetadataStore(){const registry=globalThis[STORE_GLOBAL_KEY];if(delete globalThis[STORE_GLOBAL_KEY],!registry)return;const pending=[registry.override,...registry.byEngine.values()].filter(entry=>entry!==void 0);for(const entry of pending)await(await entry.catch(()=>{}))?.clear().catch(()=>{})}exports.IdbMetadataStore=IdbMetadataStore;exports.MemoryMetadataStore=MemoryMetadataStore;exports.getMetadataStore=getMetadataStore;exports.resetMetadataStore=resetMetadataStore;exports.setMetadataStoreForTesting=setMetadataStoreForTesting;
-
-//# sourceMappingURL=metadataStore.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"metadataStore.cjs","names":[],"sources":["../../../../src/lib/metadataStore.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 engines mion ships, and the one place an engine is chosen. The contract they implement, and\n// that an app's own engine implements, is in storage.ts.\n\nimport {DEFAULT_STORAGE_ENGINE, STORAGE_KEY} from '../constants.ts';\nimport type {MetadataKind, MetadataRecord, MetadataRecordKey, MetadataStore, StorageEngine} from './storage.ts';\n\nconst STORE_GLOBAL_KEY = '__mion_metadata_store__';\nconst OBJECT_STORE = 'metadata';\nconst DB_VERSION = 1;\n/** A store that never answers (private mode has historically hung on open) must not hang the client */\nconst OPEN_TIMEOUT_MS = 3000;\n\n/** In-memory store for SSR, Node, and any browser where IndexedDB is missing or blocked. */\nexport class MemoryMetadataStore implements MetadataStore {\n  readonly kind = 'memory' as const;\n  private readonly records = new Map<string, MetadataRecord>();\n\n  async readAll(baseURL: string): Promise<MetadataRecord[]> {\n    const result: MetadataRecord[] = [];\n    for (const record of this.records.values()) if (record.baseURL === baseURL) result.push(record);\n    return result;\n  }\n\n  async write(records: MetadataRecord[]): Promise<void> {\n    for (const record of records) this.records.set(recordMapKey(record.baseURL, record.kind, record.id), record);\n  }\n\n  async remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void> {\n    for (const [kind, id] of keys) this.records.delete(recordMapKey(baseURL, kind, id));\n  }\n\n  async clear(baseURL?: string): Promise<void> {\n    if (baseURL === undefined) {\n      this.records.clear();\n      return;\n    }\n    for (const [key, record] of this.records) if (record.baseURL === baseURL) this.records.delete(key);\n  }\n}\n\nfunction recordMapKey(baseURL: string, kind: MetadataKind, id: string): string {\n  // \\u0000 as the escape, never a raw NUL byte: a source file carrying one is a repo contract break\n  return `${baseURL}\\u0000${kind}\\u0000${id}`;\n}\n\n/** IndexedDB store: one object store keyed by the compound `[baseURL, kind, id]`, so every entry of\n *  one server sits in one contiguous key range and a cold load is a single `getAll` over it. */\nexport class IdbMetadataStore implements MetadataStore {\n  readonly kind = 'indexeddb' as const;\n  constructor(private readonly db: IDBDatabase) {}\n\n  readAll(baseURL: string): Promise<MetadataRecord[]> {\n    return this.transact('readonly', (store) => {\n      // IndexedDB orders keys by type and an array sorts after every string, so `[baseURL, []]` is a\n      // valid open upper bound: strictly greater than every `[baseURL, kind, id]` and less than the\n      // next baseURL. That is what keeps this ONE request instead of a cursor walk or a full scan.\n      const range = IDBKeyRange.bound([baseURL], [baseURL, []], false, true);\n      return store.getAll(range) as IDBRequest<MetadataRecord[]>;\n    });\n  }\n\n  write(records: MetadataRecord[]): Promise<void> {\n    if (!records.length) return Promise.resolve();\n    return this.transact('readwrite', (store) => {\n      let last: IDBRequest = store.put(records[0]);\n      for (let i = 1; i < records.length; i++) last = store.put(records[i]);\n      return last;\n    }).then(() => undefined);\n  }\n\n  remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void> {\n    if (!keys.length) return Promise.resolve();\n    return this.transact('readwrite', (store) => {\n      let last: IDBRequest = store.delete([baseURL, keys[0][0], keys[0][1]]);\n      for (let i = 1; i < keys.length; i++) last = store.delete([baseURL, keys[i][0], keys[i][1]]);\n      return last;\n    }).then(() => undefined);\n  }\n\n  clear(baseURL?: string): Promise<void> {\n    return this.transact('readwrite', (store) => {\n      if (baseURL === undefined) return store.clear();\n      return store.delete(IDBKeyRange.bound([baseURL], [baseURL, []], false, true));\n    }).then(() => undefined);\n  }\n\n  /** Resolves on transaction COMPLETE, not on request success: a put that succeeded inside a\n   *  transaction the browser then aborts (quota) must reject, or a caller would count it as stored. */\n  private transact<T>(mode: IDBTransactionMode, run: (store: IDBObjectStore) => IDBRequest<T>): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      let transaction: IDBTransaction;\n      try {\n        transaction = this.db.transaction(OBJECT_STORE, mode);\n      } catch (error) {\n        return reject(error);\n      }\n      let result: T;\n      try {\n        const request = run(transaction.objectStore(OBJECT_STORE));\n        request.onsuccess = () => (result = request.result);\n      } catch (error) {\n        transaction.abort();\n        return reject(error);\n      }\n      transaction.oncomplete = () => resolve(result);\n      transaction.onabort = () => reject(transaction.error ?? new Error('mion metadata cache transaction aborted'));\n      transaction.onerror = () => reject(transaction.error ?? new Error('mion metadata cache transaction failed'));\n    });\n  }\n}\n\n/** Opens the database, or resolves undefined for every reason a browser can refuse one. */\nfunction openDatabase(): Promise<IDBDatabase | undefined> {\n  if (typeof indexedDB === 'undefined') return Promise.resolve(undefined);\n  return new Promise<IDBDatabase | undefined>((resolve) => {\n    let settled = false;\n    const settle = (db?: IDBDatabase) => {\n      if (settled) return;\n      settled = true;\n      resolve(db);\n    };\n    // an open that never answers falls back rather than hanging the first call behind it\n    const timer = setTimeout(() => settle(undefined), OPEN_TIMEOUT_MS);\n    const done = (db?: IDBDatabase) => {\n      clearTimeout(timer);\n      settle(db);\n    };\n    let request: IDBOpenDBRequest;\n    try {\n      request = indexedDB.open(STORAGE_KEY, DB_VERSION);\n    } catch {\n      clearTimeout(timer);\n      return settle(undefined);\n    }\n    request.onupgradeneeded = () => {\n      const db = request.result;\n      // the cache holds nothing that is not refetchable, so a schema bump is the invalidation lever\n      if (db.objectStoreNames.contains(OBJECT_STORE)) db.deleteObjectStore(OBJECT_STORE);\n      db.createObjectStore(OBJECT_STORE, {keyPath: ['baseURL', 'kind', 'id']});\n    };\n    request.onsuccess = () => {\n      const db = request.result;\n      // another tab upgrading must not deadlock this one: close and let the next call fall back\n      db.onversionchange = () => db.close();\n      done(db);\n    };\n    request.onerror = () => done(undefined);\n    request.onblocked = () => done(undefined);\n  });\n}\n\n/** Opens one engine. Anything it cannot give us here is a cache miss, never a failed call, so every\n *  refusal lands on the same fallback: keep the cache in memory for the life of the process. */\nasync function openEngine(engine: StorageEngine): Promise<MetadataStore> {\n  if (engine === 'memory') return new MemoryMetadataStore();\n  if (engine === 'indexeddb') {\n    const db = await openDatabase();\n    return db ? new IdbMetadataStore(db) : new MemoryMetadataStore();\n  }\n  // an app's own engine\n  return (await engine()) ?? new MemoryMetadataStore();\n}\n\n/** One resolved store per engine, plus a stand-in that wins over all of them while testing.\n *  Memoized on globalThis so every module instance shares one connection. */\ninterface StoreRegistry {\n  override?: Promise<MetadataStore>;\n  byEngine: Map<StorageEngine, Promise<MetadataStore>>;\n}\n\nfunction getRegistry(): StoreRegistry {\n  let registry = (globalThis as any)[STORE_GLOBAL_KEY] as StoreRegistry | undefined;\n  if (!registry) {\n    registry = {byEngine: new Map()};\n    (globalThis as any)[STORE_GLOBAL_KEY] = registry;\n  }\n  return registry;\n}\n\n/** Returns the store for one engine, opening it on first use. */\nexport function getMetadataStore(engine: StorageEngine = DEFAULT_STORAGE_ENGINE): Promise<MetadataStore> {\n  const registry = getRegistry();\n  if (registry.override) return registry.override;\n  const existing = registry.byEngine.get(engine);\n  if (existing) return existing;\n  const pending = openEngine(engine).catch(() => new MemoryMetadataStore());\n  registry.byEngine.set(engine, pending);\n  return pending;\n}\n\n/** Puts a stand-in behind every engine. Only for testing — the browser's own limits (a full disk, a\n *  refused write) cannot be produced any other way. */\nexport function setMetadataStoreForTesting(store: MetadataStore): void {\n  getRegistry().override = Promise.resolve(store);\n}\n\n/** Drops every store instance and everything they hold. Only for testing — simulates a new page. */\nexport async function resetMetadataStore(): Promise<void> {\n  const registry = (globalThis as any)[STORE_GLOBAL_KEY] as StoreRegistry | undefined;\n  delete (globalThis as any)[STORE_GLOBAL_KEY];\n  if (!registry) return;\n  const pending = [registry.override, ...registry.byEngine.values()].filter((entry) => entry !== undefined);\n  for (const entry of pending) {\n    const store = await entry.catch(() => undefined);\n    await store?.clear().catch(() => undefined);\n  }\n}\n"],"mappings":"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"}

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

@@ -1,23 +0,0 @@
-import { MetadataRecord, MetadataRecordKey, MetadataStore, StorageEngine } from './storage.ts';
-export declare class MemoryMetadataStore implements MetadataStore {
-    readonly kind: "memory";
-    private readonly records;
-    readAll(baseURL: string): Promise<MetadataRecord[]>;
-    write(records: MetadataRecord[]): Promise<void>;
-    remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void>;
-    clear(baseURL?: string): Promise<void>;
-}
-export declare class IdbMetadataStore implements MetadataStore {
-    private readonly db;
-    readonly kind: "indexeddb";
-    constructor(db: IDBDatabase);
-    readAll(baseURL: string): Promise<MetadataRecord[]>;
-    write(records: MetadataRecord[]): Promise<void>;
-    remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void>;
-    clear(baseURL?: string): Promise<void>;
-    private transact;
-}
-export declare function getMetadataStore(engine?: StorageEngine): Promise<MetadataStore>;
-export declare function setMetadataStoreForTesting(store: MetadataStore): void;
-export declare function resetMetadataStore(): Promise<void>;
-//# sourceMappingURL=metadataStore.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +0,0 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_lib_methods=require("./methods.cjs"),require_src_lib_headers=require("./headers.cjs");let _mionjs_core=require("@mionjs/core");function serializeRequestBody(context,optimistic=!1){return{body:optimistic?serializeJSonBodyOptimistic(context):serializeJsonBody(context),contentType:"application/json; charset=utf-8"}}function serializeJsonBody(context){const props=[],subRequestIds=Object.keys(context.subRequestList);for(let i=0;i<subRequestIds.length;i++){const id=subRequestIds[i],subRequest=context.subRequestList[id];if(!subRequest)continue;let params=subRequest.params;const method=require_src_lib_methods.useMethodFns(id);method.type===_mionjs_core.HandlerType.headersMiddleware&&method.headersParam&&(params=getParamsWithoutHeadersSubset(params));try{const jsonValue=stringifyHandlerParams(method,params,context.options.validateParams);if(!jsonValue)continue;props.push(`${JSON.stringify(id)}:${jsonValue}`)}catch(e){throw new _mionjs_core.RpcError({type:"json-stringify-request-error",publicMessage:`Failed to stringify params for handler ${id}`,originalError:e})}}return`{${props.join(",")}}`}function serializeJSonBodyOptimistic(context){const body={},subRequestIds=Object.keys(context.subRequestList);for(const id of subRequestIds){const subRequest=context.subRequestList[id];if(!subRequest)continue;const params=require_src_lib_headers.hasHeadersSubsetParam(id,subRequest.params)?getParamsWithoutHeadersSubset(subRequest.params):subRequest.params;params?.length&&(body[id]=params)}return JSON.stringify(body,wireFormReplacer)}function stringifyHandlerParams(method,params,validated){if(!method.paramsCount)return"";const{json,isType}=method.paramsJitFns;if(json.encode.isNoop)return JSON.stringify(params);if(!validated&&!isType.isNoop&&!isType.fn(params))return JSON.stringify(params,wireFormReplacer);const write=()=>JSON.stringify(json.encode.fn(params));try{return write()}catch{return JSON.stringify(params,wireFormReplacer)}}function wireFormReplacer(key,value){return value instanceof Map?[...value]:value instanceof Set?[...value]:typeof value=="bigint"?value.toString():value}async function deserializeResponseBody(response,options,takeRaw){let parsedBody;const contentType=response.headers.get("content-type")?.toLowerCase();if(!0===!!contentType?.includes("application/json"))parsedBody=await deserializeJsonResponseBody(response,takeRaw);else throw new _mionjs_core.RpcError({type:"unsupported-content-type",publicMessage:`Unsupported response content-type: '${contentType||"none"}'`});return parsedBody}async function deserializeJsonResponseBody(response,takeRaw){try{const parsedBody=await response.json(),rawEntries=parsedBody&&typeof parsedBody=="object"?takeRaw?.(parsedBody):void 0,extracted=extractThrownErrors(parsedBody);if(extracted.platformError)return{[_mionjs_core.MION_ROUTES.platformError]:extracted.platformError};let thrownErrors=extracted.thrownErrors;const deserializedBody={};return Object.entries(parsedBody).forEach(([methodId,returnValue])=>{const method=require_src_lib_methods.useMethodFns(methodId);try{deserializedBody[methodId]=parseHandlerJsonReturnValue(method,returnValue)}catch(decodeError){(thrownErrors??={})[methodId]=new _mionjs_core.RpcError({type:"deserialization-error",publicMessage:`Invalid response from Route or Middleware '${method.id}', can not deserialize return value: ${decodeError.message}`,errorData:decodeError?.errors})}}),thrownErrors&&(deserializedBody[_mionjs_core.MION_ROUTES.thrownErrors]=thrownErrors),rawEntries&&Object.assign(deserializedBody,rawEntries),deserializedBody}catch(err){throw new _mionjs_core.RpcError({type:"parsing-json-response-error",publicMessage:`Invalid json response body: ${err?.message||"unknown parsing error."}`})}}function extractThrownErrors(parsedBody){if(!(_mionjs_core.MION_ROUTES.thrownErrors in parsedBody))return{};const rawThrownErrors=parsedBody[_mionjs_core.MION_ROUTES.thrownErrors];if(delete parsedBody[_mionjs_core.MION_ROUTES.thrownErrors],_mionjs_core.MION_ROUTES.platformError in rawThrownErrors){const globalErrorValue=rawThrownErrors[_mionjs_core.MION_ROUTES.platformError];return{platformError:(0,_mionjs_core.isRpcError)(globalErrorValue)?new _mionjs_core.RpcError(globalErrorValue):globalErrorValue}}const thrownErrors=Object.create(null);return Object.entries(rawThrownErrors).forEach(([id,value])=>{thrownErrors[id]=(0,_mionjs_core.isRpcError)(value)?new _mionjs_core.RpcError(value):value}),{thrownErrors}}function getParamsWithoutHeadersSubset(params){return!params||params.length===0?[]:params.slice(1)}function parseHandlerJsonReturnValue(method,returnValue){if(!method.hasReturnData)return returnValue;const{decode}=method.returnJitFns.json;return decode.isNoop||!returnValue||returnValue instanceof _mionjs_core.RpcError?returnValue:(0,_mionjs_core.isRpcError)(returnValue)?new _mionjs_core.RpcError(returnValue):decode.fn(returnValue)}exports.deserializeResponseBody=deserializeResponseBody;exports.serializeRequestBody=serializeRequestBody;exports.wireFormReplacer=wireFormReplacer;
-
-//# sourceMappingURL=serializer.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"serializer.cjs","names":[],"sources":["../../../../src/lib/serializer.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {ResponseBody} from '@mionjs/router';\nimport {type MethodWithJitFns, RpcError, isRpcError, MION_ROUTES, HandlerType} from '@mionjs/core';\nimport type {CallContext} from '../types.ts';\nimport {useMethodFns} from './methods.ts';\nimport {hasHeadersSubsetParam} from './headers.ts';\nimport {ClientOptions} from '../types.ts';\n\nexport type SerializedBody = string;\n\nexport type ContentType = 'application/json; charset=utf-8';\n\n/** Runs on the parsed body before anything decodes, and may hand back entries to add untouched. */\ntype TakeRaw = (parsedBody: Record<string, unknown>) => Record<string, unknown> | undefined;\n\nexport interface SerializedRequest {\n  body: SerializedBody;\n  contentType: ContentType;\n}\n\n// ################################## SERIALIZE ##################################\n\n/** `optimistic`: the route's metadata is still being fetched, so no compiled encoders exist yet. */\nexport function serializeRequestBody(context: CallContext, optimistic = false): SerializedRequest {\n  const body = optimistic ? serializeJSonBodyOptimistic(context) : serializeJsonBody(context);\n  return {body, contentType: 'application/json; charset=utf-8'};\n}\n\nfunction serializeJsonBody(context: CallContext): string {\n  const props: string[] = [];\n  const subRequestIds = Object.keys(context.subRequestList);\n\n  for (let i = 0; i < subRequestIds.length; i++) {\n    const id = subRequestIds[i];\n    const subRequest = context.subRequestList[id];\n    if (!subRequest) continue;\n    let params = subRequest.params;\n    const method = useMethodFns(id);\n    if (method.type === HandlerType.headersMiddleware && method.headersParam) {\n      params = getParamsWithoutHeadersSubset(params);\n    }\n    try {\n      const jsonValue = stringifyHandlerParams(method, params, context.options.validateParams);\n      if (!jsonValue) continue;\n      props.push(`${JSON.stringify(id)}:${jsonValue}`);\n    } catch (e: any) {\n      const err = new RpcError({\n        type: 'json-stringify-request-error',\n        publicMessage: `Failed to stringify params for handler ${id}`,\n        originalError: e,\n      });\n      throw err;\n    }\n  }\n\n  return `{${props.join(',')}}`;\n}\n\n/** Plain wire forms every server decoder accepts; a HeadersSubset goes out as HTTP headers, never in the body */\nfunction serializeJSonBodyOptimistic(context: CallContext): string {\n  const body: Record<string, any> = {};\n  const subRequestIds = Object.keys(context.subRequestList);\n  for (const id of subRequestIds) {\n    const subRequest = context.subRequestList[id];\n    if (!subRequest) continue;\n    const params = hasHeadersSubsetParam(id, subRequest.params)\n      ? getParamsWithoutHeadersSubset(subRequest.params)\n      : subRequest.params;\n    if (params?.length) body[id] = params;\n  }\n  return JSON.stringify(body, wireFormReplacer);\n}\n\n/** Writes the params with the strategy the server compiled. */\nfunction stringifyHandlerParams(method: MethodWithJitFns, params: any[], validated: boolean): string {\n  if (!method.paramsCount) return '';\n  const {json, isType} = method.paramsJitFns;\n  if (json.encode.isNoop) return JSON.stringify(params);\n  // with local validation off a wrong-typed value must still reach the server's validation, and the\n  // compiled encoders assume the type, so it rides the plain wire form instead\n  if (!validated && !isType.isNoop && !isType.fn(params)) return JSON.stringify(params, wireFormReplacer);\n  const write = (): string => JSON.stringify(json.encode.fn(params));\n  // the compiled encoder rejects anything but the real params (a batch mapping's `null` placeholder,\n  // a wrong-typed value), so those fall back to the plain wire forms the server decoders accept\n  try {\n    return write();\n  } catch {\n    return JSON.stringify(params, wireFormReplacer);\n  }\n}\n\n/** The wire forms the server's JSON decoders accept; Date, URL and Temporal need no arm, their own toJSON writes it.\n *  No union `[index, value]` envelope: the index needs metadata, so the server's guarded decoder refuses and the client retries. */\nexport function wireFormReplacer(this: unknown, key: string, value: unknown): unknown {\n  if (value instanceof Map) return [...value];\n  if (value instanceof Set) return [...value];\n  if (typeof value === 'bigint') return value.toString();\n  return value;\n}\n\n// ################################## DE-SERIALIZE ##################################\n\nexport async function deserializeResponseBody(\n  response: Response,\n  options: ClientOptions,\n  takeRaw?: TakeRaw\n): Promise<ResponseBody> {\n  let parsedBody: any;\n  const contentType = response.headers.get('content-type')?.toLowerCase();\n  switch (true) {\n    case !!contentType?.includes('application/json'):\n      parsedBody = await deserializeJsonResponseBody(response, takeRaw);\n      break;\n    default:\n      throw new RpcError({\n        type: 'unsupported-content-type',\n        publicMessage: `Unsupported response content-type: '${contentType || 'none'}'`,\n      });\n  }\n  return parsedBody;\n}\n\nasync function deserializeJsonResponseBody(response: Response, takeRaw: TakeRaw | undefined) {\n  try {\n    const parsedBody = await response.json();\n    const rawEntries = parsedBody && typeof parsedBody === 'object' ? takeRaw?.(parsedBody) : undefined;\n    // kept out of the body, so the wire's returned-vs-thrown split survives\n    const extracted = extractThrownErrors(parsedBody);\n    if (extracted.platformError) return {[MION_ROUTES.platformError]: extracted.platformError};\n    let thrownErrors = extracted.thrownErrors;\n    const deserializedBody: ResponseBody = {};\n    Object.entries(parsedBody).forEach(([methodId, returnValue]) => {\n      const method = useMethodFns(methodId);\n      try {\n        deserializedBody[methodId] = parseHandlerJsonReturnValue(method, returnValue);\n      } catch (decodeError: any) {\n        // an unreadable answer is untyped: thrown, never the method's declared value\n        (thrownErrors ??= {})[methodId] = new RpcError({\n          type: 'deserialization-error',\n          publicMessage: `Invalid response from Route or Middleware '${method.id}', can not deserialize return value: ${decodeError.message}`,\n          errorData: decodeError?.errors,\n        });\n      }\n    });\n    if (thrownErrors) deserializedBody[MION_ROUTES.thrownErrors] = thrownErrors;\n    if (rawEntries) Object.assign(deserializedBody, rawEntries);\n    return deserializedBody;\n  } catch (err: any) {\n    throw new RpcError({\n      type: 'parsing-json-response-error',\n      publicMessage: `Invalid json response body: ${err?.message || 'unknown parsing error.'}`,\n    });\n  }\n}\n\n/** Takes [MION_ROUTES.thrownErrors] out WITHOUT flattening it into the body, so the returned-vs-thrown split\n * survives for error classification. Thrown errors are not strongly typed and deserialize as RpcError<string>. */\nfunction extractThrownErrors(parsedBody: any): {\n  platformError?: RpcError<string>;\n  thrownErrors?: Record<string, RpcError<string>>;\n} {\n  if (!(MION_ROUTES.thrownErrors in parsedBody)) return {};\n  const rawThrownErrors = parsedBody[MION_ROUTES.thrownErrors];\n  delete parsedBody[MION_ROUTES.thrownErrors];\n  // if platform error is present that means the router never executed (just the platform wrapper)\n  if (MION_ROUTES.platformError in rawThrownErrors) {\n    const globalErrorValue = rawThrownErrors[MION_ROUTES.platformError];\n    const platformError = isRpcError(globalErrorValue) ? new RpcError<string>(globalErrorValue) : globalErrorValue;\n    return {platformError};\n  }\n  // keyed by whatever the response says, so a `__proto__` key stays a plain entry\n  const thrownErrors: Record<string, RpcError<string>> = Object.create(null);\n  Object.entries(rawThrownErrors).forEach(([id, value]) => {\n    thrownErrors[id] = isRpcError(value) ? new RpcError<string>(value) : (value as RpcError<string>);\n  });\n  return {thrownErrors};\n}\n\nfunction getParamsWithoutHeadersSubset(params: any[]): any[] {\n  if (!params || params.length === 0) return [];\n  return params.slice(1);\n}\n\nfunction parseHandlerJsonReturnValue(method: MethodWithJitFns, returnValue: any): any {\n  if (!method.hasReturnData) return returnValue;\n  const {decode} = method.returnJitFns.json;\n  if (decode.isNoop || !returnValue) return returnValue;\n\n  if (returnValue instanceof RpcError) return returnValue;\n  if (isRpcError(returnValue)) return new RpcError(returnValue);\n  return decode.fn(returnValue);\n}\n"],"mappings":"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"}

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

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

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

@@ -1,19 +0,0 @@
-export type MetadataKind = 'm' | 'j' | 'p';
-export interface MetadataRecord {
-    baseURL: string;
-    kind: MetadataKind;
-    id: string;
-    json: string;
-    ts: number;
-}
-export type MetadataRecordKey = [MetadataKind, string];
-export interface MetadataStore {
-    readonly kind: string;
-    readAll(baseURL: string): Promise<MetadataRecord[]>;
-    write(records: MetadataRecord[]): Promise<void>;
-    remove(baseURL: string, keys: MetadataRecordKey[]): Promise<void>;
-    clear(baseURL?: string): Promise<void>;
-}
-export type MetadataStoreFactory = () => MetadataStore | undefined | Promise<MetadataStore | undefined>;
-export type StorageEngine = 'indexeddb' | 'memory' | MetadataStoreFactory;
-//# sourceMappingURL=storage.d.ts.map

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"typedEvent.cjs","names":[],"sources":["../../../../src/lib/typedEvent.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {RpcError} from '@mionjs/core';\nimport type {HandlersRegistry} from './handlersRegistry.ts';\nimport type {ErrorHandler, ErrorOfType, RequestHandler, ResponseHandler, SubRequest} from '../types.ts';\n\n/** Persistent hooks of one middleware: its params before each request, its result or error after it */\nexport class TypedEvent<S = void, E extends RpcError<string, any> = never, P extends any[] = any[]> {\n  constructor(\n    private readonly handlerId: string,\n    private readonly registry: HandlersRegistry,\n    private readonly createSubRequest?: (params: any[]) => SubRequest<any>\n  ) {}\n\n  /** Register a persistent handler that gives this middleware its params before every request that runs it */\n  onRequest(handler: RequestHandler<P>): TypedEvent<S, E, P> {\n    if (!this.createSubRequest) throw new Error(`onRequest needs the middleware from the client, '${this.handlerId}' has none`);\n    this.registry.registerRequest(this.handlerId, handler, this.createSubRequest);\n    return this;\n  }\n\n  /** Remove a previously registered request handler from HandlersRegistry */\n  offRequest(): TypedEvent<S, E, P> {\n    this.registry.unregisterRequest(this.handlerId);\n    return this;\n  }\n\n  /** Persistent handler for this middleware's successful result; every one registered runs, in order */\n  onResponse(handler: ResponseHandler<S>): TypedEvent<S, E, P> {\n    this.registry.registerResponse(this.handlerId, handler);\n    return this;\n  }\n\n  /** Remove this response handler; the others on this middleware stay */\n  offResponse(handler: ResponseHandler<S>): TypedEvent<S, E, P> {\n    this.registry.unregisterResponse(this.handlerId, handler);\n    return this;\n  }\n\n  /** Persistent error handler; every one registered for the type runs, in order */\n  onError<T extends E['type']>(errorType: T, handler: ErrorHandler<ErrorOfType<E, T>>): TypedEvent<S, E, P> {\n    this.registry.register(this.handlerId, errorType, handler as ErrorHandler<any>);\n    return this;\n  }\n\n  /** Remove this error handler; the others for the type stay */\n  offError<T extends E['type']>(errorType: T, handler: ErrorHandler<ErrorOfType<E, T>>): TypedEvent<S, E, P> {\n    this.registry.unregister(this.handlerId, errorType, handler as ErrorHandler<any>);\n    return this;\n  }\n\n  /** Get the handler ID this event is associated with */\n  getHandlerId(): string {\n    return this.handlerId;\n  }\n\n  /** Check if an error handler is registered for a specific error type */\n  hasErrorHandler(errorType: string): boolean {\n    return this.registry.hasHandler(this.handlerId, errorType);\n  }\n\n  /** Check if a response handler is registered */\n  hasResponseHandler(): boolean {\n    return this.registry.hasResponseHandler(this.handlerId);\n  }\n\n  /** Check if a request handler is registered */\n  hasRequestHandler(): boolean {\n    return this.registry.hasRequestHandler(this.handlerId);\n  }\n}\n"],"mappings":"mEAYA,IAAa,WAAb,KAAoG,CAE/E,UACA,SACA,iBAHnB,YACE,UACA,SACA,iBACA,CAHiB,KAAA,UAAA,UACA,KAAA,SAAA,SACA,KAAA,iBAAA,gBAChB,CAGH,UAAU,QAAiD,CACzD,GAAI,CAAC,KAAK,iBAAkB,MAAM,IAAI,MAAM,oDAAoD,KAAK,SAAA,YAAqB,EAC1H,YAAK,SAAS,gBAAgB,KAAK,UAAW,QAAS,KAAK,gBAAgB,EACrE,IACT,CAGA,YAAkC,CAChC,YAAK,SAAS,kBAAkB,KAAK,SAAS,EACvC,IACT,CAGA,WAAW,QAAkD,CAC3D,YAAK,SAAS,iBAAiB,KAAK,UAAW,OAAO,EAC/C,IACT,CAGA,YAAY,QAAkD,CAC5D,YAAK,SAAS,mBAAmB,KAAK,UAAW,OAAO,EACjD,IACT,CAGA,QAA6B,UAAc,QAA+D,CACxG,YAAK,SAAS,SAAS,KAAK,UAAW,UAAW,OAA4B,EACvE,IACT,CAGA,SAA8B,UAAc,QAA+D,CACzG,YAAK,SAAS,WAAW,KAAK,UAAW,UAAW,OAA4B,EACzE,IACT,CAGA,cAAuB,CACrB,OAAO,KAAK,SACd,CAGA,gBAAgB,UAA4B,CAC1C,OAAO,KAAK,SAAS,WAAW,KAAK,UAAW,SAAS,CAC3D,CAGA,oBAA8B,CAC5B,OAAO,KAAK,SAAS,mBAAmB,KAAK,SAAS,CACxD,CAGA,mBAA6B,CAC3B,OAAO,KAAK,SAAS,kBAAkB,KAAK,SAAS,CACvD,CACF"}

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"validation.cjs","names":[],"sources":["../../../../src/lib/validation.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {HeadersSubset, RpcError} from '@mionjs/core';\nimport {getMethod, useMethodFns} from './methods.ts';\nimport type {JitCompiledFunctions, RunTypeError, ValidationErrorData} from '@mionjs/core';\nimport type {CallContext, RequestErrors, SubRequest} from '../types.ts';\n\nexport function validateSubRequests(\n  subRequestIds: string[],\n  context: CallContext,\n  errors: RequestErrors,\n  validateRouteMiddlewares = true\n): void {\n  if (!context.options.validateParams) return;\n  subRequestIds.forEach((id) => {\n    const subRequest = context.subRequestList[id];\n    validateSubRequest(id, subRequest, errors);\n    const methodMeta = getMethod(id);\n    if (validateRouteMiddlewares && methodMeta?.middlewareIds?.length) {\n      const validMiddlewareIds = methodMeta.middlewareIds.filter((middlewareId) => middlewareId != null);\n      validateSubRequests(validMiddlewareIds, context, errors, validateRouteMiddlewares);\n    }\n  });\n  return;\n}\n\nexport function validateSubRequest(id: string, subRequest: SubRequest<any>, errors: RequestErrors): void {\n  if (subRequest?.error || subRequest?.isResolved) return;\n  // inputFrom params hold null placeholders the server fills after the source route runs\n  if (subRequest?.mappings && subRequest.mappings.length > 0) return;\n\n  const params = subRequest?.params || [];\n  const validationResponse = getTypeErrors(id, params);\n  if (!validationResponse) return;\n  const error = validationResponse;\n  errors.set(id, error);\n  if (subRequest) {\n    subRequest.error = error;\n    subRequest.isResolved = true;\n  }\n  return;\n}\n\n/** An answer the return type does not describe; undefined when it matches or the method returns nothing. */\nexport function getResponseError(id: string, value: unknown) {\n  const method = useMethodFns(id);\n  if (!method.hasReturnData) return;\n  if (method.headersReturn) {\n    // no header on the wire can be a valid void return\n    if (!(value instanceof HeadersSubset)) return;\n    const jitFns = method.headersReturn.jitFns as JitCompiledFunctions;\n    return checkValue(method.id, jitFns, value, 'response-validation-error', 'response-validation-error', 'headers from');\n  }\n  return checkValue(\n    method.id,\n    method.returnJitFns,\n    value,\n    'response-validation-error',\n    'response-validation-error',\n    'response from'\n  );\n}\n\nfunction getTypeErrors(id: string, params: any[]) {\n  const method = useMethodFns(id);\n  if (!method.paramsCount) return;\n  // No separate strict pass: the parser strategy's key check is compiled into isType.\n  return checkValue(method.id, method.paramsJitFns, params, 'validation-error', 'unexpected-validation-error', 'params for');\n}\n\n/** typeErrors runs only on a miss, and a validator that throws is reported, never raised. */\nfunction checkValue<Invalid extends string, Failed extends string>(\n  methodId: string,\n  jitFns: JitCompiledFunctions,\n  value: unknown,\n  invalidType: Invalid,\n  failedType: Failed,\n  subject: string\n): RpcError<Invalid, ValidationErrorData> | RpcError<Failed> | undefined {\n  if (jitFns.isType.isNoop) return;\n  try {\n    if (jitFns.isType.fn(value)) return;\n    return new RpcError<Invalid, ValidationErrorData>({\n      type: invalidType,\n      publicMessage: `Invalid ${subject} Route or Middleware '${methodId}', validation failed.`,\n      errorData: {typeErrors: jitFns.typeErrors.fn(value) as RunTypeError[]},\n    });\n  } catch (err: any) {\n    return new RpcError<Failed>({\n      type: failedType,\n      publicMessage: `Could not validate ${subject} Route or Middleware '${methodId}': ${err.message}`,\n    });\n  }\n}\n"],"mappings":"mKAYA,SAAgB,oBACd,cACA,QACA,OACA,yBAA2B,GACrB,CACD,QAAQ,QAAQ,gBACrB,cAAc,QAAS,IAAO,CAC5B,MAAM,WAAa,QAAQ,eAAe,EAAA,EAC1C,mBAAmB,GAAI,WAAY,MAAM,EACzC,MAAM,WAAa,wBAAA,UAAU,EAAE,EAC3B,0BAA4B,YAAY,eAAe,QAEzD,oBAD2B,WAAW,cAAc,OAAQ,cAAiB,cAAgB,IACzE,EAAoB,QAAS,OAAQ,wBAAwB,CAErF,CAAC,CAEH,CAEA,SAAgB,mBAAmB,GAAY,WAA6B,OAA6B,CAGvG,GAFI,YAAY,OAAS,YAAY,YAEjC,YAAY,UAAY,WAAW,SAAS,OAAS,EAAG,OAG5D,MAAM,mBAAqB,cAAc,GAD1B,YAAY,QAAU,CAAC,CACa,EACnD,GAAI,CAAC,mBAAoB,OACzB,MAAM,MAAQ,mBACd,OAAO,IAAI,GAAI,KAAK,EAChB,aACF,WAAW,MAAQ,MACnB,WAAW,WAAa,GAG5B,CAGA,SAAgB,iBAAiB,GAAY,MAAgB,CAC3D,MAAM,OAAS,wBAAA,aAAa,EAAE,EAC9B,GAAK,OAAO,cACZ,IAAI,OAAO,cAAe,CAExB,GAAI,EAAE,iBAAiB,aAAA,eAAgB,OACvC,MAAM,OAAS,OAAO,cAAc,OACpC,OAAO,WAAW,OAAO,GAAI,OAAQ,MAAO,4BAA6B,4BAA6B,cAAc,CACtH,CACA,OAAO,WACL,OAAO,GACP,OAAO,aACP,MACA,4BACA,4BACA,eACF,EACF,CAEA,SAAS,cAAc,GAAY,OAAe,CAChD,MAAM,OAAS,wBAAA,aAAa,EAAE,EAC9B,GAAK,OAAO,YAEZ,OAAO,WAAW,OAAO,GAAI,OAAO,aAAc,OAAQ,mBAAoB,8BAA+B,YAAY,CAC3H,CAGA,SAAS,WACP,SACA,OACA,MACA,YACA,WACA,QACuE,CACvE,GAAI,QAAO,OAAO,OAClB,GAAI,CACF,OAAI,OAAO,OAAO,GAAG,KAAK,EAAG,OACtB,IAAI,aAAA,SAAuC,CAChD,KAAM,YACN,cAAe,WAAW,OAAA,yBAAgC,QAAA,wBAC1D,UAAW,CAAC,WAAY,OAAO,WAAW,GAAG,KAAK,CAAmB,CACvE,CAAC,CACH,OAAS,IAAU,CACjB,OAAO,IAAI,aAAA,SAAiB,CAC1B,KAAM,WACN,cAAe,sBAAsB,OAAA,yBAAgC,QAAA,MAAc,IAAI,OAAA,EACzF,CAAC,CACH,CACF"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +0,0 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const require_src_batch=require("./batch.cjs");let _mionjs_core=require("@mionjs/core");var MionSubRequest=class{client;pointer;id;isResolved=!1;params;resolvedValue;error;serializedParams;mappings=[];constructor(parentProps,handlerId,argArray,client){this.client=client,this.pointer=[...parentProps],this.id=handlerId,this.params=argArray.map((arg,index)=>require_src_batch.isInputFromRef(arg)?(arg.toRequestId=this.id,arg.paramIndex=index,this.mappings.push(arg),null):arg)}call(setup,apiMetadata){return this.client.useBundledApi(apiMetadata),this.client.execute(this,void 0,void 0,setup?.signal,setup?.timeout)}typeErrors(apiMetadata){return this.client.useBundledApi(apiMetadata),this.client.typeErrors(this).catch(errors=>Promise.reject(findSubRequestError(this,errors)))}};function findSubRequestError(subRequest,errors){const specificError=errors.get(subRequest.id);if(specificError)return specificError;const firstError=errors.values().next().value;return firstError||new _mionjs_core.RpcError({type:"unknown-error",publicMessage:"An unknown error occurred"})}exports.MionSubRequest=MionSubRequest;exports.findSubRequestError=findSubRequestError;
-
-//# sourceMappingURL=subRequest.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"subRequest.cjs","names":[],"sources":["../../../src/subRequest.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {RpcError} from '@mionjs/core';\nimport type {RunTypeError} from '@mionjs/core';\nimport type {CallSetup, RequestErrors, RouteSubRequest, SubRequest} from './types.ts';\nimport type {InjectedApiMetadata} from './types.ts';\n\nimport type {InputFromRef} from '@mionjs/core';\nimport type {MionClient} from './client.ts';\nimport {isInputFromRef} from './batch.ts';\n\nexport class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RouteSubRequest<any> {\n  pointer: string[];\n  id: string;\n  isResolved: boolean = false;\n  params: any[];\n  resolvedValue?: S;\n  error?: E;\n  serializedParams?: any[];\n  mappings: InputFromRef[] = [];\n\n  constructor(\n    parentProps: string[],\n    handlerId: string,\n    argArray: any[],\n    readonly client: MionClient\n  ) {\n    this.pointer = [...parentProps];\n    this.id = handlerId;\n    this.params = argArray.map((arg, index) => {\n      if (isInputFromRef(arg)) {\n        arg.toRequestId = this.id;\n        arg.paramIndex = index;\n        this.mappings.push(arg);\n        return null;\n      }\n      return arg;\n    });\n  }\n\n  /** `apiMetadata` is filled by the build when routes are bundled, never by hand. */\n  call(setup?: CallSetup, apiMetadata?: InjectedApiMetadata): Promise<any> {\n    this.client.useBundledApi(apiMetadata);\n    return this.client.execute(this as unknown as RouteSubRequest<any>, undefined, undefined, setup?.signal, setup?.timeout);\n  }\n\n  /** `apiMetadata` is filled by the build when routes are bundled, never by hand. */\n  typeErrors(apiMetadata?: InjectedApiMetadata): Promise<RunTypeError[]> {\n    this.client.useBundledApi(apiMetadata);\n    return this.client\n      .typeErrors(this as SubRequest<any>)\n      .catch((errors: RequestErrors) => Promise.reject(findSubRequestError(this, errors)));\n  }\n}\n\n/** Finds the most relevant error from the errors map for a given sub-request */\nexport function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string> {\n  const specificError = errors.get(subRequest.id);\n  if (specificError) return specificError;\n\n  const firstError = errors.values().next().value;\n  if (firstError) return firstError;\n\n  return new RpcError({\n    type: 'unknown-error',\n    publicMessage: 'An unknown error occurred',\n  });\n}\n"],"mappings":"2JAgBA,IAAa,eAAb,KAA4G,CAc/F,OAbX,QACA,GACA,WAAsB,GACtB,OACA,cACA,MACA,iBACA,SAA2B,CAAC,EAE5B,YACE,YACA,UACA,SACA,OACA,CADS,KAAA,OAAA,OAET,KAAK,QAAU,CAAC,GAAG,WAAW,EAC9B,KAAK,GAAK,UACV,KAAK,OAAS,SAAS,IAAA,CAAK,IAAK,QAC3B,kBAAA,eAAe,GAAG,GACpB,IAAI,YAAc,KAAK,GACvB,IAAI,WAAa,MACjB,KAAK,SAAS,KAAK,GAAG,EACf,MAEF,GACR,CACH,CAGA,KAAK,MAAmB,YAAiD,CACvE,YAAK,OAAO,cAAc,WAAW,EAC9B,KAAK,OAAO,QAAQ,KAAyC,OAAW,OAAW,OAAO,OAAQ,OAAO,OAAO,CACzH,CAGA,WAAW,YAA4D,CACrE,YAAK,OAAO,cAAc,WAAW,EAC9B,KAAK,OACT,WAAW,IAAuB,EAClC,MAAO,QAA0B,QAAQ,OAAO,oBAAoB,KAAM,MAAM,CAAC,CAAC,CACvF,CACF,EAGA,SAAgB,oBAAoB,WAA6B,OAAyC,CACxG,MAAM,cAAgB,OAAO,IAAI,WAAW,EAAE,EAC9C,GAAI,cAAe,OAAO,cAE1B,MAAM,WAAa,OAAO,OAAO,EAAE,KAAK,EAAE,MAC1C,OAAI,YAEG,IAAI,aAAA,SAAS,CAClB,KAAM,gBACN,cAAe,2BACjB,CAAC,CACH"}

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

@@ -1,19 +0,0 @@
-import { RpcError, RunTypeError, InputFromRef } from '@mionjs/core';
-import { CallSetup, RequestErrors, RouteSubRequest, SubRequest, InjectedApiMetadata } from './types.ts';
-import { MionClient } from './client.ts';
-export declare class MionSubRequest<S = any, E extends RpcError<string, any> = any> implements RouteSubRequest<any> {
-    readonly client: MionClient;
-    pointer: string[];
-    id: string;
-    isResolved: boolean;
-    params: any[];
-    resolvedValue?: S;
-    error?: E;
-    serializedParams?: any[];
-    mappings: InputFromRef[];
-    constructor(parentProps: string[], handlerId: string, argArray: any[], client: MionClient);
-    call(setup?: CallSetup, apiMetadata?: InjectedApiMetadata): Promise<any>;
-    typeErrors(apiMetadata?: InjectedApiMetadata): Promise<RunTypeError[]>;
-}
-export declare function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string>;
-//# sourceMappingURL=subRequest.d.ts.map

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

@@ -1,155 +0,0 @@
-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';
-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 BatchResult<Routes extends RouteSubRequest<any>[]> = {
-    [K in keyof Routes]: Routes[K] extends RouteSubRequest<any> ? Awaited<ReturnType<Routes[K]['call']>> : never;
-};
-export type ClientFetchOptions = Omit<RequestInit, 'method' | 'body' | 'signal'>;
-export interface ClientOptions {
-    baseURL: string;
-    basePath: string;
-    suffix: string;
-    fetchOptions: ClientFetchOptions;
-    validateParams: boolean;
-    validateServerResponses: boolean;
-    sanitizeParams: boolean;
-    storageEngine: StorageEngine;
-    timeout?: number;
-}
-export type InjectedApiMetadata = InjectApiMetadata<RemoteApi, string>;
-type PublicHandler = (...args: any[]) => Promise<any>;
-type PublicMethod = PublicRoute | PublicMiddleware | PublicHeadersMiddleware;
-type ExtractHandler<PM extends PublicMethod> = PM extends {
-    handler: infer H;
-} ? H : never;
-export type InitClientOptions = Partial<ClientOptions> & {
-    baseURL: string;
-};
-export type RequestHeaders = {
-    [key: string]: string;
-};
-export type RequestBody = {
-    [key: string]: any[];
-};
-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 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>>;
-export type HandlerFailResponse<PH extends PublicHandler> = Extract<HandlerResponse<PH>, RpcError<string>>;
-export type SuccessResponse<MR extends SubRequest<any>> = Required<MR>['resolvedValue'];
-export type SuccessResponses<List extends SubRequest<any>[]> = {
-    [P in keyof List]: SuccessResponse<List[P]>;
-};
-export type FailResponse<MR extends SubRequest<any>> = Required<MR>['error'];
-export type FailResponses<List extends SubRequest<any>[]> = {
-    [P in keyof List]: FailResponse<List[P]>;
-};
-export type RequestErrors = Map<string, RpcError<string>>;
-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, Id extends string = string> {
-    pointer: string[];
-    id: Id;
-    isResolved: boolean;
-    params: Parameters<PH>;
-    resolvedValue?: HandlerSuccessResponse<PH>;
-    error?: HandlerFailResponse<PH>;
-    serializedParams?: any[];
-    mappings?: InputFromRef[];
-}
-export interface CallSetup {
-    signal?: AbortSignal;
-    timeout?: number;
-}
-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, 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 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 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 NonClientMiddleware = RouteLeaf | {
-    [key: string]: RouteLeaf;
-};
-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];
-};
-export type SuccessClientResponse<RS extends RouteSubRequest<any>, RHList extends MiddlewareSubRequest<any>[]> = [
-    SuccessResponse<RS>,
-    ...SuccessResponses<RHList>
-];
-export {};
-//# sourceMappingURL=types.d.ts.map