jev-web 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jev-web",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Run open-jev- and Laya-shaped typed-decision models in the browser: one state plus typed questions in, calibrated probabilities out.",
   "type": "module",
   "license": "MIT",

package/src/laya.mjs

@@ -211,26 +211,11 @@ export function layaAnswersFromLogits({
  * Falls back to `res.json()` when the body isn't streamable (Node fakes/tests).
  */
 async function fetchJson(url, file, { fetchImpl, onProgress }) {
-  const res = await fetchImpl(url);
-  if (!res.ok) throw new Error(`tokenizer ${file}: HTTP ${res.status}`);
-  const total = Number(res.headers?.get?.("content-length")) || 0;
-  if (onProgress && res.body?.getReader) {
-    const reader = res.body.getReader();
-    const chunks = [];
-    let loaded = 0;
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-      loaded += value.length;
-      onProgress({ phase: "tokenizer", file, loaded, total: total || null });
-    }
-    const buf = new Uint8Array(loaded);
-    let off = 0;
-    for (const c of chunks) { buf.set(c, off); off += c.length; }
-    return JSON.parse(new TextDecoder().decode(buf));
-  }
-  return res.json();
+  const bytes = await fetchCachedBytes(url, {
+    fetchImpl,
+    onProgress: (p) => onProgress?.({ ...p, phase: "tokenizer", file }),
+  });
+  return JSON.parse(new TextDecoder().decode(bytes));
 }
 
 /**
@@ -300,6 +285,146 @@ const now = () => (typeof performance !== "undefined" ? performance.now() : Date
 const hfUrl = (model, revision, file) =>
   `https://huggingface.co/${model}/resolve/${revision ? `${revision}/` : ""}${file}`;
 
+const MODEL_CACHE = "kf-models-v1";
+
+async function modelCacheStore() {
+  try {
+    return typeof caches !== "undefined" ? caches : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Ask for persistent storage once so big weights survive eviction pressure. */
+export async function requestPersistentStorage() {
+  try {
+    return (await globalThis.navigator?.storage?.persist?.()) ?? false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Fetch bytes with a Cache-API layer. Hugging Face redirects to a *signed*
+ * CDN URL that changes per request, so the browser HTTP cache never hits for
+ * the 468 MB encoder weights; this caches them under the stable model URL
+ * instead (Cache API), so a page refresh is free.
+ *
+ * @returns {Promise<Uint8Array>}
+ */
+export async function fetchCachedBytes(url, {
+  fetchImpl = fetch,
+  onProgress = null,
+  cacheName = MODEL_CACHE,
+  force = false,
+  persist = false,
+} = {}) {
+  const store = await modelCacheStore();
+  if (persist) await requestPersistentStorage();
+  if (store && !force) {
+    try {
+      const hit = await store.match(url);
+      if (hit) {
+        const data = new Uint8Array(await hit.arrayBuffer());
+        onProgress?.({ phase: "cache", file: String(url).split("/").pop(), loaded: data.length, total: data.length });
+        return data;
+      }
+    } catch {
+      /* cache read failed — fall through to the network */
+    }
+  }
+  const res = await fetchImpl(url);
+  if (!res?.ok) throw new Error(`fetch ${url} failed (HTTP ${res?.status ?? "no response"})`);
+  const data = await readBytesWithProgress(res, url, onProgress);
+  if (store) {
+    try {
+      await store.put(url, new Response(data, {
+        headers: { "content-type": "application/octet-stream", "content-length": String(data.length) },
+      }));
+    } catch {
+      /* quota exceeded / private mode — caching is best-effort */
+    }
+  }
+  return data;
+}
+
+async function readBytesWithProgress(res, url, onProgress) {
+  const total = Number(res.headers?.get?.("content-length")) || 0;
+  const file = String(url).split("/").pop();
+  if (res.body?.getReader) {
+    const reader = res.body.getReader();
+    let received = 0;
+    let data = total ? new Uint8Array(total) : null;
+    const chunks = total ? null : [];
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (data) {
+        if (received + value.length > data.length) {
+          // content-length can describe the *encoded* size (gzip/br), so the
+          // decoded stream may be larger — grow instead of overflowing.
+          const grown = new Uint8Array(Math.max(data.length * 2, received + value.length));
+          grown.set(data.subarray(0, received));
+          data = grown;
+        }
+        data.set(value, received);
+      } else {
+        chunks.push(value);
+      }
+      received += value.length;
+      onProgress?.({ phase: "download", file, loaded: received, total: total || null });
+    }
+    if (!data) {
+      data = new Uint8Array(received);
+      let off = 0;
+      for (const c of chunks) { data.set(c, off); off += c.length; }
+    } else {
+      // the buffer may have grown past the decoded length (content-length is
+      // the *encoded* size) — always trim to what was actually received
+      data = data.subarray(0, received);
+    }
+    return data;
+  }
+  let data;
+  if (typeof res.arrayBuffer === "function") {
+    data = new Uint8Array(await res.arrayBuffer());
+  } else if (typeof res.text === "function") {
+    data = new TextEncoder().encode(await res.text());
+  } else if (typeof res.json === "function") {
+    data = new TextEncoder().encode(JSON.stringify(await res.json()));
+  } else {
+    throw new Error(`fetch ${url}: response has no readable body`);
+  }
+  onProgress?.({ phase: "download", file, loaded: data.length, total: data.length });
+  return data;
+}
+
+/**
+ * ONNX external-data loader.
+ *
+ * The pinned Laya export stores weights in `<model>.onnx.data` siblings
+ * (encoder ~468 MB, head ~53 MB). onnxruntime-web cannot resolve those from a
+ * URL by itself (`Module.MountedFiles is not available`); it needs the bytes
+ * passed via `session_options.externalData`. Fetch the sibling (streaming,
+ * with progress) and hand it over.
+ *
+ * @returns {Promise<{path:string, data:Uint8Array}|null>} null when the model
+ *   has no external data (404) or the fetch fails.
+ */
+export async function fetchOnnxExternalData(url, { fetchImpl = fetch, onProgress = null, force = false } = {}) {
+  const dataUrl = `${url}.data`;
+  const path = `${String(url).split("/").pop()}.data`;
+  try {
+    // Probe cheaply first: a 404 means the model has no external data.
+    const head = await fetchImpl(dataUrl, { method: "HEAD" }).catch(() => null);
+    if (head && !head.ok) return null;
+    const data = await fetchCachedBytes(dataUrl, { fetchImpl, onProgress, force, persist: true });
+    return { path, data };
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Create a Laya decider.
  *
@@ -376,7 +501,13 @@ export async function createLayaDecider({
   const encUrl = encoderUrl ?? hfUrl(model, revision, `${subfolder}/encoder_q8.onnx`);
   const headUrlResolved = headUrl ?? hfUrl(model, revision, `${subfolder}/head_q8.onnx`);
   const createSession = sessionFactory
-    ?? ((url, opts) => ortMod.InferenceSession.create(url, opts));
+    ?? (async (url, opts) => {
+      const report2 = (p) => onProgress?.(p);
+      const modelBytes = await fetchCachedBytes(url, { fetchImpl, onProgress: report2, persist: true });
+      const external = await fetchOnnxExternalData(url, { fetchImpl, onProgress: report2 });
+      const sessionOpts = external ? { ...opts, externalData: [external] } : opts;
+      return ortMod.InferenceSession.create(modelBytes, sessionOpts);
+    });
   const loadPair = async (providers) => {
     const opts = { executionProviders: providers, graphOptimizationLevel: "all" };
     const enc = await createSession(encUrl, { ...opts, progress_callback: report("encoder") });