@mionjs/client 0.8.10 → 0.13.2

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

@@ -0,0 +1,152 @@
+import { DEFAULT_STORAGE_ENGINE, STORAGE_KEY } from "../constants.js";
+var STORE_GLOBAL_KEY = "__mion_metadata_store__", OBJECT_STORE = "metadata", DB_VERSION = 1, OPEN_TIMEOUT_MS = 3e3, MemoryMetadataStore = class {
+  kind = "memory";
+  records = /* @__PURE__ */ 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 ?? /* @__PURE__ */ new Error("mion metadata cache transaction aborted")), transaction.onerror = () => reject(transaction.error ?? /* @__PURE__ */ 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(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: /* @__PURE__ */ new Map() }, globalThis[STORE_GLOBAL_KEY] = registry), registry;
+}
+function getMetadataStore(engine = 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(() => {
+  });
+}
+export {
+  IdbMetadataStore,
+  MemoryMetadataStore,
+  getMetadataStore,
+  resetMetadataStore,
+  setMetadataStoreForTesting
+};
+
+//# sourceMappingURL=metadataStore.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadataStore.js","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/esm/src/lib/methods.d.ts

@@ -0,0 +1,15 @@
+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/esm/src/lib/methods.js

@@ -0,0 +1,41 @@
+var bundledMethods = /* @__PURE__ */ 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();
+}
+export {
+  bundledMethodIds,
+  getMethod,
+  hasMethod,
+  isBundledMethod,
+  resetBundledMethods,
+  setBundledMethod,
+  setFetchedMethods,
+  useMethodFns
+};
+
+//# sourceMappingURL=methods.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"methods.js","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":"AAoBA,IAAM,iBAAiB,oBAAI,IAAqC,GAC5D;AAEJ,SAAgB,UAAU,IAAqB;AAC7C,SAAO,eAAe,IAAI,EAAE,KAAK,gBAAgB,YAAY,EAAE,MAAM;AACvE;AAEA,SAAgB,UAAU,IAA2C;AACnE,SAAO,eAAe,IAAI,EAAE,KAAK,gBAAgB,YAAY,EAAE;AACjE;AAGA,SAAgB,aAAa,IAAqC;AAChE,QAAM,UAAU,eAAe,IAAI,EAAE;AACrC,MAAI,QAAS,QAAO;AACpB,QAAM,UAAU,gBAAgB,gBAAgB,EAAE;AAClD,MAAI,CAAC,QAAS,OAAM,IAAI,MAAM,8BAA8B,EAAA,YAAc;AAC1E,SAAO;AACT;AAGA,SAAgB,iBAAiB,IAAY,OAAsC;AACjF,iBAAe,IAAI,IAAI,KAAK;AAC9B;AAEA,SAAgB,gBAAgB,IAAqB;AACnD,SAAO,eAAe,IAAI,EAAE;AAC9B;AAGA,SAAgB,mBAA6B;AAC3C,SAAO,CAAC,GAAG,eAAe,KAAK,CAAC;AAClC;AAGA,SAAgB,kBAAkB,SAA+B;AAC/D,mBAAiB;AACnB;AAGA,SAAgB,sBAA4B;AAC1C,iBAAe,MAAM;AACvB"}

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

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

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

@@ -0,0 +1,26 @@
+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;
+  }
+}
+export {
+  requestPersistenceWhenSilent,
+  requestPersistentStorage
+};
+
+//# sourceMappingURL=persistentStorage.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persistentStorage.js","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":"AAWA,eAAsB,2BAA6C;AACjE,QAAM,UAAU,WAAW,WAAW;AACtC,MAAI,CAAC,SAAS,QAAS,QAAO;AAC9B,MAAI;AACF,WAAI,MAAM,QAAQ,YAAY,IAAU,KACjC,MAAM,QAAQ,QAAQ;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKA,eAAsB,+BAAiD;AACrE,QAAM,UAAU,WAAW,WAAW;AACtC,MAAI,CAAC,SAAS,WAAW,CAAC,QAAQ,UAAW,QAAO;AACpD,MAAI;AACF,QAAI,MAAM,QAAQ,UAAU,EAAG,QAAO;AACtC,UAAM,cAAc,WAAW,WAAW;AAG1C,WAFI,CAAC,aAAa,UAEd,MADiB,YAAY,MAAM,EAAC,MAAM,qBAAsC,CAAC,GAC1E,UAAU,YAAkB,KAChC,MAAM,QAAQ,QAAQ;AAAA,EAC/B,QAAQ;AAEN,WAAO;AAAA,EACT;AACF"}

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

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

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

@@ -0,0 +1,25 @@
+import { hasMethod, useMethodFns } from "./methods.js";
+import { HandlerType } from "@mionjs/core";
+var sanitizedParams = /* @__PURE__ */ 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 || !hasMethod(id)) continue;
+      const method = useMethodFns(id), formatTransform = method.paramsJitFns.formatTransform;
+      if (!method.options?.sanitizeParams || !method.paramsCount || !formatTransform || formatTransform.isNoop) continue;
+      const isHeadersMiddleware = method.type === 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 {
+      }
+    }
+}
+export {
+  sanitizeSubRequests
+};
+
+//# sourceMappingURL=sanitize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.js","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":";;AAYA,IAAM,kBAAkB,oBAAI,QAAe;AAG3C,SAAgB,oBAAoB,eAAyB,SAA4B;AACvF,MAAK,QAAQ,QAAQ;AACrB,eAAW,MAAM,eAAe;AAC9B,YAAM,aAAa,QAAQ,eAAe,EAAA;AAC1C,UAAI,CAAC,cAAc,WAAW,cAAc,WAAW,MAAO;AAC9D,YAAM,SAAS,WAAW;AAI1B,UAHI,CAAC,MAAM,QAAQ,MAAM,KAAK,gBAAgB,IAAI,MAAM,KAEpD,WAAW,YAAY,WAAW,SAAS,SAAS,KACpD,CAAC,UAAU,EAAE,EAAG;AACpB,YAAM,SAAS,aAAa,EAAE,GACxB,kBAAkB,OAAO,aAAa;AAC5C,UAAI,CAAC,OAAO,SAAS,kBAAkB,CAAC,OAAO,eAAe,CAAC,mBAAmB,gBAAgB,OAAQ;AAE1G,YAAM,sBAAsB,OAAO,SAAS,YAAY,qBAAqB,CAAC,CAAC,OAAO,cAChF,OAAO,sBAAsB,OAAO,MAAM,CAAC,IAAI;AACrD,UAAI;AACF,cAAM,YAAY,gBAAgB,GAAG,IAAI;AACzC,mBAAW,SAAS,sBAAsB,CAAC,OAAO,CAAA,GAAI,GAAG,SAAS,IAAI,WACtE,gBAAgB,IAAI,WAAW,MAAM;AAAA,MACvC,QAAQ;AAAA,MAER;AAAA,IACF;AACF"}

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

@@ -1,12 +1,14 @@
 import { ResponseBody } from '@mionjs/router';
-import { MionClientRequest } from '../request.ts';
-import { ClientOptions } from '../types.ts';
-export type SerializedBody = string | Uint8Array;
-export type ContentType = 'application/json; charset=utf-8' | 'application/octet-stream';
+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(req: MionClientRequest<any, any>): SerializedRequest;
-export declare function deserializeResponseBody(response: Response, options: ClientOptions): Promise<ResponseBody>;
+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/esm/src/lib/serializer.js

@@ -1,42 +1,23 @@
-import { RpcError, deserializeBinaryBody, MION_ROUTES, routesCache, HandlerType, serializeBinaryBody as serializeBinaryBody$1, isRpcError } from "@mionjs/core";
-import { DEFAULT_PREFILL_OPTIONS } from "../constants.js";
-import { extractAndProcessMetadata } from "./clientMethodsMetadata.js";
-function serializeRequestBody(req) {
-  const serializerMode = getSerializerMode(req);
-  switch (serializerMode) {
-    case "json":
-    case "stringifyJson":
-      return {
-        body: serializeJsonBody(req),
-        contentType: "application/json; charset=utf-8"
-      };
-    case "optimistic":
-      return {
-        body: serializeJSonBodyOptimistic(req),
-        contentType: "application/json; charset=utf-8"
-      };
-    case "binary":
-      return {
-        body: serializeBinaryBody(req),
-        contentType: "application/octet-stream"
-      };
-    default:
-      throw new Error(`Invalid serializer mode ${serializerMode}`);
-  }
+import { useMethodFns } from "./methods.js";
+import { hasHeadersSubsetParam } from "./headers.js";
+import { HandlerType, MION_ROUTES, RpcError, isRpcError } from "@mionjs/core";
+function serializeRequestBody(context, optimistic = !1) {
+  return {
+    body: optimistic ? serializeJSonBodyOptimistic(context) : serializeJsonBody(context),
+    contentType: "application/json; charset=utf-8"
+  };
 }
-function serializeJsonBody(req) {
-  const props = [], subRequestIds = Object.keys(req.subRequestList);
+function serializeJsonBody(context) {
+  const props = [], subRequestIds = Object.keys(context.subRequestList);
   for (let i = 0; i < subRequestIds.length; i++) {
-    const id = subRequestIds[i], subRequest = req.subRequestList[id];
-    if (!subRequest)
-      continue;
+    const id = subRequestIds[i], subRequest = context.subRequestList[id];
+    if (!subRequest) continue;
     let params = subRequest.params;
-    const method = routesCache.useMethodJitFns(id);
-    method.type === HandlerType.headersMiddleFn && method.headersParam && (params = getParamsWithoutHeadersSubset(params));
+    const method = useMethodFns(id);
+    method.type === HandlerType.headersMiddleware && method.headersParam && (params = getParamsWithoutHeadersSubset(params));
     try {
-      const jsonValue = stringifyHandlerParams(method, params);
-      if (!jsonValue)
-        continue;
+      const jsonValue = stringifyHandlerParams(method, params, context.options.validateParams);
+      if (!jsonValue) continue;
       props.push(`${JSON.stringify(id)}:${jsonValue}`);
     } catch (e) {
       throw new RpcError({
@@ -48,60 +29,61 @@ function serializeJsonBody(req) {
   }
   return `{${props.join(",")}}`;
 }
-function serializeJSonBodyOptimistic(req) {
-  const body = {}, subRequestIds = Object.keys(req.subRequestList);
+function serializeJSonBodyOptimistic(context) {
+  const body = {}, subRequestIds = Object.keys(context.subRequestList);
   for (const id of subRequestIds) {
-    const subRequest = req.subRequestList[id];
-    subRequest && (body[id] = subRequest.params);
+    const subRequest = context.subRequestList[id];
+    if (!subRequest) continue;
+    const params = hasHeadersSubsetParam(id, subRequest.params) ? getParamsWithoutHeadersSubset(subRequest.params) : subRequest.params;
+    params?.length && (body[id] = params);
   }
-  return JSON.stringify(body);
+  return JSON.stringify(body, wireFormReplacer);
 }
-function serializeBinaryBody(req) {
-  const subRequestIds = Object.keys(req.subRequestList), body = {}, executionChain = [];
-  for (const id of subRequestIds) {
-    let params = req.subRequestList[id].params;
-    const method = routesCache.useMethodJitFns(id);
-    method.type === HandlerType.headersMiddleFn && method.headersParam && (params = getParamsWithoutHeadersSubset(params)), body[id] = params, executionChain.push(method);
+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);
   }
-  const workflowRouteIds = req.workflowSubRequests?.map((sr) => sr.id), { buffer } = serializeBinaryBody$1(req.path, executionChain, body, !1, workflowRouteIds);
-  return new Uint8Array(buffer);
 }
-function stringifyHandlerParams(method, params) {
-  if (!method.paramNames || method.paramNames.length === 0)
-    return "";
-  const paramsJit = method.paramsJitFns;
-  return paramsJit.prepareForJson.isNoop ? JSON.stringify(params) : paramsJit.stringifyJson.fn(params);
+function wireFormReplacer(key, value) {
+  return value instanceof Map ? [...value] : value instanceof Set ? [...value] : typeof value == "bigint" ? value.toString() : value;
 }
-async function deserializeResponseBody(response, options) {
+async function deserializeResponseBody(response, options, takeRaw) {
   let parsedBody;
   const contentType = response.headers.get("content-type")?.toLowerCase();
-  switch (!0) {
-    case !!contentType?.includes("application/json"):
-      parsedBody = await deserializeJsonResponseBody(response, options);
-      break;
-    case !!contentType?.includes("application/octet-stream"):
-      parsedBody = await deserializeBinaryResponseBody(response);
-      break;
-    default:
-      throw new RpcError({
-        type: "unsupported-content-type",
-        publicMessage: `Unsupported response content-type: '${contentType || "none"}'`
-      });
-  }
+  if (!0 === !!contentType?.includes("application/json"))
+    parsedBody = await deserializeJsonResponseBody(response, takeRaw);
+  else
+    throw new RpcError({
+      type: "unsupported-content-type",
+      publicMessage: `Unsupported response content-type: '${contentType || "none"}'`
+    });
   return parsedBody;
 }
-async function deserializeJsonResponseBody(response, options) {
+async function deserializeJsonResponseBody(response, takeRaw) {
   try {
-    const parsedBody = await response.json();
-    extractAndProcessMetadata(MION_ROUTES.methodsMetadata, parsedBody, options), extractAndProcessMetadata(MION_ROUTES.methodsMetadataById, parsedBody, options);
-    const platformError = unwrapUnexpectedErrors(parsedBody);
-    if (platformError)
-      return { [MION_ROUTES.platformError]: platformError };
+    const parsedBody = await response.json(), rawEntries = parsedBody && typeof parsedBody == "object" ? takeRaw?.(parsedBody) : void 0, extracted = extractThrownErrors(parsedBody);
+    if (extracted.platformError) return { [MION_ROUTES.platformError]: extracted.platformError };
+    let thrownErrors = extracted.thrownErrors;
     const deserializedBody = {};
     return Object.entries(parsedBody).forEach(([methodId, returnValue]) => {
-      const method = routesCache.useMethodJitFns(methodId);
-      deserializedBody[methodId] = parseHandlerJsonReturnValue(method, returnValue);
-    }), deserializedBody;
+      const method = useMethodFns(methodId);
+      try {
+        deserializedBody[methodId] = parseHandlerJsonReturnValue(method, returnValue);
+      } catch (decodeError) {
+        (thrownErrors ??= {})[methodId] = new 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[MION_ROUTES.thrownErrors] = thrownErrors), rawEntries && Object.assign(deserializedBody, rawEntries), deserializedBody;
   } catch (err) {
     throw new RpcError({
       type: "parsing-json-response-error",
@@ -109,47 +91,30 @@ async function deserializeJsonResponseBody(response, options) {
     });
   }
 }
-async function deserializeBinaryResponseBody(response) {
-  const arrayBuffer = await response.arrayBuffer(), { body } = deserializeBinaryBody("client-response", arrayBuffer, !0), platformError = unwrapUnexpectedErrors(body);
-  return platformError ? { [MION_ROUTES.platformError]: platformError } : body;
-}
-function unwrapUnexpectedErrors(parsedBody) {
-  if (!(MION_ROUTES.thrownErrors in parsedBody))
-    return;
-  const unexpectedErrors = parsedBody[MION_ROUTES.thrownErrors];
-  if (MION_ROUTES.platformError in unexpectedErrors) {
-    const globalErrorValue = unexpectedErrors[MION_ROUTES.platformError];
-    return isRpcError(globalErrorValue) ? new RpcError(globalErrorValue) : globalErrorValue;
+function extractThrownErrors(parsedBody) {
+  if (!(MION_ROUTES.thrownErrors in parsedBody)) return {};
+  const rawThrownErrors = parsedBody[MION_ROUTES.thrownErrors];
+  if (delete parsedBody[MION_ROUTES.thrownErrors], MION_ROUTES.platformError in rawThrownErrors) {
+    const globalErrorValue = rawThrownErrors[MION_ROUTES.platformError];
+    return { platformError: isRpcError(globalErrorValue) ? new RpcError(globalErrorValue) : globalErrorValue };
   }
-  Object.assign(parsedBody, unexpectedErrors), delete parsedBody[MION_ROUTES.thrownErrors];
-}
-function getSerializerMode(req) {
-  if (req.options.serializer === "optimistic")
-    return Object.keys(req.subRequestList).every((id) => routesCache.hasMetadata(id)) ? "stringifyJson" : "optimistic";
-  const methodId = req.route?.id ?? req.workflowSubRequests?.[0]?.id, serializerMode = routesCache.getMethodJitFns(methodId)?.options.serializer || DEFAULT_PREFILL_OPTIONS.serializer;
-  return serializerMode === "json" ? DEFAULT_PREFILL_OPTIONS.serializer : serializerMode;
+  const thrownErrors = /* @__PURE__ */ Object.create(null);
+  return Object.entries(rawThrownErrors).forEach(([id, value]) => {
+    thrownErrors[id] = isRpcError(value) ? new 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 returnJit = method.returnJitFns;
-  if (returnJit.restoreFromJson.isNoop || !returnValue)
-    return returnValue;
-  try {
-    return returnValue instanceof RpcError ? returnValue : isRpcError(returnValue) ? new RpcError(returnValue) : returnJit.restoreFromJson.fn(returnValue);
-  } catch (e) {
-    return new RpcError({
-      type: "deserialization-error",
-      publicMessage: `Invalid response from Route or MiddleFn '${method.id}', can not deserialize return value: ${e.message}`,
-      errorData: e?.errors
-    });
-  }
+  if (!method.hasReturnData) return returnValue;
+  const { decode } = method.returnJitFns.json;
+  return decode.isNoop || !returnValue || returnValue instanceof RpcError ? returnValue : isRpcError(returnValue) ? new RpcError(returnValue) : decode.fn(returnValue);
 }
 export {
   deserializeResponseBody,
-  serializeRequestBody
+  serializeRequestBody,
+  wireFormReplacer
 };
-//# sourceMappingURL=serializer.js.map
+
+//# sourceMappingURL=serializer.js.map