@mionjs/client 0.8.10 → 0.13.2

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

@@ -0,0 +1,52 @@
+import { isBundledMethod, resetBundledMethods, setBundledMethod } from "./methods.js";
+import { HandlerType, RpcError, getHeadersReflectionFromMarkers, getReflectionFromMarkers } from "@mionjs/core";
+var pendingPayloadError;
+function registerBundledApi(payload) {
+  if (!isBundledApiPayload(payload)) {
+    pendingPayloadError = new RpcError({
+      type: "bundle-api-invalid-payload",
+      publicMessage: "The bundled API metadata injected at this call is not what the build writes; rebuild with a matching @mionjs/devtools."
+    }), console.error("[mion] bundled API payload rejected at a dispatch point; rebuild with a matching @mionjs/devtools");
+    return;
+  }
+  for (const method of payload.methods)
+    isBundledMethod(method.id) || setBundledMethod(method.id, bundledMethodToCacheEntry(method));
+}
+function takeBundledApiError() {
+  const error = pendingPayloadError;
+  return pendingPayloadError = void 0, error;
+}
+function resetBundledApi() {
+  resetBundledMethods(), pendingPayloadError = void 0;
+}
+function isBundledApiPayload(value) {
+  if (typeof value != "object" || value === null) return !1;
+  const methods = value.methods;
+  return Array.isArray(methods) && methods.every(isBundledMethodRow);
+}
+function isBundledMethodRow(value) {
+  if (typeof value != "object" || value === null) return !1;
+  const method = value;
+  return typeof method.id == "string" && typeof method.type == "number" && typeof method.nestLevel == "number" && typeof method.isAsync == "boolean" && Array.isArray(method.pointer) && typeof method.options == "object" && method.options !== null && typeof method.rtFns == "object" && method.rtFns !== null;
+}
+var noHandler = () => {
+};
+function bundledMethodToCacheEntry(method) {
+  const entry = {
+    ...method.type === HandlerType.headersMiddleware ? getHeadersReflectionFromMarkers(method.rtFns, noHandler, method.id) : getReflectionFromMarkers(method.rtFns, noHandler, method.id),
+    type: method.type,
+    id: method.id,
+    pointer: method.pointer,
+    nestLevel: method.nestLevel,
+    isAsync: method.isAsync,
+    options: method.options
+  };
+  return delete entry.paramsJsonMaxBytes, method.middlewareIds && method.middlewareIds.length && (entry.middlewareIds = method.middlewareIds), entry;
+}
+export {
+  registerBundledApi,
+  resetBundledApi,
+  takeBundledApiError
+};
+
+//# sourceMappingURL=bundledApi.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bundledApi.js","names":[],"sources":["../../../../src/lib/bundledApi.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 {\n  HandlerType,\n  RpcError,\n  getHeadersReflectionFromMarkers,\n  getReflectionFromMarkers,\n  type MethodWithOptions,\n  type MethodWithOptsAndJitFns,\n  type RtMarkerPayload,\n} from '@mionjs/core';\nimport type {InjectedApiMetadata} from '../types.ts';\nimport {isBundledMethod, resetBundledMethods, setBundledMethod} from './methods.ts';\n\n// With bundled routes the build injects, at each dispatch point, the route and its middlewares with the server's\n// compiled functions. Registering one runs the router's initRoutes reflection, so it looks exactly like a fetched one.\n\n/** One method of a bundled payload: the `MethodWithOptions` members the build can answer from the API type,\n *  plus the marker payload. The rest (jit hashes, arity, header names) comes from the reflection instead. */\nexport interface BundledMethod extends Pick<\n  MethodWithOptions,\n  'id' | 'pointer' | 'nestLevel' | 'type' | 'isAsync' | 'options' | 'middlewareIds'\n> {\n  rtFns: RtMarkerPayload;\n}\n\n/** What the build injects at a dispatch point: the method called plus every middleware in its chain. */\nexport interface BundledApiPayload {\n  methods: BundledMethod[];\n}\n\n/** A payload the build did not write, held until a call can report it once. */\nlet pendingPayloadError: RpcError<string> | undefined;\n\n/** Registers a bundled payload, once per method id; a dispatch point passes the same module on every call.\n *  The guard runs despite the declared type because a `<genDir>/api/` tree from another @mionjs/devtools\n *  version can disagree; a payload it did not write is recorded, never thrown, since `call()` never throws. */\nexport function registerBundledApi(payload: InjectedApiMetadata): void {\n  if (!isBundledApiPayload(payload)) {\n    pendingPayloadError = new RpcError({\n      type: 'bundle-api-invalid-payload',\n      publicMessage:\n        'The bundled API metadata injected at this call is not what the build writes; rebuild with a matching @mionjs/devtools.',\n    });\n    console.error('[mion] bundled API payload rejected at a dispatch point; rebuild with a matching @mionjs/devtools');\n    return;\n  }\n  for (const method of payload.methods) {\n    if (isBundledMethod(method.id)) continue;\n    setBundledMethod(method.id, bundledMethodToCacheEntry(method));\n  }\n}\n\n/** Takes the last rejected payload, if any, so a call can report it once. */\nexport function takeBundledApiError(): RpcError<string> | undefined {\n  const error = pendingPayloadError;\n  pendingPayloadError = undefined;\n  return error;\n}\n\n/** Forgets which ids came from a bundle. Tests only. */\nexport function resetBundledApi(): void {\n  resetBundledMethods();\n  pendingPayloadError = undefined;\n  // the bundled flag stays: the build's module sets it once at import, and a cache reset cannot change the build\n}\n\nfunction isBundledApiPayload(value: unknown): value is BundledApiPayload {\n  if (typeof value !== 'object' || value === null) return false;\n  const methods = (value as BundledApiPayload).methods;\n  return Array.isArray(methods) && methods.every(isBundledMethodRow);\n}\n\n/** Every member the cache entry reads, so a stale module fails the guard instead of a later access. */\nfunction isBundledMethodRow(value: unknown): value is BundledMethod {\n  if (typeof value !== 'object' || value === null) return false;\n  const method = value as BundledMethod;\n  return (\n    typeof method.id === 'string' &&\n    typeof method.type === 'number' &&\n    typeof method.nestLevel === 'number' &&\n    typeof method.isAsync === 'boolean' &&\n    Array.isArray(method.pointer) &&\n    typeof method.options === 'object' &&\n    method.options !== null &&\n    typeof method.rtFns === 'object' &&\n    method.rtFns !== null\n  );\n}\n\n/** A bundled method never carries a handler; the reflection reads everything off the marker payload\n *  and the row, so the placeholder is never called. */\nconst noHandler = () => undefined;\n\nfunction bundledMethodToCacheEntry(method: BundledMethod): MethodWithOptsAndJitFns {\n  const reflection =\n    method.type === HandlerType.headersMiddleware\n      ? getHeadersReflectionFromMarkers(method.rtFns, noHandler, method.id)\n      : getReflectionFromMarkers(method.rtFns, noHandler, method.id);\n  // spread, like `registerRoutes` does on the server, so a member added to the reflection reaches\n  // a bundled method too; only the row's own answers are written over it\n  const entry: MethodWithOptsAndJitFns = {\n    ...reflection,\n    type: method.type,\n    id: method.id,\n    pointer: method.pointer,\n    nestLevel: method.nestLevel,\n    // the build answered this off the server handler's declared return; the placeholder above cannot\n    isAsync: method.isAsync,\n    // `options.maxBodySize` is the route's own declared limit or nothing: the number the server\n    // settles for a chain that declares none (its types times the router factor, else the platform\n    // adapter's) is only known at the server's registration, and the client never enforces it\n    options: method.options,\n  };\n  // the params byte ceiling is the SERVER's: it settles a chain's request limit once at\n  // registration. The client enforces no limit, and the fetched lane is never sent it either\n  delete entry.paramsJsonMaxBytes;\n  if (method.middlewareIds && method.middlewareIds.length) entry.middlewareIds = method.middlewareIds;\n  return entry;\n}\n"],"mappings":";;AAqCA,IAAI;AAKJ,SAAgB,mBAAmB,SAAoC;AACrE,MAAI,CAAC,oBAAoB,OAAO,GAAG;AACjC,0BAAsB,IAAI,SAAS;AAAA,MACjC,MAAM;AAAA,MACN,eACE;AAAA,IACJ,CAAC,GACD,QAAQ,MAAM,mGAAmG;AACjH;AAAA,EACF;AACA,aAAW,UAAU,QAAQ;AAC3B,IAAI,gBAAgB,OAAO,EAAE,KAC7B,iBAAiB,OAAO,IAAI,0BAA0B,MAAM,CAAC;AAEjE;AAGA,SAAgB,sBAAoD;AAClE,QAAM,QAAQ;AACd,+BAAsB,QACf;AACT;AAGA,SAAgB,kBAAwB;AACtC,sBAAoB,GACpB,sBAAsB;AAExB;AAEA,SAAS,oBAAoB,OAA4C;AACvE,MAAI,OAAO,SAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,UAAW,MAA4B;AAC7C,SAAO,MAAM,QAAQ,OAAO,KAAK,QAAQ,MAAM,kBAAkB;AACnE;AAGA,SAAS,mBAAmB,OAAwC;AAClE,MAAI,OAAO,SAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,SAAS;AACf,SACE,OAAO,OAAO,MAAO,YACrB,OAAO,OAAO,QAAS,YACvB,OAAO,OAAO,aAAc,YAC5B,OAAO,OAAO,WAAY,aAC1B,MAAM,QAAQ,OAAO,OAAO,KAC5B,OAAO,OAAO,WAAY,YAC1B,OAAO,YAAY,QACnB,OAAO,OAAO,SAAU,YACxB,OAAO,UAAU;AAErB;AAIA,IAAM,YAAA,MAAA;AAAA;AAEN,SAAS,0BAA0B,QAAgD;AAOjF,QAAM,QAAiC;AAAA,IACrC,GANA,OAAO,SAAS,YAAY,oBACxB,gCAAgC,OAAO,OAAO,WAAW,OAAO,EAAE,IAClE,yBAAyB,OAAO,OAAO,WAAW,OAAO,EAAE;AAAA,IAK/D,MAAM,OAAO;AAAA,IACb,IAAI,OAAO;AAAA,IACX,SAAS,OAAO;AAAA,IAChB,WAAW,OAAO;AAAA,IAElB,SAAS,OAAO;AAAA,IAIhB,SAAS,OAAO;AAAA,EAClB;AAGA,gBAAO,MAAM,oBACT,OAAO,iBAAiB,OAAO,cAAc,WAAQ,MAAM,gBAAgB,OAAO,gBAC/E;AACT"}

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

@@ -1,11 +1,11 @@
-import { MION_ROUTES, JitCompiledFnData, MethodsCache, PureFnsDataCache } from '@mionjs/core';
-import { ClientOptions, SubRequest } from '../types.ts';
-type MetadataRouteKey = typeof MION_ROUTES.methodsMetadata | typeof MION_ROUTES.methodsMetadataById;
-export declare function extractAndProcessMetadata(routeKey: MetadataRouteKey, parsedBody: any, options: ClientOptions): void;
-export declare function storeDependencies(deps: Record<string, JitCompiledFnData>, pureFnDeps: PureFnsDataCache, options: ClientOptions): void;
-export declare function storeMethodsMetadata(methods: MethodsCache, options: ClientOptions): void;
-export declare function restoreAllDependencies(options: ClientOptions): void;
-export declare function createMetadataSubRequest(methodIds: string[]): SubRequest<any>;
-export declare function restoreFromLocalStorage(methodIds: string[], options: ClientOptions): void;
-export {};
+import { RpcError, SerializableMethodsData } from '@mionjs/core';
+import { ClientOptions } from '../types.ts';
+export declare function flushMetadataCache(): Promise<void>;
+export declare function takeMetadataCacheError(): RpcError<string> | undefined;
+export declare function hydrateMetadataCache(options: ClientOptions): Promise<void>;
+export declare function wasHydratedFromCache(id: string, options: ClientOptions): boolean;
+export declare function purgeHydratedMetadata(ids: string[], options: ClientOptions): Promise<void>;
+export declare function forgetFetchedMetadata(ids: string[], options: ClientOptions): Promise<void>;
+export declare function resetMetadataCacheState(): void;
+export declare function installMethodRows(serializableMethodsData: SerializableMethodsData, options: ClientOptions, replaceIds?: string[]): void;
 //# sourceMappingURL=clientMethodsMetadata.d.ts.map

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

@@ -1,125 +1,281 @@
-import { MION_ROUTES, isRpcError, addSerializedJitCaches, routesCache, addRoutesToCache } from "@mionjs/core";
-import { STORAGE_KEY } from "../constants.js";
-import { getStorage } from "./storage.js";
-const METHOD_DATA_PREFIX = `${STORAGE_KEY}:method-data:`, JIT_FN_PREFIX = `${STORAGE_KEY}:jit-fn:`, PURE_FN_PREFIX = `${STORAGE_KEY}:pure-fn:`;
-function extractAndProcessMetadata(routeKey, parsedBody, options) {
-  if (typeof parsedBody != "object" || !(routeKey in parsedBody))
-    return;
-  const rawMetadata = parsedBody[routeKey];
-  if (delete parsedBody[routeKey], !rawMetadata)
-    return;
-  const metadataValue = Array.isArray(rawMetadata) ? rawMetadata[1] : rawMetadata;
-  metadataValue && !isRpcError(metadataValue) && metadataValue.methods && processMethodsMetadata(metadataValue, options);
+import { METADATA_CACHE_MAX_BYTES } from "../constants.js";
+import { getMetadataStore } from "./metadataStore.js";
+import { requestPersistenceWhenSilent } from "./persistentStorage.js";
+import { isBundledMethod, setFetchedMethods } from "./methods.js";
+import { findOrphans } from "./metadataEviction.js";
+import { RpcError, addRoutesToCache, addSerializedJitCaches, hasJitFnsForMethod, isUnsafePropertyName, routesCache } from "@mionjs/core";
+var states = /* @__PURE__ */ new Map(), writeQueue = [], flushHandle, flushChain = Promise.resolve(), persistenceAsked = !1, pendingCacheError;
+function getState(options) {
+  const baseURL = options.baseURL;
+  let state = states.get(baseURL);
+  return state || (state = {
+    baseURL,
+    storageEngine: options.storageEngine,
+    hydratedIds: /* @__PURE__ */ new Set(),
+    stored: /* @__PURE__ */ new Map(),
+    bytes: 0,
+    graph: {
+      methods: /* @__PURE__ */ Object.create(null),
+      deps: /* @__PURE__ */ Object.create(null),
+      pureFns: /* @__PURE__ */ Object.create(null)
+    },
+    sweepScheduled: !1
+  }, states.set(baseURL, state)), state;
+}
+function storedKey(kind, id) {
+  return `${kind} ${id}`;
 }
 function processMethodsMetadata(serializableMethodsData, options) {
-  storeDependencies(serializableMethodsData.deps, serializableMethodsData.purFnDeps, options), storeMethodsMetadata(serializableMethodsData.methods, options), addToCaches(serializableMethodsData);
+  addToCaches(serializableMethodsData), queuePersist(serializableMethodsData, options);
 }
-function getSerializedMethodDataKey(methodId, options) {
-  return `${METHOD_DATA_PREFIX}${methodId}:${options.baseURL}`;
+function isStorableName(name) {
+  return !isUnsafePropertyName(name) && !name.includes(":");
 }
-function getJitCompiledFnKey(jitFnHash, options) {
-  return `${JIT_FN_PREFIX}${jitFnHash}:${options.baseURL}`;
+function queuePersist(data, options) {
+  writeQueue.push({
+    data,
+    options
+  }), scheduleFlush();
 }
-function getJitPureFnKey(namespace, pureFnHash, options) {
-  return `${PURE_FN_PREFIX}${namespace}:${pureFnHash}:${options.baseURL}`;
+function scheduleFlush() {
+  if (flushHandle !== void 0) return;
+  const run = () => {
+    flushHandle = void 0, flushChain = flushChain.then(flushQueue);
+  }, idle = globalThis.requestIdleCallback;
+  flushHandle = typeof idle == "function" ? idle(run, { timeout: 200 }) : setTimeout(run, 0);
 }
-function storeDependencies(deps, pureFnDeps, options) {
-  Object.entries(deps).forEach(([hash, jitFnData]) => {
-    const key = getJitCompiledFnKey(hash, options);
-    try {
-      getStorage().setItem(key, JSON.stringify(jitFnData));
-    } catch (error) {
-      console.warn(`Failed to store JIT function dependency ${hash}:`, error);
-    }
-  }), Object.entries(pureFnDeps).forEach(([namespace, nsPureFns]) => {
-    Object.entries(nsPureFns).forEach(([fnHash, pureFnData]) => {
-      const key = getJitPureFnKey(namespace, fnHash, options);
+function flushMetadataCache() {
+  if (flushHandle !== void 0) {
+    const cancelIdle = globalThis.cancelIdleCallback;
+    typeof cancelIdle == "function" ? cancelIdle(flushHandle) : clearTimeout(flushHandle), flushHandle = void 0;
+  }
+  return flushChain = flushChain.then(flushQueue), flushChain;
+}
+async function flushQueue() {
+  if (!writeQueue.length) return;
+  const batch = writeQueue;
+  writeQueue = [];
+  const byBaseURL = /* @__PURE__ */ new Map();
+  for (const item of batch) {
+    const group = byBaseURL.get(item.options.baseURL);
+    group ? group.payloads.push(item.data) : byBaseURL.set(item.options.baseURL, {
+      options: item.options,
+      payloads: [item.data]
+    });
+  }
+  for (const group of byBaseURL.values()) await persistPayloads(group.options, group.payloads);
+}
+async function persistPayloads(options, payloads) {
+  const baseURL = options.baseURL, state = getState(options), ts = Date.now(), records = /* @__PURE__ */ new Map(), add = (kind, id, value) => {
+    const key = storedKey(kind, id);
+    if (!(kind !== "m" && state.stored.has(key)))
       try {
-        getStorage().setItem(key, JSON.stringify(pureFnData));
+        records.set(key, {
+          baseURL,
+          kind,
+          id,
+          json: JSON.stringify(value),
+          ts
+        });
       } catch (error) {
-        console.warn(`Failed to store pure function dependency ${namespace}::${fnHash}:`, error);
+        console.warn(`Failed to serialize metadata cache entry ${id}:`, error);
       }
-    });
+  };
+  for (const payload of payloads) {
+    for (const [hash, jitFnData] of Object.entries(payload.deps ?? {})) {
+      if (!isStorableName(hash)) {
+        console.warn(`Refused to store JIT function dependency under '${hash}'`);
+        continue;
+      }
+      add("j", hash, jitFnData);
+    }
+    for (const [id, pureFnData] of Object.entries(payload.purFnDeps ?? {})) {
+      if (!isStorableName(id)) {
+        console.warn(`Refused to store pure function '${id}'`);
+        continue;
+      }
+      add("p", id, pureFnData);
+    }
+    for (const [methodId, methodData] of Object.entries(payload.methods ?? {})) {
+      if (!isStorableName(methodId)) {
+        console.warn(`Refused to store metadata for method '${methodId}'`);
+        continue;
+      }
+      isBundledMethod(methodId) || add("m", methodId, methodData);
+    }
+  }
+  records.size && await writeRecords(state, [...records.values()]);
+}
+function recordBytes(record) {
+  return record.json.length + record.id.length;
+}
+async function writeRecords(state, records) {
+  const store = await getMetadataStore(state.storageEngine), incoming = records.reduce((total, record) => total + recordBytes(record), 0);
+  await evictOldest(state, store, state.bytes + incoming - METADATA_CACHE_MAX_BYTES);
+  for (let round = 0; ; round++) try {
+    await store.write(records);
+    for (const record of records) {
+      const key = storedKey(record.kind, record.id), previous = state.stored.get(key);
+      previous && (state.bytes -= previous.bytes);
+      const bytes = recordBytes(record);
+      state.stored.set(key, {
+        kind: record.kind,
+        id: record.id,
+        ts: record.ts,
+        bytes
+      }), state.bytes += bytes;
+    }
+    askForPersistenceOnce();
+    return;
+  } catch (error) {
+    if (round >= 5 || !await evictOldest(state, store, Math.max(state.bytes / 4, incoming))) return reportCacheError(error);
+  }
+}
+async function evictOldest(state, store, targetBytes) {
+  if (targetBytes <= 0 || !state.stored.size) return 0;
+  const oldestFirst = [...state.stored.values()].sort((a, b) => a.ts - b.ts), keys = [];
+  let freed = 0;
+  for (const entry of oldestFirst)
+    if (keys.push([entry.kind, entry.id]), freed += entry.bytes, freed >= targetBytes) break;
+  try {
+    await store.remove(state.baseURL, keys);
+  } catch {
+    return 0;
+  }
+  for (const [kind, id] of keys) {
+    const key = storedKey(kind, id);
+    state.bytes -= state.stored.get(key)?.bytes ?? 0, state.stored.delete(key), kind === "j" ? delete state.graph.deps[id] : kind === "p" ? delete state.graph.pureFns[id] : delete state.graph.methods[id];
+  }
+  return freed;
+}
+function reportCacheError(error) {
+  const rpcError = new RpcError({
+    type: "metadata-cache-error",
+    publicMessage: "Could not store the remote method metadata cache",
+    originalError: error instanceof Error ? error : void 0
   });
+  console.error("[mion] metadata cache write failed:", error), pendingCacheError = rpcError;
+}
+function takeMetadataCacheError() {
+  const error = pendingCacheError;
+  return pendingCacheError = void 0, error;
+}
+function askForPersistenceOnce() {
+  persistenceAsked || (persistenceAsked = !0, requestPersistenceWhenSilent());
+}
+function hydrateMetadataCache(options) {
+  const state = getState(options);
+  return state.hydration || (state.hydration = hydrate(state).catch((error) => {
+    console.warn("Failed to restore the remote method metadata cache:", error);
+  })), state.hydration;
 }
-function storeMethodsMetadata(methods, options) {
-  Object.entries(methods).forEach(([methodId, methodData]) => {
-    const key = getSerializedMethodDataKey(methodId, options);
+async function hydrate(state) {
+  const records = await (await getMetadataStore(state.storageEngine)).readAll(state.baseURL);
+  if (!records.length) return;
+  const deps = /* @__PURE__ */ Object.create(null), pureFnDeps = /* @__PURE__ */ Object.create(null), methods = /* @__PURE__ */ Object.create(null);
+  for (const record of records) {
+    if (!isStorableName(record.id)) continue;
+    let parsed;
     try {
-      getStorage().setItem(key, JSON.stringify(methodData));
+      parsed = JSON.parse(record.json);
     } catch (error) {
-      console.warn(`Failed to store method metadata ${methodId}:`, error);
+      console.warn(`Failed to restore metadata cache entry ${record.id}:`, error);
+      continue;
     }
-  });
-}
-function restoreAllDependencies(options) {
-  const deps = {}, pureFnDeps = {}, baseURLSuffix = `:${options.baseURL}`;
-  for (let i = 0; i < getStorage().length; i++) {
-    const key = getStorage().key(i);
-    if (key?.startsWith(JIT_FN_PREFIX) && key.endsWith(baseURLSuffix))
-      try {
-        const data = getStorage().getItem(key);
-        if (data) {
-          const parsedData = JSON.parse(data);
-          deps[parsedData.jitFnHash] = parsedData;
-        }
-      } catch (error) {
-        console.warn(`Failed to restore JIT function from key ${key}:`, error);
+    const key = storedKey(record.kind, record.id);
+    if (state.stored.set(key, {
+      kind: record.kind,
+      id: record.id,
+      ts: record.ts,
+      bytes: recordBytes(record)
+    }), state.bytes += recordBytes(record), record.kind === "j")
+      deps[record.id] = parsed, state.graph.deps[record.id] = parsed;
+    else if (record.kind === "p") {
+      if (typeof parsed?.code != "string") {
+        console.warn(`Ignoring cached pure function ${record.id}: it carries no code`);
+        continue;
       }
+      pureFnDeps[record.id] = parsed, state.graph.pureFns[record.id] = parsed;
+    } else
+      methods[record.id] = parsed, state.graph.methods[record.id] = parsed;
   }
-  for (let i = 0; i < getStorage().length; i++) {
-    const key = getStorage().key(i);
-    if (key?.startsWith(PURE_FN_PREFIX) && key.endsWith(baseURLSuffix))
-      try {
-        const data = getStorage().getItem(key);
-        if (data) {
-          const parsedData = JSON.parse(data), namespace = key.slice(PURE_FN_PREFIX.length, key.length - baseURLSuffix.length).split(":")[0] || parsedData.namespace;
-          pureFnDeps[namespace] || (pureFnDeps[namespace] = {}), pureFnDeps[namespace][parsedData.fnName] = parsedData;
-        }
-      } catch (error) {
-        console.warn(`Failed to restore pure function from key ${key}:`, error);
-      }
+  addSerializedJitCaches(deps, pureFnDeps);
+  const restorable = {}, unusable = [];
+  for (const [id, metadata] of Object.entries(methods)) hasJitFnsForMethod(metadata) ? (restorable[id] = metadata, state.hydratedIds.add(id)) : (unusable.push(["m", id]), delete state.graph.methods[id]);
+  addRoutesToCache(restorable), scheduleSweep(state, unusable);
+}
+function wasHydratedFromCache(id, options) {
+  return states.get(options.baseURL)?.hydratedIds.has(id) === !0;
+}
+async function purgeHydratedMetadata(ids, options) {
+  const state = states.get(options.baseURL);
+  if (!state) return;
+  const hydrated = ids.filter((id) => state.hydratedIds.has(id));
+  for (const id of hydrated) routesCache.removeMetadata(id);
+  await dropStoredMethods(state, hydrated);
+}
+async function forgetFetchedMetadata(ids, options) {
+  const fetchedIds = ids.filter((id) => !isBundledMethod(id));
+  for (const id of fetchedIds) routesCache.removeMetadata(id);
+  for (const queued of writeQueue)
+    if (queued.options.baseURL === options.baseURL)
+      for (const id of fetchedIds) delete queued.data.methods[id];
+  const state = states.get(options.baseURL);
+  state && await dropStoredMethods(state, fetchedIds);
+}
+async function dropStoredMethods(state, ids) {
+  const keys = [];
+  for (const id of ids)
+    state.hydratedIds.delete(id), delete state.graph.methods[id], keys.push(["m", id]);
+  if (keys.length) {
+    await (await getMetadataStore(state.storageEngine)).remove(state.baseURL, keys).catch(() => {
+    });
+    for (const [kind, id] of keys) {
+      const key = storedKey(kind, id);
+      state.bytes -= state.stored.get(key)?.bytes ?? 0, state.stored.delete(key);
+    }
+    await sweepOrphans(state);
   }
-  (Object.keys(deps).length > 0 || Object.keys(pureFnDeps).length > 0) && addSerializedJitCaches(deps, pureFnDeps);
-}
-function createMetadataSubRequest(methodIds) {
-  return {
-    pointer: [MION_ROUTES.methodsMetadata],
-    id: MION_ROUTES.methodsMetadata,
-    isResolved: !1,
-    params: [methodIds]
-  };
 }
-function restoreFromLocalStorage(methodIds, options) {
-  restoreAllDependencies(options);
-  const methods = {};
-  let anyMethodsRestored = !1;
-  methodIds.forEach((id) => {
-    if (routesCache.hasMetadata(id))
-      return;
-    const methodKey = getSerializedMethodDataKey(id, options), methodMetaJson = getStorage().getItem(methodKey);
-    if (methodMetaJson)
-      try {
-        const methodMeta = JSON.parse(methodMetaJson);
-        methods[id] = methodMeta, anyMethodsRestored = !0;
-      } catch (error) {
-        console.warn(`Failed to restore method metadata for ${id}:`, error), getStorage().removeItem(methodKey);
-      }
-  }), anyMethodsRestored && addToCaches({
-    methods,
-    deps: {},
-    purFnDeps: {}
-  });
+function scheduleSweep(state, alsoDelete) {
+  if (state.sweepScheduled) return;
+  state.sweepScheduled = !0;
+  const run = () => {
+    sweepOrphans(state, alsoDelete);
+  }, idle = globalThis.requestIdleCallback;
+  typeof idle == "function" ? idle(run, { timeout: 2e3 }) : setTimeout(run, 0);
+}
+async function sweepOrphans(state, alsoDelete = []) {
+  const keys = [...alsoDelete, ...findOrphans(state.graph)];
+  if (keys.length) {
+    await (await getMetadataStore(state.storageEngine)).remove(state.baseURL, keys).catch(() => {
+    });
+    for (const [kind, id] of keys) {
+      const key = storedKey(kind, id);
+      state.bytes -= state.stored.get(key)?.bytes ?? 0, state.stored.delete(key), kind === "j" ? delete state.graph.deps[id] : kind === "p" ? delete state.graph.pureFns[id] : delete state.graph.methods[id];
+    }
+  }
+}
+function resetMetadataCacheState() {
+  states.clear(), writeQueue = [], persistenceAsked = !1, pendingCacheError = void 0;
+}
+function installMethodRows(serializableMethodsData, options, replaceIds = []) {
+  for (const id of replaceIds) routesCache.removeMetadata(id);
+  processMethodsMetadata(serializableMethodsData, options);
 }
 function addToCaches(serializableMethodsData) {
   addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps), addRoutesToCache(serializableMethodsData.methods);
 }
+setFetchedMethods(routesCache);
 export {
-  createMetadataSubRequest,
-  extractAndProcessMetadata,
-  restoreAllDependencies,
-  restoreFromLocalStorage,
-  storeDependencies,
-  storeMethodsMetadata
+  flushMetadataCache,
+  forgetFetchedMetadata,
+  hydrateMetadataCache,
+  installMethodRows,
+  purgeHydratedMetadata,
+  resetMetadataCacheState,
+  takeMetadataCacheError,
+  wasHydratedFromCache
 };
-//# sourceMappingURL=clientMethodsMetadata.js.map
+
+//# sourceMappingURL=clientMethodsMetadata.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"clientMethodsMetadata.js","sources":["../../../../src/lib/clientMethodsMetadata.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 {isRpcError, addRoutesToCache} from '@mionjs/core';\nimport {MION_ROUTES} from '@mionjs/core';\nimport {ClientOptions, SubRequest} from '../types.ts';\nimport type {\n    JitCompiledFnData,\n    MethodsCache,\n    MethodWithOptions,\n    PureFunctionData,\n    SerializableMethodsData,\n    PureFnsDataCache,\n} from '@mionjs/core';\nimport {routesCache, addSerializedJitCaches} from '@mionjs/core';\nimport {STORAGE_KEY} from '../constants.ts';\nimport {getStorage} from './storage.ts';\n\nconst METHOD_DATA_PREFIX = `${STORAGE_KEY}:method-data:`;\nconst JIT_FN_PREFIX = `${STORAGE_KEY}:jit-fn:`;\nconst PURE_FN_PREFIX = `${STORAGE_KEY}:pure-fn:`;\n\ntype MetadataRouteKey = typeof MION_ROUTES.methodsMetadata | typeof MION_ROUTES.methodsMetadataById;\n\n/** Extracts raw metadata from a parsed response body, unwraps the JIT union discriminator, and processes it. */\nexport function extractAndProcessMetadata(routeKey: MetadataRouteKey, parsedBody: any, options: ClientOptions): void {\n    if (typeof parsedBody !== 'object' || !(routeKey in parsedBody)) return;\n    const rawMetadata = parsedBody[routeKey];\n    delete parsedBody[routeKey];\n    if (!rawMetadata) return;\n    const metadataValue = Array.isArray(rawMetadata) ? rawMetadata[1] : rawMetadata;\n    if (metadataValue && !isRpcError(metadataValue) && metadataValue.methods) {\n        processMethodsMetadata(metadataValue as SerializableMethodsData, options);\n    }\n}\n\n/** Processes metadata from an optimistic response and caches it */\nfunction processMethodsMetadata(serializableMethodsData: SerializableMethodsData, options: ClientOptions): void {\n    storeDependencies(serializableMethodsData.deps, serializableMethodsData.purFnDeps, options);\n    storeMethodsMetadata(serializableMethodsData.methods, options);\n    addToCaches(serializableMethodsData);\n}\n\nfunction getSerializedMethodDataKey(methodId: string, options: ClientOptions) {\n    return `${METHOD_DATA_PREFIX}${methodId}:${options.baseURL}`;\n}\n\nfunction getJitCompiledFnKey(jitFnHash: string, options: ClientOptions) {\n    return `${JIT_FN_PREFIX}${jitFnHash}:${options.baseURL}`;\n}\n\nfunction getJitPureFnKey(namespace: string, pureFnHash: string, options: ClientOptions) {\n    return `${PURE_FN_PREFIX}${namespace}:${pureFnHash}:${options.baseURL}`;\n}\n\n/** Stores JIT compiled functions and pure functions globally in localStorage */\nexport function storeDependencies(deps: Record<string, JitCompiledFnData>, pureFnDeps: PureFnsDataCache, options: ClientOptions) {\n    Object.entries(deps).forEach(([hash, jitFnData]: [string, JitCompiledFnData]) => {\n        const key = getJitCompiledFnKey(hash, options);\n        try {\n            getStorage().setItem(key, JSON.stringify(jitFnData));\n        } catch (error) {\n            console.warn(`Failed to store JIT function dependency ${hash}:`, error);\n        }\n    });\n\n    // Store namespaced pure functions\n    Object.entries(pureFnDeps).forEach(([namespace, nsPureFns]) => {\n        Object.entries(nsPureFns).forEach(([fnHash, pureFnData]: [string, PureFunctionData]) => {\n            const key = getJitPureFnKey(namespace, fnHash, options);\n            try {\n                getStorage().setItem(key, JSON.stringify(pureFnData));\n            } catch (error) {\n                console.warn(`Failed to store pure function dependency ${namespace}::${fnHash}:`, error);\n            }\n        });\n    });\n}\n\n/** Stores method metadata in localStorage using the new storage format */\nexport function storeMethodsMetadata(methods: MethodsCache, options: ClientOptions) {\n    Object.entries(methods).forEach(([methodId, methodData]) => {\n        const key = getSerializedMethodDataKey(methodId, options);\n        try {\n            getStorage().setItem(key, JSON.stringify(methodData));\n        } catch (error) {\n            console.warn(`Failed to store method metadata ${methodId}:`, error);\n        }\n    });\n}\n\n/** Restores all JIT compiled functions and pure functions from localStorage and deserializes them */\nexport function restoreAllDependencies(options: ClientOptions) {\n    const deps: Record<string, JitCompiledFnData> = {};\n    const pureFnDeps: PureFnsDataCache = {};\n    const baseURLSuffix = `:${options.baseURL}`;\n\n    for (let i = 0; i < getStorage().length; i++) {\n        const key = getStorage().key(i);\n        if (key?.startsWith(JIT_FN_PREFIX) && key.endsWith(baseURLSuffix)) {\n            try {\n                const data = getStorage().getItem(key);\n                if (data) {\n                    const parsedData = JSON.parse(data);\n                    deps[parsedData.jitFnHash] = parsedData;\n                }\n            } catch (error) {\n                console.warn(`Failed to restore JIT function from key ${key}:`, error);\n            }\n        }\n    }\n\n    for (let i = 0; i < getStorage().length; i++) {\n        const key = getStorage().key(i);\n        if (key?.startsWith(PURE_FN_PREFIX) && key.endsWith(baseURLSuffix)) {\n            try {\n                const data = getStorage().getItem(key);\n                if (data) {\n                    const parsedData = JSON.parse(data);\n                    // Extract namespace from key: \"mion:pure-fn:namespace:fnHash:baseURL\"\n                    const inner = key.slice(PURE_FN_PREFIX.length, key.length - baseURLSuffix.length);\n                    const namespace = inner.split(':')[0] || parsedData.namespace;\n                    if (!pureFnDeps[namespace]) pureFnDeps[namespace] = {};\n                    pureFnDeps[namespace][parsedData.fnName] = parsedData;\n                }\n            } catch (error) {\n                console.warn(`Failed to restore pure function from key ${key}:`, error);\n            }\n        }\n    }\n\n    if (Object.keys(deps).length > 0 || Object.keys(pureFnDeps).length > 0) {\n        addSerializedJitCaches(deps, pureFnDeps);\n    }\n}\n\n/** Creates a SubRequest for the metadata middleware to piggyback on an optimistic request */\nexport function createMetadataSubRequest(methodIds: string[]): SubRequest<any> {\n    return {\n        pointer: [MION_ROUTES.methodsMetadata],\n        id: MION_ROUTES.methodsMetadata,\n        isResolved: false,\n        params: [methodIds],\n    };\n}\n\n/** Restores method metadata from localStorage using the new storage format */\nexport function restoreFromLocalStorage(methodIds: string[], options: ClientOptions) {\n    restoreAllDependencies(options);\n\n    const methods: MethodsCache = {};\n    let anyMethodsRestored = false;\n\n    methodIds.forEach((id) => {\n        if (routesCache.hasMetadata(id)) return;\n        const methodKey = getSerializedMethodDataKey(id, options);\n        const methodMetaJson = getStorage().getItem(methodKey);\n        if (methodMetaJson) {\n            try {\n                const methodMeta: MethodWithOptions = JSON.parse(methodMetaJson);\n                methods[id] = methodMeta;\n                anyMethodsRestored = true;\n            } catch (error) {\n                console.warn(`Failed to restore method metadata for ${id}:`, error);\n                getStorage().removeItem(methodKey);\n            }\n        }\n    });\n\n    if (anyMethodsRestored) {\n        const serializableMethodsData: SerializableMethodsData = {\n            methods,\n            deps: {},\n            purFnDeps: {},\n        };\n        addToCaches(serializableMethodsData);\n    }\n}\n\nfunction addToCaches(serializableMethodsData: SerializableMethodsData) {\n    addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps);\n    addRoutesToCache(serializableMethodsData.methods);\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"clientMethodsMetadata.js","names":[],"sources":["../../../../src/lib/clientMethodsMetadata.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 {addRoutesToCache, isUnsafePropertyName, hasJitFnsForMethod, RpcError} from '@mionjs/core';\nimport {ClientOptions} from '../types.ts';\nimport type {\n  CompiledFnData,\n  MethodsCache,\n  MethodWithOptions,\n  PureFunctionData,\n  SerializablePureFunction,\n  SerializableMethodsData,\n  PureFnsDataCache,\n} from '@mionjs/core';\nimport {addSerializedJitCaches, routesCache} from '@mionjs/core';\nimport {METADATA_CACHE_EVICTION_ROUNDS, METADATA_CACHE_MAX_BYTES} from '../constants.ts';\nimport {getMetadataStore} from './metadataStore.ts';\nimport type {MetadataKind, MetadataRecord, MetadataRecordKey, MetadataStore, StorageEngine} from './storage.ts';\nimport {findOrphans, type CacheGraph} from './metadataEviction.ts';\nimport {requestPersistenceWhenSilent} from './persistentStorage.ts';\nimport {isBundledMethod, setFetchedMethods} from './methods.ts';\n\n/** What the cache knows about one stored record, without holding its text. Enough to pick the\n *  oldest rows when room is needed, and to skip re-writing an entry that is already down. */\ninterface StoredEntry {\n  kind: MetadataKind;\n  id: string;\n  ts: number;\n  bytes: number;\n}\n\n/** Everything the cache tracks for one server. One instance per baseURL, for the page's lifetime. */\ninterface CacheState {\n  baseURL: string;\n  /** the engine this server's cache lives on, so every read and write goes to the same store */\n  storageEngine: StorageEngine | undefined;\n  hydration?: Promise<void>;\n  /** method ids this page restored from the store rather than from the server */\n  hydratedIds: Set<string>;\n  /** what is on disk, keyed `${kind} ${id}` */\n  stored: Map<string, StoredEntry>;\n  bytes: number;\n  graph: CacheGraph;\n  sweepScheduled: boolean;\n}\n\nconst states = new Map<string, CacheState>();\n/** Payloads waiting to be written; the response path only pushes here and returns */\nlet writeQueue: {data: SerializableMethodsData; options: ClientOptions}[] = [];\nlet flushHandle: ReturnType<typeof setTimeout> | number | undefined;\nlet flushChain: Promise<void> = Promise.resolve();\nlet persistenceAsked = false;\nlet pendingCacheError: RpcError<string> | undefined;\n\nfunction getState(options: ClientOptions): CacheState {\n  const baseURL = options.baseURL;\n  let state = states.get(baseURL);\n  if (!state) {\n    state = {\n      baseURL,\n      storageEngine: options.storageEngine,\n      hydratedIds: new Set(),\n      stored: new Map(),\n      bytes: 0,\n      // Null-prototype maps: every key comes off the store, which any script on the page can write,\n      // so a plain object would let a `__proto__` key reach Object.prototype.\n      graph: {methods: Object.create(null), deps: Object.create(null), pureFns: Object.create(null)},\n      sweepScheduled: false,\n    };\n    states.set(baseURL, state);\n  }\n  return state;\n}\n\nfunction storedKey(kind: MetadataKind, id: string): string {\n  return `${kind} ${id}`;\n}\n\n/** Fills the in-memory caches now and leaves the store for later: the caller is a sync deserializer on the\n *  response path, where every throw becomes a parse error. */\nfunction processMethodsMetadata(serializableMethodsData: SerializableMethodsData, options: ClientOptions): void {\n  addToCaches(serializableMethodsData);\n  queuePersist(serializableMethodsData, options);\n}\n\n/** A name that reaches an object key on restore is checked even though the server is trusted: `__proto__` as\n *  a namespace would land the next write on Object.prototype, page-wide. A refused entry is only warned about. */\nfunction isStorableName(name: string): boolean {\n  return !isUnsafePropertyName(name) && !name.includes(':');\n}\n\n// ############# WRITE PATH #############\n\nfunction queuePersist(data: SerializableMethodsData, options: ClientOptions): void {\n  writeQueue.push({data, options});\n  scheduleFlush();\n}\n\nfunction scheduleFlush(): void {\n  if (flushHandle !== undefined) return;\n  const run = () => {\n    flushHandle = undefined;\n    flushChain = flushChain.then(flushQueue);\n  };\n  // idle time is exactly right for this: nothing waits on the write, and a big metadata payload\n  // costs a real JSON.stringify per entry\n  const idle = (globalThis as any).requestIdleCallback;\n  flushHandle = typeof idle === 'function' ? idle(run, {timeout: 200}) : setTimeout(run, 0);\n}\n\n/** Resolves once every queued write has reached the store. The write path is deferred on purpose,\n *  so a test that wants to read back what a response cached must await this first. */\nexport function flushMetadataCache(): Promise<void> {\n  if (flushHandle !== undefined) {\n    const cancelIdle = (globalThis as any).cancelIdleCallback;\n    if (typeof cancelIdle === 'function') cancelIdle(flushHandle);\n    else clearTimeout(flushHandle as ReturnType<typeof setTimeout>);\n    flushHandle = undefined;\n  }\n  flushChain = flushChain.then(flushQueue);\n  return flushChain;\n}\n\nasync function flushQueue(): Promise<void> {\n  if (!writeQueue.length) return;\n  const batch = writeQueue;\n  writeQueue = [];\n  const byBaseURL = new Map<string, {options: ClientOptions; payloads: SerializableMethodsData[]}>();\n  for (const item of batch) {\n    const group = byBaseURL.get(item.options.baseURL);\n    if (group) group.payloads.push(item.data);\n    else byBaseURL.set(item.options.baseURL, {options: item.options, payloads: [item.data]});\n  }\n  for (const group of byBaseURL.values()) await persistPayloads(group.options, group.payloads);\n}\n\n/** Turns the payloads into records, dropping anything already down, then writes them as one unit. */\nasync function persistPayloads(options: ClientOptions, payloads: SerializableMethodsData[]): Promise<void> {\n  const baseURL = options.baseURL;\n  const state = getState(options);\n  const ts = Date.now();\n  const records = new Map<string, MetadataRecord>();\n  const add = (kind: MetadataKind, id: string, value: unknown) => {\n    const key = storedKey(kind, id);\n    // hashes are content addresses, so a compiled function already down is byte for byte this one.\n    // A method row is keyed by its id instead, so it is always rewritten.\n    if (kind !== 'm' && state.stored.has(key)) return;\n    try {\n      records.set(key, {baseURL, kind, id, json: JSON.stringify(value), ts});\n    } catch (error) {\n      console.warn(`Failed to serialize metadata cache entry ${id}:`, error);\n    }\n  };\n\n  for (const payload of payloads) {\n    for (const [hash, jitFnData] of Object.entries<CompiledFnData>(payload.deps ?? {})) {\n      if (!isStorableName(hash)) {\n        console.warn(`Refused to store JIT function dependency under '${hash}'`);\n        continue;\n      }\n      add('j', hash, jitFnData);\n    }\n    for (const [id, pureFnData] of Object.entries<PureFunctionData>(payload.purFnDeps ?? {})) {\n      if (!isStorableName(id)) {\n        console.warn(`Refused to store pure function '${id}'`);\n        continue;\n      }\n      add('p', id, pureFnData);\n    }\n    for (const [methodId, methodData] of Object.entries<MethodWithOptions>(payload.methods ?? {})) {\n      if (!isStorableName(methodId)) {\n        console.warn(`Refused to store metadata for method '${methodId}'`);\n        continue;\n      }\n      // The server answers for a route's whole chain, so a bundled middleware rides a fetched route's\n      // answer; its row would only be read back to be ignored. Orphaned compiled functions are swept.\n      if (isBundledMethod(methodId)) continue;\n      add('m', methodId, methodData);\n    }\n  }\n\n  if (!records.size) return;\n  await writeRecords(state, [...records.values()]);\n}\n\nfunction recordBytes(record: MetadataRecord): number {\n  return record.json.length + record.id.length;\n}\n\n/** Writes the records, making room as many times as it takes: the new data always wins. The size cap trims\n *  first, and a browser that refuses anyway gets more old rows dropped and the write retried. Only an empty\n *  store that still cannot take the write is reported. */\nasync function writeRecords(state: CacheState, records: MetadataRecord[]): Promise<void> {\n  const store = await getMetadataStore(state.storageEngine);\n  const incoming = records.reduce((total, record) => total + recordBytes(record), 0);\n  await evictOldest(state, store, state.bytes + incoming - METADATA_CACHE_MAX_BYTES);\n\n  for (let round = 0; ; round++) {\n    try {\n      await store.write(records);\n      for (const record of records) {\n        const key = storedKey(record.kind, record.id);\n        const previous = state.stored.get(key);\n        if (previous) state.bytes -= previous.bytes;\n        const bytes = recordBytes(record);\n        state.stored.set(key, {kind: record.kind, id: record.id, ts: record.ts, bytes});\n        state.bytes += bytes;\n      }\n      askForPersistenceOnce();\n      return;\n    } catch (error) {\n      if (round >= METADATA_CACHE_EVICTION_ROUNDS) return reportCacheError(error);\n      // nothing freed means nothing is left to give up, so the store cannot take this write: tell the app\n      const freed = await evictOldest(state, store, Math.max(state.bytes / 4, incoming));\n      if (!freed) return reportCacheError(error);\n    }\n  }\n}\n\n/** Drops the oldest rows until at least `targetBytes` have been freed. Returns the bytes freed.\n *  Safe at any granularity: a method whose compiled functions went with it is refused on the next\n *  hydration and simply refetched. */\nasync function evictOldest(state: CacheState, store: MetadataStore, targetBytes: number): Promise<number> {\n  if (targetBytes <= 0 || !state.stored.size) return 0;\n  const oldestFirst = [...state.stored.values()].sort((a, b) => a.ts - b.ts);\n  const keys: MetadataRecordKey[] = [];\n  let freed = 0;\n  for (const entry of oldestFirst) {\n    keys.push([entry.kind, entry.id]);\n    freed += entry.bytes;\n    if (freed >= targetBytes) break;\n  }\n  try {\n    await store.remove(state.baseURL, keys);\n  } catch {\n    // a store that cannot delete cannot be trimmed; the caller reports the write failure instead\n    return 0;\n  }\n  for (const [kind, id] of keys) {\n    const key = storedKey(kind, id);\n    state.bytes -= state.stored.get(key)?.bytes ?? 0;\n    state.stored.delete(key);\n    if (kind === 'j') delete state.graph.deps[id];\n    else if (kind === 'p') delete state.graph.pureFns[id];\n    else delete state.graph.methods[id];\n  }\n  return freed;\n}\n\nfunction reportCacheError(error: unknown): void {\n  const rpcError = new RpcError({\n    type: 'metadata-cache-error',\n    publicMessage: 'Could not store the remote method metadata cache',\n    originalError: error instanceof Error ? error : undefined,\n  });\n  // loud now for whoever is watching the console, and again on the next call for the app itself\n  console.error('[mion] metadata cache write failed:', error);\n  pendingCacheError = rpcError;\n}\n\n/** Takes the last unrecoverable cache error, if any, so a call can report it once. */\nexport function takeMetadataCacheError(): RpcError<string> | undefined {\n  const error = pendingCacheError;\n  pendingCacheError = undefined;\n  return error;\n}\n\nfunction askForPersistenceOnce(): void {\n  if (persistenceAsked) return;\n  persistenceAsked = true;\n  // never awaited, and never in a browser where it could prompt (see persistentStorage.ts)\n  void requestPersistenceWhenSilent();\n}\n\n// ############# READ PATH #############\n\n/** Restores everything this server cached, once per page. One indexed read, never a scan.\n *  Never rejects: a missing or blocked store is a cache miss, not an error. */\nexport function hydrateMetadataCache(options: ClientOptions): Promise<void> {\n  const state = getState(options);\n  if (!state.hydration) {\n    state.hydration = hydrate(state).catch((error) => {\n      console.warn('Failed to restore the remote method metadata cache:', error);\n    });\n  }\n  return state.hydration;\n}\n\nasync function hydrate(state: CacheState): Promise<void> {\n  const store = await getMetadataStore(state.storageEngine);\n  const records = await store.readAll(state.baseURL);\n  if (!records.length) return;\n\n  const deps: Record<string, CompiledFnData> = Object.create(null);\n  const pureFnDeps: PureFnsDataCache = Object.create(null);\n  const methods: MethodsCache = Object.create(null);\n\n  for (const record of records) {\n    // the entry is keyed by the id in ITS OWN record, never by what the payload claims\n    if (!isStorableName(record.id)) continue;\n    let parsed: any;\n    try {\n      parsed = JSON.parse(record.json);\n    } catch (error) {\n      console.warn(`Failed to restore metadata cache entry ${record.id}:`, error);\n      continue;\n    }\n    const key = storedKey(record.kind, record.id);\n    state.stored.set(key, {kind: record.kind, id: record.id, ts: record.ts, bytes: recordBytes(record)});\n    state.bytes += recordBytes(record);\n    if (record.kind === 'j') {\n      deps[record.id] = parsed;\n      state.graph.deps[record.id] = parsed;\n    } else if (record.kind === 'p') {\n      // the factory is rebuilt from `code`, so an entry without one restores to nothing callable\n      if (typeof parsed?.code !== 'string') {\n        console.warn(`Ignoring cached pure function ${record.id}: it carries no code`);\n        continue;\n      }\n      pureFnDeps[record.id] = parsed as SerializablePureFunction;\n      state.graph.pureFns[record.id] = parsed;\n    } else {\n      methods[record.id] = parsed as MethodWithOptions;\n      state.graph.methods[record.id] = parsed;\n    }\n  }\n\n  addSerializedJitCaches(deps, pureFnDeps);\n\n  // A method whose compiled functions are gone (eviction, an aborted write, a newer server build) would\n  // throw at call time, not here: refuse it and let the server be asked again.\n  const restorable: MethodsCache = {};\n  const unusable: MetadataRecordKey[] = [];\n  for (const [id, metadata] of Object.entries(methods)) {\n    if (hasJitFnsForMethod(metadata)) {\n      restorable[id] = metadata;\n      state.hydratedIds.add(id);\n    } else {\n      unusable.push(['m', id]);\n      delete state.graph.methods[id];\n    }\n  }\n  addRoutesToCache(restorable);\n  scheduleSweep(state, unusable);\n}\n\n/** True when this page took the method's metadata off the store rather than from the server. */\nexport function wasHydratedFromCache(id: string, options: ClientOptions): boolean {\n  return states.get(options.baseURL)?.hydratedIds.has(id) === true;\n}\n\n/** Drops restored rows the server no longer matches from memory and the store, so the next call relearns them. */\nexport async function purgeHydratedMetadata(ids: string[], options: ClientOptions): Promise<void> {\n  const state = states.get(options.baseURL);\n  if (!state) return;\n  const hydrated = ids.filter((id) => state.hydratedIds.has(id));\n  for (const id of hydrated) routesCache.removeMetadata(id);\n  await dropStoredMethods(state, hydrated);\n}\n\n/** Forgets fetched rows from memory, the store and any queued write, so the next call relearns them.\n *  A bundled row stays: the calling code was built against it. */\nexport async function forgetFetchedMetadata(ids: string[], options: ClientOptions): Promise<void> {\n  const fetchedIds = ids.filter((id) => !isBundledMethod(id));\n  for (const id of fetchedIds) routesCache.removeMetadata(id);\n  // a queued write would put the forgotten row back after the delete below\n  for (const queued of writeQueue) {\n    if (queued.options.baseURL !== options.baseURL) continue;\n    for (const id of fetchedIds) delete queued.data.methods[id];\n  }\n  const state = states.get(options.baseURL);\n  if (state) await dropStoredMethods(state, fetchedIds);\n}\n\nasync function dropStoredMethods(state: CacheState, ids: string[]): Promise<void> {\n  const keys: MetadataRecordKey[] = [];\n  for (const id of ids) {\n    state.hydratedIds.delete(id);\n    delete state.graph.methods[id];\n    keys.push(['m', id]);\n  }\n  if (!keys.length) return;\n  const store = await getMetadataStore(state.storageEngine);\n  await store.remove(state.baseURL, keys).catch(() => undefined);\n  for (const [kind, id] of keys) {\n    const key = storedKey(kind, id);\n    state.bytes -= state.stored.get(key)?.bytes ?? 0;\n    state.stored.delete(key);\n  }\n  // the compiled functions those methods pointed at have nothing left pointing at them\n  await sweepOrphans(state);\n}\n\n/** Deletes rows nothing can reach any more. Costs no extra reads: it walks the records hydration\n *  already parsed. Once per server per page, on idle. */\nfunction scheduleSweep(state: CacheState, alsoDelete: MetadataRecordKey[]): void {\n  if (state.sweepScheduled) return;\n  state.sweepScheduled = true;\n  const run = () => void sweepOrphans(state, alsoDelete);\n  const idle = (globalThis as any).requestIdleCallback;\n  if (typeof idle === 'function') idle(run, {timeout: 2000});\n  else setTimeout(run, 0);\n}\n\nasync function sweepOrphans(state: CacheState, alsoDelete: MetadataRecordKey[] = []): Promise<void> {\n  const keys = [...alsoDelete, ...findOrphans(state.graph)];\n  if (!keys.length) return;\n  const store = await getMetadataStore(state.storageEngine);\n  await store.remove(state.baseURL, keys).catch(() => undefined);\n  for (const [kind, id] of keys) {\n    const key = storedKey(kind, id);\n    state.bytes -= state.stored.get(key)?.bytes ?? 0;\n    state.stored.delete(key);\n    if (kind === 'j') delete state.graph.deps[id];\n    else if (kind === 'p') delete state.graph.pureFns[id];\n    else delete state.graph.methods[id];\n  }\n}\n\n/** Forgets everything this page learned about the store. Only for testing — simulates a new page. */\nexport function resetMetadataCacheState(): void {\n  states.clear();\n  writeQueue = [];\n  persistenceAsked = false;\n  pendingCacheError = undefined;\n}\n\n/** Saves rows answered outside the metadata route: a stored row that later disagrees with its server is relearned.\n *  `replaceIds` go first: the fetched shelf never overwrites a row. */\nexport function installMethodRows(\n  serializableMethodsData: SerializableMethodsData,\n  options: ClientOptions,\n  replaceIds: string[] = []\n): void {\n  for (const id of replaceIds) routesCache.removeMetadata(id);\n  processMethodsMetadata(serializableMethodsData, options);\n}\n\nfunction addToCaches(serializableMethodsData: SerializableMethodsData) {\n  addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps);\n  addRoutesToCache(serializableMethodsData.methods);\n}\n\n// Registered here rather than in metadataFromServer.ts: its pieces are public API and a consumer\n// can import one directly, so this module evaluating IS the moment the fetched lane exists.\nsetFetchedMethods(routesCache);\n"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import { RpcError } from '@mionjs/core';
+import { RemoteApi } from '@mionjs/router';
+import { ClientResponse } from '../types.ts';
+export declare function addThrownError(response: ClientResponse<RemoteApi>, error: RpcError<string>): void;
+export declare function hasResponseValue(response: ClientResponse<RemoteApi>, id: string): boolean;
+export declare function getResponseValue(response: ClientResponse<RemoteApi>, id: string): unknown;
+export declare function setResponseValue(response: ClientResponse<RemoteApi>, id: string, value: unknown): boolean;
+export declare function deleteResponseValue(response: ClientResponse<RemoteApi>, id: string): void;
+//# sourceMappingURL=clientResponse.d.ts.map

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

@@ -0,0 +1,53 @@
+import { MION_ROUTES, ROUTER_ITEM_SEPARATOR_CHAR } from "@mionjs/core";
+function addThrownError(response, error) {
+  const thrownErrors = response[MION_ROUTES.thrownErrors];
+  Array.isArray(thrownErrors) ? thrownErrors.push(error) : response[MION_ROUTES.thrownErrors] = [error];
+}
+function hasResponseValue(response, id) {
+  const { parent, key } = findParent(response, id);
+  return !!parent && Object.hasOwn(parent, key);
+}
+function getResponseValue(response, id) {
+  const { parent, key } = findParent(response, id);
+  return parent && Object.hasOwn(parent, key) ? parent[key] : void 0;
+}
+function setResponseValue(response, id, value) {
+  const { parent, key } = findParent(response, id, !0);
+  return parent && (parent[key] = value), !!parent;
+}
+function deleteResponseValue(response, id) {
+  const pointer = id.split(ROUTER_ITEM_SEPARATOR_CHAR);
+  for (let depth = pointer.length; depth > 0; depth--) {
+    const { parent, key } = findParent(response, pointer.slice(0, depth).join(ROUTER_ITEM_SEPARATOR_CHAR));
+    if (!parent || !Object.hasOwn(parent, key)) return;
+    const child = parent[key];
+    if (depth < pointer.length && !(isNode(child) && !Object.keys(child).length)) return;
+    delete parent[key];
+  }
+}
+function findParent(response, id, create = !1) {
+  const pointer = id.split(ROUTER_ITEM_SEPARATOR_CHAR), key = pointer[pointer.length - 1];
+  if (pointer.includes("__proto__") || pointer[0] === MION_ROUTES.thrownErrors) return { key };
+  let node = response;
+  for (let i = 0; i < pointer.length - 1; i++) {
+    let next = Object.hasOwn(node, pointer[i]) ? node[pointer[i]] : void 0;
+    if (next === void 0 && create && (next = node[pointer[i]] = {}), !isNode(next)) return { key };
+    node = next;
+  }
+  return {
+    parent: node,
+    key
+  };
+}
+function isNode(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+export {
+  addThrownError,
+  deleteResponseValue,
+  getResponseValue,
+  hasResponseValue,
+  setResponseValue
+};
+
+//# sourceMappingURL=clientResponse.js.map