eddie-jekyll 0.4.0 → 0.4.2

data/assets/eddie-sw-dense.js

@@ -0,0 +1,1873 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Generated by widget/build.sh from widget/src/eddie-sw.js and widget/src/lib/*.js; edit those instead.
+"use strict";
+const EDDIE_ASSET_VERSION = "c0fdc503e01a";
+import initLiteWasm, * as liteWasmApi from "./eddie-lite-esm.js?v=c0fdc503e01a";
+const EDDIE_LITE_WASM = "eddie-lite.wasm";
+import initDenseWasm, * as denseWasmApi from "./eddie-dense-esm.js?v=c0fdc503e01a";
+const EDDIE_SW_TIER = "dense";
+const EDDIE_DENSE_WASM = "eddie-dense.wasm", webllm = null, transformers = null;
+const EddieLib = {};
+// SPDX-License-Identifier: GPL-3.0-only
+
+// URL, version and cache-key helpers shared by the widget and the worker.
+
+(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 HF_HOST = "https://huggingface.co";
+
+  /**
+   * `?v=` of the runtime assets (widget, workers, wasm, glue, service
+   * workers): a hash of the files that produced them, stamped into every
+   * bundle by widget/build.sh. Deliberately not the index's version, which
+   * changes on every content rebuild and so re-downloaded the whole engine
+   * on every deploy; see "Script tag" in widget/README.md. null outside a
+   * bundle (the Node tests), which just means no `?v=`.
+   */
+  const ASSET_VERSION =
+    typeof EDDIE_ASSET_VERSION === "string" && EDDIE_ASSET_VERSION ? EDDIE_ASSET_VERSION : null;
+
+  /** 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);
+  }
+
+  /** 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;
+  }
+
+  /** 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,
+    ASSET_VERSION,
+    baseUrlOf,
+    versionOf,
+    withVersion,
+    assetUrl,
+    hfFileUrl,
+    cacheKey,
+    cacheKeyFromUrl,
+    isWeightsFile,
+    timeoutForFile,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Dense-lane selection and download sizes. Pure functions over the index
+// manifest (see src/manifest.rs). The consent and notice copy lives in
+// copy.js so the widget bundle does not carry the engine-side lane logic.
+
+(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));
+  }
+
+  /** Site-relative directory the lane's model files live in (`eddie index --bundle-model`), or null for HuggingFace. */
+  function laneBaseUrl(lane) {
+    const b = lane && lane.runtime && lane.runtime.base_url;
+    return typeof b === "string" && b.trim() ? b.trim() : null;
+  }
+
+  /** Where the lane's files are downloaded from: "site" (bundled next to the index) or "huggingface". */
+  function laneOrigin(lane) {
+    return laneBaseUrl(lane) ? "site" : "huggingface";
+  }
+
+  /** Absolute URL of a site-bundled model file, resolved against the index URL (no version parameter yet). */
+  function siteModelUrl(lane, file, indexUrl) {
+    const base = laneBaseUrl(lane);
+    if (!base) return null;
+    return new URL(base.replace(/\/?$/, "/") + String(file).replace(/^\//, ""), indexUrl).href;
+  }
+
+  /**
+   * Name a lane's file is cached under (see urls.js cacheKey): a bundled f16
+   * copy and the HuggingFace original differ, so site files get their own
+   * prefix and never collide with a repo download of the same name.
+   */
+  function laneFileName(lane, file) {
+    return laneBaseUrl(lane) ? "@site/" + file : String(file);
+  }
+
+  /** The sidecar entry that holds `scope`'s section of `laneId`, or null when the section is in the core file. */
+  function sidecarFor(manifest, scope, laneId) {
+    const list = manifest && Array.isArray(manifest.sidecars) ? manifest.sidecars : [];
+    return list.find((s) => s.scope === scope && s.lane === laneId) || null;
+  }
+
+  /** Bytes of the sidecar file(s) a lane's chunk vectors need, counted once per file. */
+  function laneSidecarBytes(manifest, laneId) {
+    const side = sidecarFor(manifest, "chunks", laneId);
+    return side && Number.isFinite(Number(side.bytes)) ? Number(side.bytes) : 0;
+  }
+
+  /**
+   * 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}`;
+    }
+    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);
+    // A pinned lane id (the visitor picked one in the settings panel, or the
+    // site set data-dense-lane): the choice narrows to that lane, and if it
+    // is not runnable here the result is no dense arm rather than a silently
+    // different model.
+    const pinned = (opts && opts.laneId) ? String(opts.laneId) : null;
+    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" };
+    }
+    if (runtime === "off") {
+      return { candidates: [], skipped, reason: "dense search is turned off" };
+    }
+    let candidates;
+    if (runtime === "wasm") {
+      candidates = wasm;
+    } else if (runtime === "webgpu") {
+      candidates = hasWebGpu ? webgpu : [];
+    } else {
+      candidates = hasWebGpu ? webgpu.concat(wasm) : wasm;
+    }
+    if (pinned) candidates = candidates.filter((lane) => lane.id === pinned);
+    let reason = null;
+    if (candidates.length === 0) {
+      if (pinned) reason = `lane ${pinned} cannot run here`;
+      else 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";
+  }
+
+  /** The exact byte count the manifest declares for a bundled model (`runtime.bytes`), or null. */
+  function laneDeclaredBytes(lane) {
+    const declared = lane && lane.runtime ? Number(lane.runtime.bytes) : NaN;
+    return Number.isFinite(declared) && declared > 0 ? declared : null;
+  }
+
+  /**
+   * Bytes a lane downloads on first use, or null when unknown: the exact
+   * count the manifest carries for a bundled model (`runtime.bytes`, written
+   * by `eddie index --bundle-model`), else the table estimate for known
+   * HuggingFace repos. The table describes the f32 originals; a bundled f16
+   * copy without `runtime.bytes` should be measured instead (the engine
+   * HEADs the files), never estimated from the table.
+   */
+  function laneDownloadBytes(lane) {
+    const declared = laneDeclaredBytes(lane);
+    if (declared != null) return declared;
+    const repo = (laneRepo(lane) || "").toLowerCase();
+    return Object.prototype.hasOwnProperty.call(DOWNLOAD_SIZES, repo) ? DOWNLOAD_SIZES[repo] : null;
+  }
+
+  return {
+    DEFAULT_WASM_FILES,
+    DOWNLOAD_SIZES,
+    laneKind,
+    isWasmLane,
+    isWebGpuLane,
+    laneRepo,
+    laneRevision,
+    laneFiles,
+    isWeightsFile,
+    laneBaseUrl,
+    laneOrigin,
+    siteModelUrl,
+    laneFileName,
+    sidecarFor,
+    laneSidecarBytes,
+    wasmLaneProblem,
+    chooseDenseLanes,
+    pickDtype,
+    laneDeclaredBytes,
+    laneDownloadBytes,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// User-facing copy shared by the widget and the search engine: byte
+// formatting, the download consent card and the degraded-arm notices.
+// Split out of lanes.js so the widget bundle carries only this, not the
+// engine-side lane selection.
+
+(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";
+
+  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}`, `{model}` and `{origin}` placeholders.
+   *   sizeBytes    model download (null when unknown)
+   *   origin       "site" | "huggingface" (where the model is fetched from)
+   *   sidecarBytes index vectors fetched from the site for this lane (0 when in the core index)
+   */
+  function consentCopy(opts) {
+    const size = formatBytes(opts.sizeBytes);
+    const model = opts.model || "the search model";
+    const origin = opts.origin === "site" ? "this site" : "huggingface.co";
+    if (opts.consentText) {
+      return opts.consentText.replace(/\{size\}/g, size).replace(/\{model\}/g, model).replace(/\{origin\}/g, origin);
+    }
+    const sized = opts.sizeBytes == null ? `a one-time download (size unknown) from ${origin}` : `a one-time ${size} download from ${origin}`;
+    const side = opts.sidecarBytes > 0 ? `, plus ${formatBytes(opts.sidecarBytes)} of index vectors from this site` : "";
+    let text = `Semantic search runs ${model} in your browser. That needs ${sized}${side}, 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").
+   */
+  /**
+   * Drop the "degraded" entries that describe how the index or the visitor
+   * chose to run, not something going wrong: an index built without a lane,
+   * and a visitor who picked keyword-only search in the settings panel.
+   */
+  function filterDesignDegraded(degraded) {
+    return (degraded || []).filter(
+      (d) => !/index has no (dense lane|sparse arm)|dense search is turned off/.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 {
+    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 headers = response.headers && response.headers.get ? response.headers : null;
+    const lenHeader = headers ? headers.get("Content-Length") : null;
+    // A compressed response (Content-Encoding: br/gzip) announces the wire
+    // size while the stream yields decoded bytes: the announced total is
+    // neither a buffer size nor a progress denominator then.
+    const encoding = headers ? String(headers.get("Content-Encoding") || "").trim().toLowerCase() : "";
+    const encoded = encoding !== "" && encoding !== "identity";
+    const total = !encoded && 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);
+      }
+      if (loaded !== total) {
+        throw new TypeError(`incomplete response: ${loaded} of ${total} bytes`);
+      }
+      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 {
+        const response = await doFetch(url, { signal: controller ? controller.signal : undefined, cache: "default" });
+        if (!response.ok) {
+          throw new HttpError(url, response.status);
+        }
+        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 engine, host-independent.
+//
+// Everything the search worker does (manifest, lane choice, downloads with
+// timeouts and retry, IndexedDB cache, sidecars, sparse tokenizer, the
+// transformers.js WebGPU lane, the WASM calls and the consent handshake)
+// lives here, behind an `env` the host supplies:
+//
+//   createSearchEngine({
+//     post(message)                 broadcast sink: status and ready events
+//     loadWasm(baseUrl, variant)
+//                                   -> Promise of the wasm-bindgen API object;
+//                                   variant is "lite" (always first) or
+//                                   "dense" (only when a wasm-candle lane is
+//                                   about to run); a host without the dense
+//                                   module rejects and the lane degrades
+//     loadTransformers()            -> Promise of the transformers.js module
+//     canRunWebGpuLane              false when this host cannot run webgpu-onnx lanes
+//     navigator, indexedDB          optional overrides (tests)
+//   })
+//
+// Lite first: the lite module (no model code, a quarter of the dense one
+// after brotli) answers keyword and sparse queries at once. When a visitor
+// accepts a CPU dense lane the dense module is loaded and the index, its
+// attached sidecars and the sparse tokenizer are handed over to it; the
+// bytes are kept only while that hand-over may still happen.
+//
+// `engine.handle(msg, reply)` dispatches one protocol message; `reply` is
+// the sink for that message's own answers (search_result, cache_result,
+// error with requestId ...). In a dedicated worker `post` and `reply` are
+// both `self.postMessage`; in the service worker `reply` is the requesting
+// page's port and `post` fans out to every connected page.
+//
+// The message shapes are documented in widget/README.md ("Worker protocol").
+
+(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 IDB_NAME = "eddie-models";
+  const IDB_VERSION = 2;
+  const IDB_FILES = "files";
+  const IDB_META = "meta";
+  const PROGRESS_INTERVAL_MS = 80;
+  const NOT_LOADED = "index not loaded yet";
+
+  /** What a wasm-bindgen API object can do; older glue without capabilities() is the full build. */
+  function wasmCapabilities(api) {
+    if (api && typeof api.capabilities === "function") {
+      try {
+        const c = JSON.parse(api.capabilities());
+        return { dense_wasm: !!c.dense_wasm, sparse: c.sparse !== false, version: c.version || null };
+      } catch (_) {
+        // fall through to feature detection
+      }
+    }
+    return { dense_wasm: !!(api && typeof api.init_dense_wasm === "function"), sparse: true, version: null };
+  }
+
+  function createSearchEngine(env) {
+    const lib = typeof EddieLib === "object" && EddieLib ? EddieLib : env.lib;
+    const post = env.post;
+    const nav = env.navigator !== undefined ? env.navigator : globalThis.navigator;
+    const idb = env.indexedDB !== undefined ? env.indexedDB : globalThis.indexedDB;
+    const canRunWebGpuLane = env.canRunWebGpuLane !== false;
+
+    let wasm = null; // wasm-bindgen API object once loaded (lite, then dense after a hand-over)
+    let caps = null; // wasmCapabilities(wasm)
+
+    const state = {
+      phase: "idle", // idle | loading | awaiting_consent | awaiting_tier | ready | error | dead
+      initRunning: false,
+      rerun: false,
+      baseUrl: "",
+      version: null,
+      indexUrl: null,
+      loadedIndexUrl: null,
+      denseRuntime: "auto",
+      laneId: null, // visitor-pinned dense lane (settings panel), or null
+      consent: Object.create(null), // lane id -> true
+      wasmReady: false,
+      indexLoaded: false,
+      manifest: null,
+      // Bytes kept for the lite -> dense hand-over (dropped once it is done or impossible).
+      indexBytes: null,
+      sparseBytes: null,
+      sidecarBytes: Object.create(null), // file -> Uint8Array
+      attachedSidecars: [], // file names attached to the current module
+      candidates: [],
+      candidateReason: null,
+      hostSkipped: [], // webgpu-onnx lane ids this host cannot run
+      laneIndex: 0,
+      dense: null, // { lane, kind: "wasm" | "webgpu", embed? }
+      sparse: false,
+      degraded: [],
+      gpu: null, // { adapter, hasF16, maxBufferSize } | false
+      db: undefined, // IDBDatabase | null (unavailable)
+      siteSizes: Object.create(null), // lane id -> measured bundled download bytes
+    };
+
+    // -- dispatch ---------------------------------------------------------
+
+    function handle(msg, reply) {
+      const m = msg || {};
+      const out = reply || post;
+      switch (m.type) {
+        case "init":
+          return handleInit(m, out);
+        case "cache_check":
+          return handleCacheCheck(m, out);
+        case "cache_clear":
+          return handleCacheClear(m, out);
+        case "search":
+          return handleSearch(m, out);
+        case "page":
+          return handleLookup(m, out, "page_result", "page", () => wasm.page(String(m.url)));
+        case "chunk":
+          return handleLookup(m, out, "chunk_result", "chunk", () => wasm.chunk(Number(m.id)));
+        case "qa":
+          return handleQa(m, out);
+        default:
+          postError(out, m.requestId, `unknown message type ${String(m.type)}`);
+          return Promise.resolve();
+      }
+    }
+
+    /**
+     * The degraded list as reported to the host: design choices dropped
+     * (copy.js), and the dense arm's entries dropped entirely when the
+     * visitor turned the dense arm off -- they asked for keyword and sparse,
+     * so nothing is missing.
+     */
+    function reportedDegraded(list) {
+      const filtered = lib.filterDesignDegraded(unique(list));
+      if (state.denseRuntime !== "off") return filtered;
+      return filtered.filter((d) => !String(d).startsWith("dense:"));
+    }
+
+    /** Snapshot for the service worker's `state` reply. */
+    function snapshot() {
+      return {
+        phase: state.phase,
+        indexUrl: state.loadedIndexUrl,
+        version: state.version,
+        indexLoaded: state.indexLoaded,
+        lane: state.dense ? state.dense.lane.id : null,
+        runtime: state.dense ? state.dense.kind : null,
+        arms: state.indexLoaded ? { dense: !!state.dense, sparse: state.sparse, bm25: true } : null,
+        degraded: reportedDegraded(state.degraded),
+        manifest: state.manifest ? manifestSummary() : null,
+        lanes: laneList(),
+        hostSkippedLanes: state.hostSkipped.slice(),
+        wasm: caps ? (caps.dense_wasm ? "dense" : "lite") : null,
+      };
+    }
+
+    // -- init ---------------------------------------------------------------
+
+    function handleInit(msg, reply) {
+      if (state.phase === "dead") {
+        postError(reply, null, "search engine crashed; reload the page to retry", true);
+        return Promise.resolve();
+      }
+      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;
+      const wasRuntime = state.denseRuntime;
+      const wasLane = state.laneId;
+      if (msg.denseRuntime) state.denseRuntime = String(msg.denseRuntime);
+      if (msg.laneId !== undefined) state.laneId = msg.laneId ? String(msg.laneId) : null;
+      if (state.denseRuntime !== wasRuntime || state.laneId !== wasLane) resetDenseSelection();
+      if (msg.consent === true) {
+        const lane = currentCandidate();
+        if (lane) state.consent[lane.id] = true;
+        if (msg.consentLane) state.consent[String(msg.consentLane)] = true;
+      }
+      return runInit();
+    }
+
+    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();
+        chooseLanes();
+        await ensureSparse();
+        const outcome = await ensureDense();
+        if (outcome === "consent") {
+          state.phase = "awaiting_consent";
+          return;
+        }
+        if (outcome === "tier") {
+          state.phase = "awaiting_tier";
+          return;
+        }
+        releaseHandoverBytes();
+        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 loadWasmVariant(variant) {
+      if (typeof WebAssembly !== "object") {
+        throw unsupported("This browser can't run WebAssembly.");
+      }
+      let api;
+      try {
+        api = await env.loadWasm(state.baseUrl, variant);
+      } catch (err) {
+        if (typeof WebAssembly === "object" && (err instanceof WebAssembly.CompileError || err instanceof WebAssembly.LinkError)) {
+          throw unsupported("This browser can't run the search engine (WebAssembly SIMD is required).");
+        }
+        throw err;
+      }
+      if (!api || typeof api.search !== "function") {
+        throw new Error(`loadWasm(${variant}) did not return the Eddie WASM API`);
+      }
+      return api;
+    }
+
+    async function ensureWasm() {
+      if (state.wasmReady) return;
+      postStatus("loading_wasm", { variant: "lite" });
+      wasm = await loadWasmVariant("lite");
+      caps = wasmCapabilities(wasm);
+      state.wasmReady = true;
+    }
+
+    /**
+     * Hand the loaded index over to the dense module (candle embedder) when
+     * the running one cannot embed. Everything the lite module was given is
+     * given again: index bytes, attached sidecars, a fetched sparse tokenizer.
+     */
+    async function ensureDenseWasm() {
+      if (caps && caps.dense_wasm) return;
+      if (!state.indexBytes) throw new Error("dense hand-over: index bytes were released");
+      postStatus("loading_wasm", { variant: "dense" });
+      const dense = await loadWasmVariant("dense");
+      const dcaps = wasmCapabilities(dense);
+      if (!dcaps.dense_wasm) throw new Error("eddie-dense.wasm has no CPU embedder (capabilities.dense_wasm is false)");
+      dense.init_index(state.indexBytes);
+      for (const file of state.attachedSidecars) {
+        if (state.sidecarBytes[file]) dense.attach_sidecar(state.sidecarBytes[file]);
+      }
+      if (state.sparse && state.sparseBytes) dense.init_sparse_tokenizer(state.sparseBytes);
+      wasm = dense;
+      caps = dcaps;
+    }
+
+    /** A wasm-candle lane could still ask for the dense module later. */
+    function handoverPossible() {
+      if (!caps || caps.dense_wasm || state.dense) return false;
+      return state.candidates.slice(state.laneIndex).some((lane) => lib.isWasmLane(lane));
+    }
+
+    function releaseHandoverBytes() {
+      if (handoverPossible()) return;
+      state.indexBytes = null;
+      state.sparseBytes = null;
+      state.sidecarBytes = Object.create(null);
+    }
+
+    async function ensureIndex() {
+      if (!state.indexUrl) throw new Error("init: indexUrl is required");
+      if (state.indexLoaded && state.loadedIndexUrl === state.indexUrl) return;
+      postStatus("loading_index", { progress: null });
+      let last = 0;
+      const bytes = await lib.fetchBytes(state.indexUrl, {
+        fetch: env.fetch,
+        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.manifest(bytes));
+      wasm.init_index(bytes);
+      state.indexBytes = bytes;
+      state.indexLoaded = true;
+      state.loadedIndexUrl = state.indexUrl;
+      state.dense = null;
+      state.sparse = false;
+      state.sparseBytes = null;
+      state.sidecarBytes = Object.create(null);
+      state.attachedSidecars = [];
+      state.degraded = [];
+      state.hostSkipped = [];
+      state.laneIndex = 0;
+      state.gpu = null;
+      state.siteSizes = Object.create(null);
+      postStatus("index_ready", { manifest: manifestSummary(), lanes: laneList(), hostSkippedLanes: state.hostSkipped.slice() });
+    }
+
+    async function ensureGpu() {
+      if (state.gpu !== null) return;
+      state.gpu = false;
+      try {
+        if (state.denseRuntime !== "wasm" && nav && nav.gpu && typeof nav.gpu.requestAdapter === "function") {
+          const adapter = await nav.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;
+      }
+    }
+
+    /**
+     * Pick the dense lanes to try, in order. Runs on every init, not just the
+     * first: the visitor can change `denseRuntime` or pin a lane from the
+     * settings panel at any time, and the answer has to change with it.
+     */
+    function chooseLanes() {
+      const choice = lib.chooseDenseLanes(state.manifest, {
+        denseRuntime: state.denseRuntime,
+        laneId: state.laneId,
+        hasWebGpu: !!state.gpu && canRunWebGpuLane,
+      });
+      state.candidates = choice.candidates;
+      state.candidateReason = choice.reason;
+      if (!canRunWebGpuLane) {
+        state.hostSkipped = (state.manifest.dense || []).filter(lib.isWebGpuLane).map((l) => l.id);
+      }
+      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}`);
+      }
+    }
+
+    /**
+     * Forget which dense lane is running so the next init picks again. Called
+     * when the visitor changes the lane or turns the dense arm off.
+     */
+    function resetDenseSelection() {
+      state.dense = null;
+      state.laneIndex = 0;
+      state.degraded = state.degraded.filter((d) => !String(d).startsWith("dense:"));
+      // The hand-over bytes are dropped once no wasm-candle lane is in play
+      // (releaseHandoverBytes). A visitor who then picks the CPU lane needs
+      // them back: re-read the index, which is an immutable-cached fetch.
+      if (!state.indexBytes && !(caps && caps.dense_wasm)) {
+        state.indexLoaded = false;
+      }
+    }
+
+    /**
+     * The sparse arm: nothing to fetch when the index embeds its vocabulary
+     * (`sparse_ready()` after init_index); otherwise tokenizer.json from the
+     * repo the manifest names, checked against `vocab_hash`.
+     */
+    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 {
+        if (typeof wasm.sparse_ready === "function" && wasm.sparse_ready()) {
+          state.sparse = true;
+          return;
+        }
+        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, env.subtle);
+        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, env.subtle);
+        }
+        if (!ok) {
+          throw new Error("tokenizer.json SHA-256 does not match the index's vocab_hash");
+        }
+        wasm.init_sparse_tokenizer(bytes);
+        state.sparse = true;
+        state.sparseBytes = bytes;
+      } 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", Object.assign(await consentDetails(lane), {
+              lanes: laneList(),
+              hostSkippedLanes: state.hostSkipped.slice(),
+            }));
+            return "consent";
+          }
+          await ensureSidecar(lane, "chunks");
+          if (lib.isWasmLane(lane)) {
+            await loadWasmLane(lane);
+          } else {
+            await loadWebGpuLane(lane);
+          }
+          return "ok";
+        } catch (err) {
+          if (isFatal(err)) throw err;
+          if (err && err.eddieTier) {
+            // This host lacks the runtime, another tier has it: let the
+            // widget move the search there and init again.
+            postStatus("tier_required", { tier: String(err.eddieTier), lane: laneSummary(lane), message: describe(err) });
+            return "tier";
+          }
+          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";
+    }
+
+    /** What the consent card needs: the lane, the real download size and where it comes from. */
+    async function consentDetails(lane) {
+      return {
+        lane: laneSummary(lane),
+        sizeBytes: await laneDownloadBytes(lane),
+        origin: lib.laneOrigin(lane),
+        sidecarBytes: lib.laneSidecarBytes(state.manifest, lane.id),
+        saveData: !!(nav && nav.connection && nav.connection.saveData),
+      };
+    }
+
+    /**
+     * Download size of a lane: the byte count the manifest declares
+     * (`runtime.bytes` on a bundled lane) or the table estimate; for a
+     * site-bundled wasm lane whose manifest predates `runtime.bytes`, the
+     * Content-Length of its files (one HEAD per file, same origin), or null
+     * when the server does not say.
+     */
+    async function laneDownloadBytes(lane) {
+      const declared = lib.laneDeclaredBytes(lane);
+      if (declared != null) return declared;
+      // The table estimates describe the HuggingFace originals; a bundled
+      // f16 copy is half that, so measure it rather than estimate.
+      if (lib.laneOrigin(lane) !== "site" || !lib.isWasmLane(lane)) return lib.laneDownloadBytes(lane);
+      if (state.siteSizes[lane.id] !== undefined) return state.siteSizes[lane.id];
+      const doFetch = env.fetch || globalThis.fetch;
+      let total = 0;
+      try {
+        for (const file of lib.laneFiles(lane)) {
+          const res = await doFetch(laneFileUrl(lane, file), { method: "HEAD" });
+          const len = res && res.ok && res.headers && res.headers.get ? Number(res.headers.get("Content-Length")) : NaN;
+          if (!Number.isFinite(len) || len <= 0) {
+            total = null;
+            break;
+          }
+          total += len;
+        }
+      } catch (_) {
+        total = null;
+      }
+      state.siteSizes[lane.id] = total;
+      return total;
+    }
+
+    /** `manifest.sidecars` file for (`scope`, lane), fetched next to the index and attached once. */
+    async function ensureSidecar(lane, scope) {
+      const side = lib.sidecarFor(state.manifest, scope, lane.id);
+      if (!side) return false;
+      if (state.attachedSidecars.includes(side.file)) return true;
+      const url = lib.withVersion(new URL(side.file, state.indexUrl).href, state.version);
+      let last = 0;
+      postStatus("loading_sidecar", { lane: laneSummary(lane), file: side.file, progress: null, loaded: 0, total: side.bytes || null });
+      const bytes = await lib.fetchBytes(url, {
+        fetch: env.fetch,
+        timeoutMs: 180000,
+        onProgress: (loaded, total) => {
+          const now = Date.now();
+          if (total && now - last < PROGRESS_INTERVAL_MS && loaded !== total) return;
+          last = now;
+          postStatus("loading_sidecar", { lane: laneSummary(lane), file: side.file, progress: total ? loaded / total : null, loaded, total });
+        },
+      });
+      if (typeof wasm.attach_sidecar !== "function") {
+        throw new Error("this WASM build cannot attach sidecars (rebuild the widget)");
+      }
+      wasm.attach_sidecar(bytes);
+      state.attachedSidecars.push(side.file);
+      if (handoverPossible()) state.sidecarBytes[side.file] = bytes;
+      return true;
+    }
+
+    function laneFileUrl(lane, file) {
+      const site = lib.siteModelUrl(lane, file, state.indexUrl);
+      if (site) return lib.withVersion(site, state.version);
+      return lib.hfFileUrl(lib.laneRepo(lane), lib.laneRevision(lane), file);
+    }
+
+    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, { url: laneFileUrl(lane, file), name: lib.laneFileName(lane, file) });
+      }
+      await ensureDenseWasm();
+      postStatus("loading_model", { lane: laneSummary(lane) });
+      const config = loaded["config.json"];
+      const tokenizer = loaded["tokenizer.json"];
+      const weightsName = files.find((f) => lib.isWeightsFile(f));
+      const weights = weightsName ? loaded[weightsName] : undefined;
+      if (!config || !tokenizer || !weights) {
+        throw new Error(`lane ${lane.id}: runtime.files must include config.json, tokenizer.json and a weights file`);
+      }
+      wasm.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 env.loadTransformers();
+      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();
+      }
+      if (tf.env) configureModelSource(tf.env, lane);
+      if (env.configureTransformers) env.configureTransformers(tf);
+      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());
+    }
+
+    /**
+     * Point transformers.js at the site-hosted copy of a webgpu-onnx repo
+     * when the manifest gives one (`runtime.base_url`, relative to the index
+     * URL; the directory mirrors the repo's file layout: config.json,
+     * tokenizer.json, onnx/model_q4.onnx ...). transformers.js joins
+     * remoteHost, remotePathTemplate and the file name with "/"; "." as the
+     * template keeps the model id out of the path and the URL parser folds
+     * the "./" away. Without a base_url the defaults (huggingface.co) are
+     * restored, since these settings are global to the module.
+     */
+    function configureModelSource(tfEnv, lane) {
+      const base = lib.siteModelUrl(lane, "", state.indexUrl);
+      if (base) {
+        tfEnv.allowRemoteModels = true;
+        tfEnv.remoteHost = base;
+        tfEnv.remotePathTemplate = ".";
+      } else {
+        tfEnv.remoteHost = "https://huggingface.co/";
+        tfEnv.remotePathTemplate = "{model}/resolve/{revision}/";
+      }
+    }
+
+    function readyMessage() {
+      return {
+        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: reportedDegraded(state.degraded),
+        manifest: manifestSummary(),
+        hostSkippedLanes: state.hostSkipped.slice(),
+        wasm: caps && caps.dense_wasm ? "dense" : "lite",
+      };
+    }
+
+    function postReady() {
+      post(readyMessage());
+    }
+
+    // -- cache check --------------------------------------------------------
+
+    async function handleCacheCheck(msg, reply) {
+      try {
+        if (state.phase === "dead") throw fatal("search engine crashed; reload to retry");
+        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.laneId !== undefined) state.laneId = msg.laneId ? String(msg.laneId) : null;
+        await ensureWasm();
+        await ensureIndex();
+        await ensureDb();
+        await ensureGpu();
+        chooseLanes();
+        const lane = currentCandidate();
+        const cached = lane ? await laneCached(lane) : true;
+        reply({
+          type: "cache_result",
+          requestId: msg.requestId,
+          cached,
+          lanes: laneList(),
+          lane: lane ? laneSummary(lane) : null,
+          sizeBytes: lane ? await laneDownloadBytes(lane) : 0,
+          origin: lane ? lib.laneOrigin(lane) : null,
+          sidecarBytes: lane ? lib.laneSidecarBytes(state.manifest, lane.id) : 0,
+          hostSkippedLanes: state.hostSkipped.slice(),
+          phase: state.phase,
+        });
+      } catch (err) {
+        if (isFatal(err)) state.phase = "dead";
+        postError(reply, msg.requestId, describe(err), isFatal(err));
+      }
+    }
+
+    /**
+     * Delete every cached model file. The engine keeps whatever it has
+     * already loaded into memory for this session; the files come back on the
+     * next visit that needs them.
+     */
+    async function handleCacheClear(msg, reply) {
+      let freedBytes = 0;
+      try {
+        await ensureDb();
+        const keys = (await idbRequest(IDB_FILES, "readonly", (s) => s.getAllKeys())) || [];
+        for (const key of keys) {
+          const value = await idbGet(key);
+          freedBytes += value ? (typeof value.size === "number" ? value.size : value.byteLength || 0) : 0;
+          await idbDelete(key);
+        }
+        const metaKeys = (await idbRequest(IDB_META, "readonly", (s) => s.getAllKeys())) || [];
+        for (const key of metaKeys) {
+          await idbRequest(IDB_META, "readwrite", (s) => s.delete(key));
+        }
+      } catch (err) {
+        console.warn("eddie: could not clear the model cache", err);
+      }
+      reply({ type: "cache_clear_result", requestId: msg.requestId, freedBytes });
+    }
+
+    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, lib.laneFileName(lane, 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}`;
+    }
+
+    // -- queries ------------------------------------------------------------
+
+    /**
+     * 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)}` };
+      }
+    }
+
+    /**
+     * The qa-scope vectors of the active lane live in a sidecar the first QA
+     * lookup fetches (never before: most searches never show the FAQ card).
+     * A failed fetch leaves the lexical ranking in place.
+     */
+    async function ensureQaVectors() {
+      if (!state.dense || !hasSection("qa")) return;
+      try {
+        await ensureSidecar(state.dense.lane, "qa");
+      } catch (err) {
+        if (isFatal(err)) throw err;
+        console.warn("eddie: qa sidecar unavailable; FAQ ranking is lexical", err);
+      }
+    }
+
+    async function handleSearch(msg, reply) {
+      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.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.chunk(r.chunk)).text;
+            } catch (_) {
+              r.text = r.snippet;
+            }
+          }
+        }
+        let qa = undefined;
+        if (msg.qa && Number(msg.qa) > 0 && hasSection("qa") && (vec || !laneId)) {
+          await ensureQaVectors();
+          qa = JSON.parse(wasm.qa_lookup(query, laneId, vec, Number(msg.qa)));
+        }
+        reply({
+          type: "search_result",
+          requestId,
+          results,
+          arms: res.arms,
+          degraded: reportedDegraded((res.degraded || []).concat(state.degraded)),
+          mode: res.mode,
+          lane: res.dense_lane || null,
+          qa,
+        });
+      } catch (err) {
+        failRequest(reply, requestId, err);
+      }
+    }
+
+    function handleLookup(msg, reply, type, key, fn) {
+      try {
+        requireIndex();
+        reply({ type, requestId: msg.requestId, [key]: JSON.parse(fn()) });
+      } catch (err) {
+        failRequest(reply, msg.requestId, err);
+      }
+      return Promise.resolve();
+    }
+
+    async function handleQa(msg, reply) {
+      try {
+        requireIndex();
+        const query = String(msg.query || "").trim();
+        const k = Number(msg.k) > 0 ? Number(msg.k) : 3;
+        if (!query || !hasSection("qa")) {
+          reply({ type: "qa_result", requestId: msg.requestId, hits: [] });
+          return;
+        }
+        await ensureQaVectors();
+        const { laneId, vec } = await queryVector(query, "dense");
+        const hits = JSON.parse(wasm.qa_lookup(query, laneId, vec, k));
+        reply({ type: "qa_result", requestId: msg.requestId, hits });
+      } catch (err) {
+        failRequest(reply, msg.requestId, err);
+      }
+    }
+
+    function failRequest(reply, requestId, err) {
+      if (isFatal(err)) {
+        // A trapped panic leaves the WASM instance unusable; never re-enter it.
+        state.phase = "dead";
+        postError(reply, requestId, "search engine crashed: " + describe(err), true);
+        return;
+      }
+      postError(reply, requestId, describe(err), false);
+    }
+
+    function requireIndex() {
+      if (state.phase === "dead") throw fatal("search engine crashed; reload to retry");
+      if (!state.indexLoaded) throw new Error(NOT_LOADED);
+    }
+
+    function hasSection(name) {
+      return !!(state.manifest && Array.isArray(state.manifest.sections) && state.manifest.sections.includes(name));
+    }
+
+    // -- model files --------------------------------------------------------
+
+    /**
+     * A model file from the IndexedDB cache or the network. `opts.url` and
+     * `opts.name` override the HuggingFace URL and cache name (site-bundled
+     * files); `opts.noCache` skips the cache read.
+     */
+    async function getModelFile(repo, rev, file, laneId, opts) {
+      const o = opts || {};
+      const key = lib.cacheKey(repo, rev, o.name || file);
+      if (!o.noCache) {
+        const cached = await idbGet(key);
+        if (cached) {
+          const bytes = new Uint8Array(cached);
+          bytes.fromCache = true;
+          return bytes;
+        }
+      }
+      const url = o.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, {
+        fetch: env.fetch,
+        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 (!idb) return;
+      try {
+        state.db = await new Promise((resolve, reject) => {
+          const req = idb.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 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);
+        },
+      };
+    }
+
+    /** 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"}/`);
+      }
+      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,
+        origin: lib.laneOrigin(lane),
+      };
+    }
+
+    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,
+        sidecars: Array.isArray(m.sidecars) ? m.sidecars.length : 0,
+      };
+    }
+
+    function postStatus(stateName, extra) {
+      post(Object.assign({ type: "status", state: stateName }, extra || {}));
+    }
+
+    function postError(reply, requestId, message, isFatalErr, isUnsupportedErr) {
+      reply({ type: "error", requestId: requestId == null ? undefined : requestId, message, fatal: !!isFatalErr, unsupported: !!isUnsupportedErr });
+    }
+
+    return {
+      handle,
+      state: snapshot,
+      readyMessage,
+      get phase() {
+        return state.phase;
+      },
+    };
+  }
+
+  function unique(list) {
+    return Array.from(new Set(list));
+  }
+
+  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 isFatal(err) {
+    if (!err) return false;
+    if (err.eddieFatal) return true;
+    return typeof WebAssembly === "object" && err instanceof WebAssembly.RuntimeError;
+  }
+
+  /** True for the engine's "not initialised" replies (the client re-runs init). */
+  function isNotLoadedMessage(message) {
+    return typeof message === "string" && message.indexOf(NOT_LOADED) === 0;
+  }
+
+  return { createSearchEngine, wasmCapabilities, NOT_LOADED, isNotLoadedMessage };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Eddie service worker: a persistent host for the search engine and the
+// agent, so a navigation within the site does not throw away the loaded
+// index, the dense model or the WebLLM engine.
+//
+// One source, four builds (widget/build.sh), because a service worker may
+// not import() anything: every dependency is a static import that build.sh
+// prepends per tier, along with `EDDIE_SW_TIER`:
+//
+//   eddie-sw-lite.js   initLiteWasm / liteWasmApi (eddie-lite-esm.js)
+//   eddie-sw-dense.js  lite + initDenseWasm / denseWasmApi (eddie-dense-esm.js)
+//   eddie-sw-gpu.js    lite + `transformers` (eddie-transformers-sw.js, the
+//                      copy whose onnxruntime-web imports point at the ORT
+//                      bundle build); search only, never WebLLM
+//   eddie-sw-agent.js  `webllm` (jsDelivr; the esm.run alias redirects, and
+//                      service worker script fetches reject redirects) and
+//                      the agent engine only; never a search host
+//
+// Each tier is registered by the widget as a *module* service worker in
+// its own scope under the asset directory (`/eddie/sw/<tier>/`), so a
+// visitor who never accepts a model never installs the gpu tier's imports
+// and one who never asks the agent a question never installs WebLLM.
+// The worker never handles `fetch`, so the browser does not start it for
+// navigations; pages reach it through
+// `registration.active.postMessage({type: "connect"}, [port])`, one
+// MessageChannel per page and engine ("search" or "agent"), and then speak
+// exactly the dedicated-worker protocols over that port. Three extra
+// messages exist on every port: `hello` (answered with the host's tier and
+// capabilities and both engines' state), `ping` -> `pong` (keepalive: Chrome
+// stops an idle service worker after ~30 s) and `state`.
+//
+// widget/build.sh concatenates widget/src/lib/*.js ahead of this file.
+
+"use strict";
+
+const lib = EddieLib;
+
+const SEARCH_TYPES = new Set(["init", "cache_check", "cache_clear", "search", "page", "chunk", "qa"]);
+const AGENT_TYPES = new Set(["load", "plan", "ask", "abort"]);
+const startedAt = Date.now();
+const hasGpu = !!(self.navigator && navigator.gpu && typeof navigator.gpu.requestAdapter === "function");
+const canRunOnnx = EDDIE_SW_TIER === "gpu" && hasGpu;
+
+/** A rejection that names the tier able to host what this one cannot; the widget moves the search there. */
+function tierError(tier, what) {
+  const e = new Error(`the ${EDDIE_SW_TIER} service worker has no ${what}; the ${tier} tier hosts it`);
+  e.eddieTier = tier;
+  return e;
+}
+
+const connections = new Set(); // { port, kind, reply }
+
+function broadcast(kind, message) {
+  for (const c of connections) {
+    if (c.kind === kind) c.reply(message);
+  }
+}
+
+/** ORT must use the factory embedded in its bundle build: no import() here. */
+function configureTransformers(tf) {
+  const onnx = tf.env && tf.env.backends && tf.env.backends.onnx;
+  if (!onnx || !onnx.wasm) return;
+  tf.env.useWasmCache = false;
+  onnx.wasm.numThreads = 1;
+  const ver = onnx.versions && onnx.versions.web;
+  if (ver && !onnx.wasm.wasmPaths) {
+    onnx.wasm.wasmPaths = { wasm: `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ver}/dist/ort-wasm-simd-threaded.asyncify.wasm` };
+  }
+}
+
+const wasmInits = {}; // variant -> Promise
+function loadWasm(baseUrl, variant) {
+  const v = variant || "lite";
+  if (v === "lite") {
+    if (!wasmInits.lite) wasmInits.lite = initLiteWasm({ module_or_path: lib.assetUrl(baseUrl, EDDIE_LITE_WASM, lib.ASSET_VERSION) }).then(() => liteWasmApi);
+    return wasmInits.lite;
+  }
+  if (v === "dense") {
+    if (!initDenseWasm) return Promise.reject(tierError("dense", "CPU embedder"));
+    if (!wasmInits.dense) wasmInits.dense = initDenseWasm({ module_or_path: lib.assetUrl(baseUrl, EDDIE_DENSE_WASM, lib.ASSET_VERSION) }).then(() => denseWasmApi);
+    return wasmInits.dense;
+  }
+  return Promise.reject(new Error(`unknown wasm variant ${String(variant)}`));
+}
+
+// The agent tier bundles no search engine (widget/src/lib/search-engine.js).
+const searchEngine = typeof lib.createSearchEngine === "function"
+  ? lib.createSearchEngine({
+      post: (message) => broadcast("search", message),
+      loadWasm,
+      loadTransformers: async () => {
+        if (!transformers) throw tierError("gpu", "transformers.js");
+        return transformers;
+      },
+      configureTransformers,
+      // Lane *choice* follows the adapter, whatever the tier: a lite worker asks
+      // consent for the webgpu lane, and the widget moves the search to the gpu
+      // tier on accept (or on a tier_required status if the lane is cached).
+      canRunWebGpuLane: hasGpu,
+    })
+  : null;
+
+// Only the agent tier bundles the agent (widget/src/lib/agent*.js) at all.
+const agentEngine = webllm && typeof lib.createAgentEngine === "function"
+  ? lib.createAgentEngine({
+      post: (message) => broadcast("agent", message),
+      loadWebLLM: async () => webllm,
+    })
+  : null;
+
+function capabilities() {
+  return {
+    ok: true,
+    tier: EDDIE_SW_TIER,
+    // The WebGPU runtime this tier hosts (transformers.js or WebLLM) can run.
+    gpu: hasGpu && !!(transformers || webllm),
+    onnx: canRunOnnx,
+    denseWasm: !!initDenseWasm,
+    startedAt,
+    search: searchEngine ? searchEngine.state() : null,
+    agent: agentEngine ? agentEngine.state() : null,
+  };
+}
+
+function attach(port, kind) {
+  const conn = {
+    port,
+    kind: kind === "agent" ? "agent" : "search",
+    reply: (message) => {
+      try {
+        port.postMessage(message);
+      } catch (err) {
+        console.warn("eddie sw: reply failed", err);
+      }
+    },
+  };
+  connections.add(conn);
+  port.onmessage = (e) => route(conn, e.data || {});
+  // Chrome 132+ fires close when the page that owns the other end goes away.
+  port.addEventListener("close", () => detach(conn));
+  port.start();
+}
+
+function detach(conn) {
+  if (!connections.has(conn)) return;
+  connections.delete(conn);
+  if (agentEngine) agentEngine.abortIfOwner(conn.reply);
+  try {
+    conn.port.close();
+  } catch (_) {
+    // ignore
+  }
+}
+
+function route(conn, msg) {
+  switch (msg.type) {
+    case "hello":
+      conn.reply(Object.assign({ type: "hello", requestId: msg.requestId }, capabilities()));
+      return;
+    case "ping":
+      conn.reply({ type: "pong", requestId: msg.requestId });
+      return;
+    case "state":
+      conn.reply(Object.assign({ type: "state", requestId: msg.requestId }, capabilities()));
+      return;
+    case "disconnect":
+      detach(conn);
+      return;
+    default:
+      break;
+  }
+  if (SEARCH_TYPES.has(msg.type)) {
+    if (searchEngine) searchEngine.handle(msg, conn.reply);
+    else conn.reply({ type: "error", requestId: msg.requestId, message: `the ${EDDIE_SW_TIER} service worker has no search engine; the lite tier hosts it` });
+  } else if (AGENT_TYPES.has(msg.type)) {
+    if (agentEngine) agentEngine.handle(msg, conn.reply);
+    else conn.reply({ type: "error", requestId: msg.requestId, message: `the ${EDDIE_SW_TIER} service worker has no agent; the agent tier hosts it` });
+  } else {
+    conn.reply({ type: "error", requestId: msg.requestId, message: `unknown message type ${String(msg.type)}` });
+  }
+}
+
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (e) => {
+  e.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("message", (e) => {
+  const msg = e.data || {};
+  if (msg.type === "connect" && e.ports && e.ports[0]) {
+    attach(e.ports[0], msg.kind);
+  }
+});