eddie-jekyll 0.2.4 → 0.4.0

data/assets/eddie-worker.js

@@ -1,226 +1,1167 @@
 // SPDX-License-Identifier: GPL-3.0-only
+// Generated by widget/build.sh from widget/src/worker.js and widget/src/lib/*.js; edit those instead.
+"use strict";
+const EddieLib = {};
+// SPDX-License-Identifier: GPL-3.0-only
 
-// Eddie Web Worker
-//
-// Loads WASM module, downloads and caches the ML model in IndexedDB,
-// and handles search queries from the main thread.
+// URL, version and cache-key helpers shared by the widget and the worker.
 
-"use strict";
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
 
-// -- Configuration --
-const HF_CDN = "https://huggingface.co";
-const MODEL_FILES = ["config.json", "tokenizer.json", "model.safetensors"];
-const IDB_NAME = "eddie-models";
-const IDB_STORE = "files";
+  const HF_HOST = "https://huggingface.co";
 
-// -- State --
-let baseUrl = "";
-let initialized = false;
+  /** Directory of an absolute URL, without query or hash, with a trailing slash. */
+  function baseUrlOf(href) {
+    const u = new URL(href);
+    u.search = "";
+    u.hash = "";
+    const s = u.href;
+    return s.substring(0, s.lastIndexOf("/") + 1);
+  }
 
-// -- Message handler --
-self.onmessage = async function (e) {
-  const msg = e.data;
+  /** The `v` query parameter of a URL (absolute or relative), or null. */
+  function versionOf(href) {
+    if (!href) return null;
+    const q = href.indexOf("?");
+    if (q < 0) return null;
+    const params = new URLSearchParams(href.substring(q + 1).split("#")[0]);
+    const v = params.get("v");
+    return v ? v : null;
+  }
 
-  if (msg.type === "init") {
-    try {
-      await initialize(msg.indexUrl, msg.baseUrl);
-    } catch (err) {
-      postStatus("error", { error: err.message || String(err) });
+  /** Append `?v=<version>` unless the URL already carries a `v` parameter. */
+  function withVersion(url, version) {
+    if (!version || versionOf(url)) return url;
+    const hashAt = url.indexOf("#");
+    const hash = hashAt >= 0 ? url.substring(hashAt) : "";
+    const body = hashAt >= 0 ? url.substring(0, hashAt) : url;
+    const sep = body.includes("?") ? (body.endsWith("?") || body.endsWith("&") ? "" : "&") : "?";
+    return body + sep + "v=" + encodeURIComponent(version) + hash;
+  }
+
+  /** Runtime asset next to the widget script, version-busted when a version is known. */
+  function assetUrl(baseUrl, name, version) {
+    const base = baseUrl ? baseUrl.replace(/\/?$/, "/") : "";
+    return withVersion(base + name, version);
+  }
+
+  /** `https://huggingface.co/<repo>/resolve/<revision>/<file>` */
+  function hfFileUrl(repo, revision, file) {
+    const rev = encodeURIComponent(revision || "main");
+    const path = String(file).split("/").map(encodeURIComponent).join("/");
+    return `${HF_HOST}/${repo}/resolve/${rev}/${path}`;
+  }
+
+  /** IndexedDB key for a cached model file. */
+  function cacheKey(repo, revision, file) {
+    return `${repo}@${revision || "main"}/${file}`;
+  }
+
+  const HF_RESOLVE_RE = /^https:\/\/huggingface\.co\/([^/]+\/[^/]+)\/resolve\/([^/]+)\/([^?#]+)/;
+
+  /** The `cacheKey` of an `hfFileUrl`-shaped URL, or null for any other URL. */
+  function cacheKeyFromUrl(url) {
+    const m = HF_RESOLVE_RE.exec(String(url || ""));
+    if (!m) return null;
+    return cacheKey(m[1], decodeURIComponent(m[2]), m[3].split("/").map(decodeURIComponent).join("/"));
+  }
+
+  function isWeightsFile(file) {
+    return /\.(safetensors|onnx|onnx_data|bin|data|pt|gguf)$/i.test(String(file));
+  }
+
+  /** Per-file fetch timeout: 10 minutes for weights, 60 seconds for everything else. */
+  function timeoutForFile(file) {
+    return isWeightsFile(file) ? 600000 : 60000;
+  }
+
+  return {
+    HF_HOST,
+    baseUrlOf,
+    versionOf,
+    withVersion,
+    assetUrl,
+    hfFileUrl,
+    cacheKey,
+    cacheKeyFromUrl,
+    isWeightsFile,
+    timeoutForFile,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Dense-lane selection, download sizes, consent copy and degraded-arm notices.
+// Pure functions over the index manifest (see src/manifest.rs).
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  const DEFAULT_WASM_FILES = ["config.json", "tokenizer.json", "model.safetensors"];
+
+  // Approximate download sizes (bytes) keyed by lower-cased HuggingFace repo.
+  const DOWNLOAD_SIZES = {
+    "sentence-transformers/multi-qa-minilm-l6-cos-v1": 91e6,
+    "sentence-transformers/all-minilm-l6-v2": 91e6,
+    "sentence-transformers/all-minilm-l12-v2": 134e6,
+    "sentence-transformers/paraphrase-multilingual-minilm-l12-v2": 471e6,
+    "baai/bge-small-en-v1.5": 134e6,
+    "baai/bge-base-en-v1.5": 438e6,
+    "onnx-community/qwen3-embedding-0.6b-onnx": 900e6,
+    "onnx-community/harrier-oss-v1-0.6b-onnx": 400e6,
+    "xenova/bge-m3": 570e6,
+  };
+
+  function laneKind(lane) {
+    return lane && lane.runtime ? lane.runtime.kind : null;
+  }
+
+  function isWasmLane(lane) {
+    return laneKind(lane) === "wasm-candle";
+  }
+
+  function isWebGpuLane(lane) {
+    return laneKind(lane) === "webgpu-onnx";
+  }
+
+  /** Repo the runtime downloads from. */
+  function laneRepo(lane) {
+    if (isWebGpuLane(lane)) return lane.runtime.repo;
+    return lane.model;
+  }
+
+  /**
+   * HuggingFace revision for the runtime's downloads. `lane.revision` pins
+   * `lane.model` (the repo the indexer used); a webgpu-onnx lane downloads
+   * from a different repo (`runtime.repo`) that the manifest does not pin.
+   */
+  function laneRevision(lane) {
+    if (isWebGpuLane(lane)) return "main";
+    return lane.revision || "main";
+  }
+
+  /** Files a wasm-candle lane needs (config, tokenizer, weights). */
+  function laneFiles(lane) {
+    if (!isWasmLane(lane)) return [];
+    const files = Array.isArray(lane.runtime.files) ? lane.runtime.files : [];
+    return files.length ? files.slice() : DEFAULT_WASM_FILES.slice();
+  }
+
+  function isWeightsFile(file) {
+    return /\.(safetensors|bin|pt|gguf|onnx)$/i.test(String(file));
+  }
+
+  /**
+   * Why the WASM loader (init_dense_wasm) cannot run a wasm-candle lane, or
+   * null when it can: it accepts BERT-family lanes with config.json,
+   * tokenizer.json and exactly one unsharded model.safetensors.
+   */
+  function wasmLaneProblem(lane) {
+    if (!isWasmLane(lane)) return "not a wasm-candle lane";
+    if (lane.family && lane.family !== "bert") return `family ${lane.family} is not supported in WASM`;
+    const files = laneFiles(lane);
+    for (const need of ["config.json", "tokenizer.json"]) {
+      if (!files.includes(need)) return `runtime.files lacks ${need}`;
     }
-  } else if (msg.type === "search") {
-    try {
-      if (!initialized) {
-        throw new Error("Engine not initialized");
+    const weights = files.filter(isWeightsFile);
+    if (weights.length === 1 && weights[0] === "model.safetensors") return null;
+    if (weights.length === 0) return "runtime.files lists no weights file";
+    return `WASM needs a single model.safetensors, not ${weights.join(", ")}`;
+  }
+
+  /**
+   * Ordered dense-lane candidates for this browser, plus the lanes skipped
+   * because this runtime cannot load them (`skipped: [{lane, reason}]`).
+   * `denseRuntime`: "auto" | "wasm" | "webgpu"; `hasWebGpu`: an adapter was obtained.
+   */
+  function chooseDenseLanes(manifest, opts) {
+    const lanes = (manifest && Array.isArray(manifest.dense)) ? manifest.dense : [];
+    const runtime = (opts && opts.denseRuntime) || "auto";
+    const hasWebGpu = !!(opts && opts.hasWebGpu);
+    const webgpu = lanes.filter(isWebGpuLane);
+    const skipped = [];
+    const wasm = lanes.filter(isWasmLane).filter((lane) => {
+      const problem = wasmLaneProblem(lane);
+      if (problem) skipped.push({ lane, reason: problem });
+      return !problem;
+    });
+    if (lanes.length === 0) {
+      return { candidates: [], skipped, reason: "index has no dense lane" };
+    }
+    let candidates;
+    if (runtime === "wasm") {
+      candidates = wasm;
+    } else if (runtime === "webgpu") {
+      candidates = hasWebGpu ? webgpu : [];
+    } else {
+      candidates = hasWebGpu ? webgpu.concat(wasm) : wasm;
+    }
+    let reason = null;
+    if (candidates.length === 0) {
+      if (runtime === "wasm") reason = skipped.length ? "no wasm-candle lane the WASM loader can run" : "index has no wasm-candle lane";
+      else if (!hasWebGpu && webgpu.length && !wasm.length) reason = "no WebGPU adapter";
+      else if (runtime === "webgpu" && !hasWebGpu) reason = "no WebGPU adapter";
+      else if (runtime === "webgpu") reason = "index has no webgpu-onnx lane";
+      else reason = "no runnable dense lane";
+    }
+    return { candidates, skipped, reason };
+  }
+
+  /** transformers.js dtype for a webgpu-onnx lane on this adapter. */
+  function pickDtype(runtime, hasF16) {
+    if (hasF16 && runtime.dtype_f16) return runtime.dtype_f16;
+    return runtime.dtype || "fp32";
+  }
+
+  /** Approximate bytes a lane downloads on first use, or null when unknown. */
+  function laneDownloadBytes(lane) {
+    const repo = (laneRepo(lane) || "").toLowerCase();
+    return Object.prototype.hasOwnProperty.call(DOWNLOAD_SIZES, repo) ? DOWNLOAD_SIZES[repo] : null;
+  }
+
+  function formatBytes(n) {
+    if (n == null || !Number.isFinite(n)) return "unknown size";
+    if (n >= 1e9) {
+      const g = n / 1e9;
+      return (g >= 10 ? Math.round(g) : Math.round(g * 10) / 10) + " GB";
+    }
+    if (n >= 1e6) return Math.round(n / 1e6) + " MB";
+    if (n >= 1e3) return Math.round(n / 1e3) + " KB";
+    return n + " B";
+  }
+
+  /**
+   * Consent card copy for a model download. `consentText` (site override) may
+   * contain `{size}` and `{model}` placeholders.
+   */
+  function consentCopy(opts) {
+    const size = formatBytes(opts.sizeBytes);
+    const model = opts.model || "the search model";
+    if (opts.consentText) {
+      return opts.consentText.replace(/\{size\}/g, size).replace(/\{model\}/g, model);
+    }
+    const sized = opts.sizeBytes == null ? "a one-time download (size unknown)" : `a one-time ${size} download`;
+    let text = `Semantic search runs a language model in your browser. That needs ${sized} of ${model}, kept in your browser's cache for next time.`;
+    if (opts.saveData) {
+      text = "Data saver is on. " + text;
+    }
+    return text;
+  }
+
+  /**
+   * Drop degraded notes that describe the index design rather than a failure
+   * (an index without a dense lane or sparse arm is not "degraded").
+   */
+  function filterDesignDegraded(degraded) {
+    return (degraded || []).filter((d) => !/index has no (dense lane|sparse arm)/.test(d));
+  }
+
+  /** Human notice when a semantic arm is missing, or null when nothing to say. */
+  function degradedNotice(arms, degraded) {
+    const named = filterDesignDegraded(degraded).filter((d) => /^(dense|sparse)\b/.test(d));
+    if (named.length === 0) return null;
+    const a = arms || {};
+    if (!a.dense && !a.sparse) {
+      return "Keyword-only results: the semantic model isn't available.";
+    }
+    if (!a.dense) {
+      return "Keyword and sparse results only: the dense model isn't available.";
+    }
+    return "Results without the learned-sparse arm.";
+  }
+
+  return {
+    DEFAULT_WASM_FILES,
+    DOWNLOAD_SIZES,
+    laneKind,
+    isWasmLane,
+    isWebGpuLane,
+    laneRepo,
+    laneRevision,
+    laneFiles,
+    isWeightsFile,
+    wasmLaneProblem,
+    chooseDenseLanes,
+    pickDtype,
+    laneDownloadBytes,
+    formatBytes,
+    consentCopy,
+    filterDesignDegraded,
+    degradedNotice,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Streaming download with progress, per-attempt timeout and one retry, plus
+// SHA-256 verification. `fetch`, `sleep` and `subtle` are injectable for tests.
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  class HttpError extends Error {
+    constructor(url, status) {
+      super(`HTTP ${status} fetching ${url}`);
+      this.name = "HttpError";
+      this.status = status;
+      this.url = url;
+    }
+  }
+
+  function isRetryableStatus(status) {
+    return status === 429 || status === 408 || status >= 500;
+  }
+
+  function isNetworkError(err) {
+    if (!err) return false;
+    if (err.name === "AbortError" || err.name === "TimeoutError") return true;
+    if (err instanceof HttpError) return isRetryableStatus(err.status);
+    // fetch() rejects with a TypeError on network failures (ERR_NETWORK_CHANGED etc.)
+    return err.name === "TypeError";
+  }
+
+  async function readBody(response, onProgress) {
+    const lenHeader = response.headers && response.headers.get ? response.headers.get("Content-Length") : null;
+    const total = lenHeader && /^\d+$/.test(lenHeader) && Number(lenHeader) > 0 ? Number(lenHeader) : null;
+    if (onProgress) onProgress(0, total);
+    if (!response.body || typeof response.body.getReader !== "function") {
+      const buf = new Uint8Array(await response.arrayBuffer());
+      if (onProgress) onProgress(buf.length, total == null ? buf.length : total);
+      return buf;
+    }
+    const reader = response.body.getReader();
+    let loaded = 0;
+    if (total != null) {
+      const out = new Uint8Array(total);
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (loaded + value.length > total) {
+          throw new Error("response longer than Content-Length");
+        }
+        out.set(value, loaded);
+        loaded += value.length;
+        if (onProgress) onProgress(loaded, total);
       }
-      const mode = msg.mode || "hybrid";
-      const topK = msg.topK || 5;
-      if (typeof wasm_bindgen.search_with_answer !== "function") {
-        throw new Error("WASM does not expose search_with_answer");
+      if (loaded !== total) {
+        throw new TypeError(`incomplete response: ${loaded} of ${total} bytes`);
       }
-      const bundle = wasm_bindgen.search_with_answer(
-        msg.query,
-        topK,
-        msg.answerTopK || 5,
-        mode,
-        !!msg.answerMode,
-        msg.qaSubject || ""
-      );
-      self.postMessage({
-        type: "search_result",
-        requestId: msg.requestId,
-        results: bundle.results || [],
-        answer: bundle.answer || null,
-      });
-    } catch (err) {
-      // Keep UX alive on occasional wasm/runtime faults by degrading to keyword lane.
+      return out;
+    }
+    const chunks = [];
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      loaded += value.length;
+      if (onProgress) onProgress(loaded, null);
+    }
+    const out = new Uint8Array(loaded);
+    let offset = 0;
+    for (const c of chunks) {
+      out.set(c, offset);
+      offset += c.length;
+    }
+    return out;
+  }
+
+  /**
+   * Download `url` as a Uint8Array.
+   * opts: { fetch, timeoutMs (per attempt), retries (default 1), backoffMs (default 1500),
+   *         onProgress(loaded, total|null), sleep, signal }
+   * Retries once on network errors, timeouts, 408/429/5xx. 4xx is final.
+   */
+  async function fetchBytes(url, opts) {
+    const o = opts || {};
+    const doFetch = o.fetch || globalThis.fetch;
+    const sleep = o.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const retries = o.retries == null ? 1 : o.retries;
+    const backoffMs = o.backoffMs == null ? 1500 : o.backoffMs;
+    let lastErr = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      const controller = typeof AbortController === "function" ? new AbortController() : null;
+      let timer = null;
+      if (controller && o.timeoutMs) {
+        timer = setTimeout(() => controller.abort(), o.timeoutMs);
+      }
+      const onOuterAbort = () => controller && controller.abort();
+      if (o.signal && controller) o.signal.addEventListener("abort", onOuterAbort);
       try {
-        if (typeof wasm_bindgen.search_with_answer !== "function") {
-          throw err;
+        const response = await doFetch(url, { signal: controller ? controller.signal : undefined, cache: "default" });
+        if (!response.ok) {
+          throw new HttpError(url, response.status);
         }
-        const fallback = wasm_bindgen.search_with_answer(
-          msg.query,
-          msg.topK || 5,
-          msg.answerTopK || 5,
-          "keyword",
-          false,
-          msg.qaSubject || ""
-        );
-        self.postMessage({
-          type: "search_result",
-          requestId: msg.requestId,
-          results: fallback.results || [],
-          answer: null,
-          degraded: true,
-          laneError: err.message || String(err),
-        });
-      } catch (fallbackErr) {
-        self.postMessage({
-          type: "error",
-          requestId: msg.requestId,
-          error: fallbackErr.message || fallbackErr.toString(),
-        });
+        return await readBody(response, o.onProgress);
+      } catch (err) {
+        lastErr = err;
+        if (o.signal && o.signal.aborted) throw err;
+        if (attempt < retries && isNetworkError(err)) {
+          await sleep(backoffMs * (attempt + 1));
+          continue;
+        }
+        throw err;
+      } finally {
+        if (timer) clearTimeout(timer);
+        if (o.signal && controller) o.signal.removeEventListener("abort", onOuterAbort);
       }
     }
+    throw lastErr;
+  }
+
+  function toHex(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let s = "";
+    for (let i = 0; i < bytes.length; i++) {
+      s += bytes[i].toString(16).padStart(2, "0");
+    }
+    return s;
   }
+
+  async function sha256Hex(bytes, subtle) {
+    const s = subtle || (globalThis.crypto && globalThis.crypto.subtle);
+    if (!s) throw new Error("crypto.subtle unavailable");
+    const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    return toHex(await s.digest("SHA-256", view));
+  }
+
+  /** True when the SHA-256 of `bytes` equals `expectedHex` (case-insensitive, optional "sha256:" prefix). */
+  async function verifySha256(bytes, expectedHex, subtle) {
+    if (!expectedHex) return false;
+    const want = String(expectedHex).replace(/^sha256:/i, "").trim().toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(want)) return false;
+    const got = await sha256Hex(bytes, subtle);
+    return got === want;
+  }
+
+  return { HttpError, isNetworkError, isRetryableStatus, fetchBytes, sha256Hex, verifySha256, toHex };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Eddie search worker (classic worker).
+//
+// widget/build.sh concatenates widget/src/lib/*.js ahead of this file, so the
+// pure helpers are available as `EddieLib`. The WASM glue is loaded with
+// importScripts; transformers.js (WebGPU dense lane) with a dynamic import().
+//
+// Protocol (main thread -> worker):
+//   init        {indexUrl, baseUrl, version?, denseRuntime?, consent?}
+//   cache_check {requestId}
+//   search      {requestId, query, topK?, mode?, evidence?, qa?}
+//   page        {requestId, url}
+//   chunk       {requestId, id}
+//   qa          {requestId, query, k?}
+// (worker -> main thread):
+//   status        {state, ...}   loading_wasm | loading_index | index_ready |
+//                                consent_required | downloading_model |
+//                                loading_model | error
+//   ready         {lanes, lane, arms, degraded, manifest}
+//   cache_result  {requestId, cached, lane, sizeBytes}
+//   search_result {requestId, results, arms, degraded, mode, qa?}
+//   page_result   {requestId, page}
+//   chunk_result  {requestId, chunk}
+//   qa_result     {requestId, hits}
+//   error         {requestId?, message, fatal?, unsupported?}
+
+"use strict";
+
+const IDB_NAME = "eddie-models";
+const IDB_VERSION = 2;
+const IDB_FILES = "files";
+const IDB_META = "meta";
+const TRANSFORMERS_URL = "https://cdn.jsdelivr.net/npm/@huggingface/transformers@4.2.0";
+const PROGRESS_INTERVAL_MS = 80;
+
+const lib = EddieLib;
+
+const state = {
+  phase: "idle", // idle | loading | awaiting_consent | ready | error | dead
+  initRunning: false,
+  rerun: false,
+  baseUrl: "",
+  version: null,
+  indexUrl: null,
+  denseRuntime: "auto",
+  consent: Object.create(null), // lane id -> true
+  wasmReady: false,
+  indexLoaded: false,
+  manifest: null,
+  candidates: [],
+  candidateReason: null,
+  laneIndex: 0,
+  dense: null, // { lane, kind: "wasm" | "webgpu", embed? }
+  sparse: false,
+  degraded: [],
+  gpu: null, // { adapter, hasF16, maxBufferSize } | false
+  db: undefined, // IDBDatabase | null (unavailable)
 };
 
-async function initialize(indexUrl, workerBaseUrl) {
-  baseUrl = workerBaseUrl || "";
+self.onmessage = function (e) {
+  const msg = e.data || {};
+  switch (msg.type) {
+    case "init":
+      handleInit(msg);
+      break;
+    case "cache_check":
+      handleCacheCheck(msg);
+      break;
+    case "search":
+      handleSearch(msg);
+      break;
+    case "page":
+      handleLookup(msg, "page_result", "page", () => wasm_bindgen.page(String(msg.url)));
+      break;
+    case "chunk":
+      handleLookup(msg, "chunk_result", "chunk", () => wasm_bindgen.chunk(Number(msg.id)));
+      break;
+    case "qa":
+      handleQa(msg);
+      break;
+    default:
+      postError(msg.requestId, `unknown message type ${String(msg.type)}`);
+  }
+};
+
+// -- init ---------------------------------------------------------------
+
+function handleInit(msg) {
+  if (state.phase === "dead") {
+    postError(null, "search engine crashed; reload the page to retry", true);
+    return;
+  }
+  if (msg.indexUrl) state.indexUrl = String(msg.indexUrl);
+  if (msg.baseUrl != null) state.baseUrl = String(msg.baseUrl);
+  if (msg.version != null) state.version = msg.version ? String(msg.version) : null;
+  if (msg.denseRuntime) state.denseRuntime = String(msg.denseRuntime);
+  if (msg.consent === true) {
+    const lane = currentCandidate();
+    if (lane) state.consent[lane.id] = true;
+    if (msg.consentLane) state.consent[String(msg.consentLane)] = true;
+  }
+  runInit();
+}
 
-  // 1. Load WASM glue + instantiate
+async function runInit() {
+  if (state.initRunning) {
+    state.rerun = true;
+    return;
+  }
+  state.initRunning = true;
+  try {
+    state.phase = "loading";
+    await ensureWasm();
+    await ensureIndex();
+    await ensureDb();
+    await ensureGpu();
+    await ensureSparse();
+    const outcome = await ensureDense();
+    if (outcome === "consent") {
+      state.phase = "awaiting_consent";
+      return;
+    }
+    state.phase = "ready";
+    postReady();
+    evictStaleFiles();
+  } catch (err) {
+    state.phase = isFatal(err) ? "dead" : "error";
+    postStatus("error", {
+      message: describe(err),
+      fatal: isFatal(err),
+      unsupported: isUnsupported(err),
+    });
+  } finally {
+    state.initRunning = false;
+    if (state.rerun) {
+      state.rerun = false;
+      runInit();
+    }
+  }
+}
+
+async function ensureWasm() {
+  if (state.wasmReady) return;
   postStatus("loading_wasm");
-  const wasmGlueUrl = resolveUrl("eddie-wasm.js");
-  importScripts(wasmGlueUrl);
-  const wasmBinaryUrl = resolveUrl("eddie.wasm");
-  await wasm_bindgen(wasmBinaryUrl);
-
-  // 2. Fetch index
-  postStatus("loading_index");
-  const indexResponse = await fetch(indexUrl);
-  if (!indexResponse.ok) {
-    throw new Error(`Failed to fetch index: ${indexResponse.status}`);
-  }
-  const indexBytes = new Uint8Array(await indexResponse.arrayBuffer());
-
-  // 3. Parse model ID from index bytes (supports raw .bin and compressed .ed)
-  const modelId = wasm_bindgen.extract_model_id(indexBytes);
-
-  // 4. Fetch model files (with IndexedDB cache)
-  postStatus("checking_cache");
-  const db = await openModelDB();
-
-  const config = await getCachedOrFetch(
-    db,
-    modelId,
-    "config.json",
-    (loaded, total) => postStatus("downloading_model", { progress: loaded / total, file: "config.json" })
-  );
-  const tokenizer = await getCachedOrFetch(
-    db,
-    modelId,
-    "tokenizer.json",
-    (loaded, total) => postStatus("downloading_model", { progress: loaded / total, file: "tokenizer.json" })
-  );
-  const weights = await getCachedOrFetch(
-    db,
-    modelId,
-    "model.safetensors",
-    (loaded, total) => postStatus("downloading_model", { progress: loaded / total, file: "model.safetensors" })
-  );
-
-  // 5. Initialize WASM engine
-  postStatus("initializing");
-  wasm_bindgen.init_engine(
-    new Uint8Array(config),
-    new Uint8Array(tokenizer),
-    new Uint8Array(weights),
-    indexBytes
-  );
-
-  initialized = true;
-  postStatus("ready");
-}
-
-// -- IndexedDB helpers --
-function openModelDB() {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(IDB_NAME, 1);
-    req.onupgradeneeded = () => {
-      req.result.createObjectStore(IDB_STORE);
-    };
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
+  if (typeof WebAssembly !== "object") {
+    throw unsupported("This browser can't run WebAssembly.");
+  }
+  try {
+    importScripts(lib.assetUrl(state.baseUrl, "eddie-wasm.js", state.version));
+    await wasm_bindgen({ module_or_path: lib.assetUrl(state.baseUrl, "eddie.wasm", state.version) });
+  } catch (err) {
+    if (err instanceof WebAssembly.CompileError || err instanceof WebAssembly.LinkError) {
+      throw unsupported("This browser can't run the search engine (WebAssembly SIMD is required).");
+    }
+    throw err;
+  }
+  state.wasmReady = true;
+}
+
+async function ensureIndex() {
+  if (state.indexLoaded) return;
+  if (!state.indexUrl) throw new Error("init: indexUrl is required");
+  postStatus("loading_index", { progress: null });
+  let last = 0;
+  const bytes = await lib.fetchBytes(state.indexUrl, {
+    timeoutMs: 180000,
+    onProgress: (loaded, total) => {
+      const now = Date.now();
+      if (total && now - last < PROGRESS_INTERVAL_MS && loaded !== total) return;
+      last = now;
+      postStatus("loading_index", { progress: total ? loaded / total : null, loaded, total });
+    },
   });
+  state.manifest = JSON.parse(wasm_bindgen.manifest(bytes));
+  wasm_bindgen.init_index(bytes);
+  state.indexLoaded = true;
+  state.dense = null;
+  state.sparse = false;
+  state.degraded = [];
+  state.laneIndex = 0;
+  postStatus("index_ready", { manifest: manifestSummary(), lanes: laneList() });
 }
 
-function idbGet(db, key) {
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(IDB_STORE, "readonly");
-    const req = tx.objectStore(IDB_STORE).get(key);
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
+async function ensureGpu() {
+  if (state.gpu !== null) return;
+  state.gpu = false;
+  try {
+    if (state.denseRuntime !== "wasm" && self.navigator && navigator.gpu && typeof navigator.gpu.requestAdapter === "function") {
+      const adapter = await navigator.gpu.requestAdapter();
+      if (adapter) {
+        state.gpu = {
+          adapter,
+          hasF16: !!(adapter.features && adapter.features.has("shader-f16")),
+          maxBufferSize: adapter.limits ? adapter.limits.maxBufferSize : 0,
+        };
+      }
+    }
+  } catch (err) {
+    console.warn("eddie: WebGPU adapter probe failed", err);
+    state.gpu = false;
+  }
+  const choice = lib.chooseDenseLanes(state.manifest, {
+    denseRuntime: state.denseRuntime,
+    hasWebGpu: !!state.gpu,
   });
+  state.candidates = choice.candidates;
+  state.candidateReason = choice.reason;
+  for (const { lane, reason } of choice.skipped) {
+    console.warn(`eddie: dense lane ${lane.id} skipped: ${reason}`);
+    state.degraded.push(`dense: lane ${lane.id} skipped: ${reason}`);
+  }
 }
 
-function idbPut(db, key, value) {
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(IDB_STORE, "readwrite");
-    const req = tx.objectStore(IDB_STORE).put(value, key);
-    req.onsuccess = () => resolve();
-    req.onerror = () => reject(req.error);
+async function ensureSparse() {
+  if (state.sparse) return;
+  const spec = state.manifest && state.manifest.sparse;
+  if (!spec) return;
+  if (state.degraded.some((d) => d.startsWith("sparse:"))) return;
+  try {
+    const repo = spec.tokenizer || spec.model;
+    const rev = spec.revision || "main";
+    let bytes = await getModelFile(repo, rev, "tokenizer.json", "sparse");
+    let ok = await lib.verifySha256(bytes, spec.vocab_hash);
+    if (!ok && bytes.fromCache) {
+      await idbDelete(lib.cacheKey(repo, rev, "tokenizer.json"));
+      bytes = await getModelFile(repo, rev, "tokenizer.json", "sparse", { noCache: true });
+      ok = await lib.verifySha256(bytes, spec.vocab_hash);
+    }
+    if (!ok) {
+      throw new Error("tokenizer.json SHA-256 does not match the index's vocab_hash");
+    }
+    wasm_bindgen.init_sparse_tokenizer(bytes);
+    state.sparse = true;
+  } catch (err) {
+    if (isFatal(err)) throw err;
+    console.warn("eddie: sparse arm unavailable", err);
+    state.degraded.push(`sparse: ${describe(err)}`);
+  }
+}
+
+/** Returns "ok" (a lane is loaded), "consent" (waiting for the visitor) or "none". */
+async function ensureDense() {
+  if (state.dense) return "ok";
+  for (; state.laneIndex < state.candidates.length; state.laneIndex++) {
+    const lane = state.candidates[state.laneIndex];
+    try {
+      const cached = await laneCached(lane);
+      if (!cached && !state.consent[lane.id]) {
+        postStatus("consent_required", {
+          lane: laneSummary(lane),
+          sizeBytes: lib.laneDownloadBytes(lane),
+          saveData: !!(self.navigator && navigator.connection && navigator.connection.saveData),
+        });
+        return "consent";
+      }
+      if (lib.isWasmLane(lane)) {
+        await loadWasmLane(lane);
+      } else {
+        await loadWebGpuLane(lane);
+      }
+      return "ok";
+    } catch (err) {
+      if (isFatal(err)) throw err;
+      console.warn(`eddie: dense lane ${lane.id} failed`, err);
+      state.degraded.push(`dense: lane ${lane.id} failed: ${describe(err)}`);
+    }
+  }
+  if (state.candidates.length === 0 && state.candidateReason && (state.manifest.dense || []).length > 0) {
+    if (!state.degraded.some((d) => d.startsWith("dense:"))) {
+      state.degraded.push(`dense: ${state.candidateReason}`);
+    }
+  }
+  return "none";
+}
+
+async function loadWasmLane(lane) {
+  const repo = lib.laneRepo(lane);
+  const rev = lib.laneRevision(lane);
+  const files = lib.laneFiles(lane);
+  const loaded = {};
+  for (const file of files) {
+    loaded[file] = await getModelFile(repo, rev, file, lane.id);
+  }
+  postStatus("loading_model", { lane: laneSummary(lane) });
+  const config = loaded["config.json"];
+  const tokenizer = loaded["tokenizer.json"];
+  const weights = files.map((f) => loaded[f]).find((b, i) => lib.isWeightsFile(files[i]));
+  if (!config || !tokenizer || !weights) {
+    throw new Error(`lane ${lane.id}: runtime.files must include config.json, tokenizer.json and a weights file`);
+  }
+  wasm_bindgen.init_dense_wasm(lane.id, config, tokenizer, weights);
+  state.dense = { lane, kind: "wasm" };
+}
+
+async function loadWebGpuLane(lane) {
+  const runtime = lane.runtime;
+  postStatus("loading_model", { lane: laneSummary(lane), file: "transformers.js" });
+  const tf = await import(TRANSFORMERS_URL);
+  if (state.db && tf.env) {
+    // Keep the ONNX files in the same IndexedDB store as the wasm lanes: the
+    // Cache API rejects multi-hundred-MB entries on some profiles, and one
+    // store means one eviction policy (evictStaleFiles) and one consent check.
+    tf.env.useCustomCache = true;
+    tf.env.customCache = transformersCache();
+  }
+  const dtype = lib.pickDtype(runtime, state.gpu && state.gpu.hasF16);
+  let last = 0;
+  const extractor = await tf.pipeline("feature-extraction", runtime.repo, {
+    device: "webgpu",
+    dtype,
+    revision: lib.laneRevision(lane),
+    progress_callback: (p) => {
+      if (!p || p.status !== "progress") return;
+      const now = Date.now();
+      if (now - last < PROGRESS_INTERVAL_MS && p.progress < 100) return;
+      last = now;
+      postStatus("downloading_model", {
+        lane: laneSummary(lane),
+        file: p.file || p.name || "",
+        progress: typeof p.progress === "number" ? p.progress / 100 : null,
+        loaded: p.loaded,
+        total: p.total,
+      });
+    },
+  });
+  postStatus("loading_model", { lane: laneSummary(lane) });
+  const pooling = runtime.pooling || "mean";
+  const embed = async (text) => {
+    const prefixed = (lane.query_prefix || "") + text;
+    const out = await extractor(prefixed, { pooling, normalize: lane.normalize !== false });
+    const data = out.data instanceof Float32Array ? out.data : Float32Array.from(out.data);
+    if (typeof out.dispose === "function") out.dispose();
+    if (data.length !== lane.dim) {
+      throw new Error(`lane ${lane.id}: model produced ${data.length}-d vectors but the index stores ${lane.dim}-d`);
+    }
+    for (let i = 0; i < data.length; i++) {
+      if (!Number.isFinite(data[i])) {
+        throw new Error(`lane ${lane.id}: model produced a non-finite value at dimension ${i}`);
+      }
+    }
+    return data;
+  };
+  await embed("warm up");
+  state.dense = { lane, kind: "webgpu", embed, dtype };
+  await idbMetaPut(webGpuMarker(lane, dtype), Date.now());
+}
+
+function postReady() {
+  self.postMessage({
+    type: "ready",
+    lanes: laneList(),
+    lane: state.dense ? state.dense.lane.id : null,
+    runtime: state.dense ? state.dense.kind : null,
+    arms: { dense: !!state.dense, sparse: state.sparse, bm25: true },
+    degraded: lib.filterDesignDegraded(unique(state.degraded)),
+    manifest: manifestSummary(),
   });
 }
 
-async function getCachedOrFetch(db, modelId, filename, onProgress) {
-  const key = `${modelId}/${filename}`;
-  const cached = await idbGet(db, key);
-  if (cached) {
-    return cached;
+// -- cache check --------------------------------------------------------
+
+async function handleCacheCheck(msg) {
+  try {
+    await ensureWasm();
+    await ensureIndex();
+    await ensureDb();
+    await ensureGpu();
+    const lane = currentCandidate();
+    const cached = lane ? await laneCached(lane) : true;
+    self.postMessage({
+      type: "cache_result",
+      requestId: msg.requestId,
+      cached,
+      lane: lane ? laneSummary(lane) : null,
+      sizeBytes: lane ? lib.laneDownloadBytes(lane) : 0,
+    });
+  } catch (err) {
+    postError(msg.requestId, describe(err), isFatal(err));
   }
+}
 
-  const url = `${HF_CDN}/${modelId}/resolve/main/${filename}`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to download ${filename}: ${response.status}`);
+async function laneCached(lane) {
+  if (lib.isWasmLane(lane)) {
+    if (!state.db) return false;
+    const repo = lib.laneRepo(lane);
+    const rev = lib.laneRevision(lane);
+    for (const file of lib.laneFiles(lane)) {
+      if (!(await idbHas(lib.cacheKey(repo, rev, file)))) return false;
+    }
+    return true;
   }
+  const dtype = lib.pickDtype(lane.runtime, state.gpu && state.gpu.hasF16);
+  return !!(await idbMetaGet(webGpuMarker(lane, dtype)));
+}
+
+function webGpuMarker(lane, dtype) {
+  return `webgpu:${lane.runtime.repo}@${lib.laneRevision(lane)}#${dtype}`;
+}
 
-  const contentLength = parseInt(response.headers.get("Content-Length") || "0", 10);
-  const reader = response.body.getReader();
-  const chunks = [];
-  let loaded = 0;
+// -- queries ------------------------------------------------------------
 
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    chunks.push(value);
-    loaded += value.length;
-    if (contentLength > 0) {
-      onProgress(loaded, contentLength);
+/**
+ * Query vector from the WebGPU lane, or nothing (the WASM lane embeds inside
+ * search()). An embedding failure degrades the dense arm for this query
+ * instead of failing the search; `note` carries the reason.
+ */
+async function queryVector(query, mode) {
+  if (!state.dense || state.dense.kind !== "webgpu") return { laneId: null, vec: null, note: null };
+  if (mode !== "hybrid" && mode !== "dense") return { laneId: null, vec: null, note: null };
+  try {
+    const vec = await state.dense.embed(query);
+    return { laneId: state.dense.lane.id, vec, note: null };
+  } catch (err) {
+    console.warn(`eddie: dense lane ${state.dense.lane.id} query embedding failed`, err);
+    return { laneId: null, vec: null, note: `dense: embedding failed for lane ${state.dense.lane.id}: ${describe(err)}` };
+  }
+}
+
+async function handleSearch(msg) {
+  const requestId = msg.requestId;
+  try {
+    requireIndex();
+    const query = String(msg.query || "").trim();
+    if (!query) throw new Error("search: empty query");
+    const mode = msg.mode || "hybrid";
+    const topK = Number(msg.topK) > 0 ? Number(msg.topK) : 8;
+    const { laneId, vec, note } = await queryVector(query, mode);
+    const res = JSON.parse(wasm_bindgen.search(query, topK, mode, laneId, vec));
+    if (note) res.degraded = (res.degraded || []).concat([note]);
+    const results = res.results || [];
+    if (msg.evidence) {
+      for (const r of results) {
+        try {
+          r.text = JSON.parse(wasm_bindgen.chunk(r.chunk)).text;
+        } catch (_) {
+          r.text = r.snippet;
+        }
+      }
+    }
+    let qa = undefined;
+    if (msg.qa && Number(msg.qa) > 0 && hasSection("qa") && (vec || !laneId)) {
+      qa = JSON.parse(wasm_bindgen.qa_lookup(query, laneId, vec, Number(msg.qa)));
     }
+    self.postMessage({
+      type: "search_result",
+      requestId,
+      results,
+      arms: res.arms,
+      degraded: lib.filterDesignDegraded(unique((res.degraded || []).concat(state.degraded))),
+      mode: res.mode,
+      lane: res.dense_lane || null,
+      qa,
+    });
+  } catch (err) {
+    failRequest(requestId, err);
+  }
+}
+
+function handleLookup(msg, type, key, fn) {
+  try {
+    requireIndex();
+    self.postMessage({ type, requestId: msg.requestId, [key]: JSON.parse(fn()) });
+  } catch (err) {
+    failRequest(msg.requestId, err);
   }
+}
 
-  // Concatenate chunks into single ArrayBuffer
-  const total = chunks.reduce((sum, c) => sum + c.length, 0);
-  const result = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.length;
+async function handleQa(msg) {
+  try {
+    requireIndex();
+    const query = String(msg.query || "").trim();
+    const k = Number(msg.k) > 0 ? Number(msg.k) : 3;
+    if (!query || !hasSection("qa")) {
+      self.postMessage({ type: "qa_result", requestId: msg.requestId, hits: [] });
+      return;
+    }
+    const { laneId, vec } = await queryVector(query, "dense");
+    const hits = JSON.parse(wasm_bindgen.qa_lookup(query, laneId, vec, k));
+    self.postMessage({ type: "qa_result", requestId: msg.requestId, hits });
+  } catch (err) {
+    failRequest(msg.requestId, err);
   }
+}
+
+function failRequest(requestId, err) {
+  if (isFatal(err)) {
+    // A trapped panic leaves the WASM instance unusable; never re-enter it.
+    state.phase = "dead";
+    postError(requestId, "search engine crashed: " + describe(err), true);
+    return;
+  }
+  postError(requestId, describe(err), false);
+}
+
+function requireIndex() {
+  if (state.phase === "dead") throw fatal("search engine crashed; reload to retry");
+  if (!state.indexLoaded) throw new Error("index not loaded yet");
+}
+
+function hasSection(name) {
+  return !!(state.manifest && Array.isArray(state.manifest.sections) && state.manifest.sections.includes(name));
+}
+
+// -- model files --------------------------------------------------------
+
+async function getModelFile(repo, rev, file, laneId, opts) {
+  const key = lib.cacheKey(repo, rev, file);
+  if (!(opts && opts.noCache)) {
+    const cached = await idbGet(key);
+    if (cached) {
+      const bytes = new Uint8Array(cached);
+      bytes.fromCache = true;
+      return bytes;
+    }
+  }
+  const url = lib.hfFileUrl(repo, rev, file);
+  let last = 0;
+  postStatus("downloading_model", { lane: laneId, file, progress: null, loaded: 0, total: null });
+  const bytes = await lib.fetchBytes(url, {
+    timeoutMs: lib.timeoutForFile(file),
+    retries: 1,
+    backoffMs: 1500,
+    onProgress: (loaded, total) => {
+      const now = Date.now();
+      if (now - last < PROGRESS_INTERVAL_MS && !(total && loaded === total)) return;
+      last = now;
+      postStatus("downloading_model", { lane: laneId, file, progress: total ? loaded / total : null, loaded, total });
+    },
+  });
+  await idbPut(key, bytes.buffer);
+  return bytes;
+}
+
+// -- IndexedDB (best effort: any failure only logs) --------------------
+
+async function ensureDb() {
+  if (state.db !== undefined) return;
+  state.db = null;
+  if (typeof indexedDB === "undefined") return;
+  try {
+    state.db = await new Promise((resolve, reject) => {
+      const req = indexedDB.open(IDB_NAME, IDB_VERSION);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(IDB_FILES)) db.createObjectStore(IDB_FILES);
+        if (!db.objectStoreNames.contains(IDB_META)) db.createObjectStore(IDB_META);
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error || new Error("indexedDB.open failed"));
+      req.onblocked = () => reject(new Error("indexedDB.open blocked"));
+    });
+  } catch (err) {
+    console.warn("eddie: model cache unavailable; files will be re-downloaded next visit", err);
+    state.db = null;
+  }
+}
+
+function idbRequest(store, mode, fn) {
+  if (!state.db) return Promise.resolve(undefined);
+  return new Promise((resolve) => {
+    try {
+      const tx = state.db.transaction(store, mode);
+      const req = fn(tx.objectStore(store));
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => {
+        console.warn("eddie: model cache operation failed", req.error);
+        resolve(undefined);
+      };
+    } catch (err) {
+      console.warn("eddie: model cache operation failed", err);
+      resolve(undefined);
+    }
+  });
+}
 
-  const buffer = result.buffer;
-  await idbPut(db, key, buffer);
-  return buffer;
+const idbGet = (key) => idbRequest(IDB_FILES, "readonly", (s) => s.get(key));
+const idbHas = async (key) => (await idbRequest(IDB_FILES, "readonly", (s) => s.getKey(key))) !== undefined;
+const idbPut = (key, value) => idbRequest(IDB_FILES, "readwrite", (s) => s.put(value, key));
+const idbDelete = (key) => idbRequest(IDB_FILES, "readwrite", (s) => s.delete(key));
+const idbMetaGet = (key) => idbRequest(IDB_META, "readonly", (s) => s.get(key));
+const idbMetaPut = (key, value) => idbRequest(IDB_META, "readwrite", (s) => s.put(value, key));
+
+/**
+ * transformers.js cache (`env.customCache`) over the model-file store.
+ * transformers.js calls `match`/`put` with string keys: the HuggingFace URL
+ * for remote files (mapped onto the repo@revision/file scheme) or a local
+ * model path (never stored, so `match` misses and the URL key is tried next).
+ */
+function transformersCache() {
+  const keyOf = (req) => {
+    const url = typeof req === "string" ? req : req && req.url ? req.url : String(req);
+    return lib.cacheKeyFromUrl(url) || "url:" + url;
+  };
+  return {
+    async match(req) {
+      const stored = await idbGet(keyOf(req));
+      if (!stored) return undefined;
+      const size = typeof stored.size === "number" ? stored.size : stored.byteLength;
+      return new Response(stored, { headers: { "Content-Length": String(size) } });
+    },
+    async put(req, response) {
+      const blob = await response.blob();
+      await idbPut(keyOf(req), blob);
+    },
+  };
 }
 
-// -- Utilities --
-function resolveUrl(filename) {
-  if (baseUrl) {
-    return baseUrl.replace(/\/$/, "") + "/" + filename;
+/** Delete cached files that belong to models this index no longer references. */
+async function evictStaleFiles() {
+  if (!state.db || !state.manifest) return;
+  const keep = ["url:"];
+  for (const lane of state.manifest.dense || []) {
+    keep.push(`${lib.laneRepo(lane)}@${lib.laneRevision(lane)}/`);
+  }
+  if (state.manifest.sparse) {
+    const s = state.manifest.sparse;
+    keep.push(`${s.tokenizer || s.model}@${s.revision || "main"}/`);
   }
-  return filename;
+  const keys = await idbRequest(IDB_FILES, "readonly", (s) => s.getAllKeys());
+  for (const key of keys || []) {
+    if (typeof key === "string" && !keep.some((p) => key.startsWith(p))) {
+      console.info("eddie: evicting cached model file", key);
+      await idbDelete(key);
+    }
+  }
+}
+
+// -- helpers ------------------------------------------------------------
+
+function currentCandidate() {
+  return state.candidates[state.laneIndex] || null;
+}
+
+function laneSummary(lane) {
+  return {
+    id: lane.id,
+    model: lane.model,
+    kind: lane.runtime ? lane.runtime.kind : null,
+    repo: lib.laneRepo(lane),
+    dim: lane.dim,
+  };
+}
+
+function laneList() {
+  return (state.manifest && state.manifest.dense ? state.manifest.dense : []).map(laneSummary);
+}
+
+function manifestSummary() {
+  const m = state.manifest || {};
+  return {
+    format: m.format,
+    eddie: m.eddie,
+    chunks: m.chunks,
+    pages: m.pages,
+    sections: m.sections || [],
+    sparse: !!m.sparse,
+  };
+}
+
+function unique(list) {
+  return Array.from(new Set(list));
+}
+
+function postStatus(stateName, extra) {
+  self.postMessage(Object.assign({ type: "status", state: stateName }, extra || {}));
+}
+
+function postError(requestId, message, isFatalErr, isUnsupported) {
+  self.postMessage({ type: "error", requestId: requestId == null ? undefined : requestId, message, fatal: !!isFatalErr, unsupported: !!isUnsupported });
+}
+
+function describe(err) {
+  if (err == null) return "unknown error";
+  if (typeof err === "string") return err;
+  if (err.message) return err.message;
+  return String(err);
+}
+
+function unsupported(message) {
+  const e = new Error(message);
+  e.eddieUnsupported = true;
+  e.eddieFatal = true;
+  return e;
+}
+
+function fatal(message) {
+  const e = new Error(message);
+  e.eddieFatal = true;
+  return e;
+}
+
+function isUnsupported(err) {
+  return !!(err && err.eddieUnsupported);
 }
 
-function postStatus(state, extra) {
-  self.postMessage({ type: "status", state, ...extra });
+function isFatal(err) {
+  if (!err) return false;
+  if (err.eddieFatal) return true;
+  return typeof WebAssembly === "object" && err instanceof WebAssembly.RuntimeError;
 }