alias3-web: 4-bit WebGPU graph, readout files, library and demo

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/bis-overview.png filter=lfs diff=lfs merge=lfs -text
+assets/demo.png filter=lfs diff=lfs merge=lfs -text
+model/model.onnx.data filter=lfs diff=lfs merge=lfs -text
+model/tok/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+model/tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,210 @@
+---
+license: apache-2.0
+language:
+- en
+base_model:
+- aliasrobotics/alias3-micro-1026
+base_model_relation: finetune
+pipeline_tag: text-generation
+library_name: onnx
+tags:
+- cybersecurity
+- security
+- onnx
+- onnxruntime-genai
+- webgpu
+- browser
+- int4
+- dual-system
+- decision-head
+- system-1
+- system-2
+- phishing
+- malware-detection
+---
+
+# alias3-web
+
+**A cybersecurity transformer that runs in the browser.** It answers a typed security question in about
+150 ms and writes an explanation on request, on the user's GPU through WebGPU. The page under test never
+leaves the machine.
+
+<p align="center">
+<img src="assets/bis-overview.png" alt="alias3-web inside the Browser Immune System: a page is reduced to typed observations, the model answers one directed question per threat class, and explains a verdict on request" width="920">
+</p>
+
+alias3-web is the model behind the **Browser Immune System (BIS)**, a browser extension that screens every
+page a user visits. Both are described in the paper *Browser Immune System (BIS): Innate and Adaptive
+Threat Detection in the Browser with a Cybersecurity Transformer* (Mayoral-Vilches and Worrel, 2026), where
+the model is called `alias-web`. The figure above is the paper's overview: the model sits in the centre lane.
+
+It serves two regimes from one loaded set of 4-bit weights:
+
+| Regime | What it does | Cost on a laptop GPU |
+|---|---|---|
+| **System 1** | One typed question, one forward pass, no token decoded: a probability per option. | 152 ms per question |
+| **System 2** | Ordinary text generation from the same weights, on request. | 10.5 tokens/s |
+
+> **Research artefact.** Released to make the paper reproducible. Read the limits below before relying on
+> its answers.
+
+## What is in this repository
+
+| Path | What it is |
+|---|---|
+| `model/model.onnx`, `model/model.onnx.data` | The 4-bit graph for WebGPU (ONNX Runtime GenAI, 2,440,274,944 bytes of weights). It returns logits and the hidden states at requested positions. |
+| `model/tokenizer.json`, `model/tokenizer_config.json`, `model/chat_template.jinja`, `model/genai_config.json` | Tokenizer and runtime configuration. `model/tok/` and `model/heads/` hold copies where the runner looks for them. |
+| `heads/head.bin` | The complete pointer head (1.3 M parameters, fp16, 2,622,545 bytes): weights and biases of both projections. |
+| `heads/norm.bin` | The weight of the model's final RMSNorm (10,289 bytes). The graph exports hidden states before that norm and the head was trained after it. |
+| `aliasweb.mjs` | The library: the typed encoding, the norm, the head, and the calls `ask()` and `generate()`. |
+| `index.html`, `serve.py` | A demo page and a local server with HTTP Range support. |
+| `vendor/ct0.js`, `vendor/ct0-edge.LICENSE` | The prefill engine: the distribution of [ct0-edge](https://github.com/eduardoworrel/ct0-edge) by Eduardo Worrel (MIT), unchanged. |
+
+## Quick start
+
+```bash
+hf download aliasrobotics/alias3-web --local-dir alias3-web
+cd alias3-web && python3 serve.py 8924
+# open http://127.0.0.1:8924 in Chrome or Edge and press "Load model"
+```
+
+The first load reads 2.44 GB from the local server and takes a few seconds. The demo page fetches its two
+runtime modules (ONNX Runtime Web 1.30.0 and Transformers.js 3.7.5) from a public CDN; the model, the
+material you paste and the answers stay on your machine.
+
+From your own page, with the same import map as `index.html`:
+
+```js
+import { AliasWeb } from "./aliasweb.mjs";
+const model = await AliasWeb.load({ base: "./" });
+
+// System 1: a directed yes/no question about a piece of evidence
+const r = await model.ask({
+  kind: "noul",
+  state: `const q = new URLSearchParams(location.search).get("q");
+document.getElementById("out").innerHTML = "result: " + q;`,
+  q: "Is user input written into the DOM without escaping?",
+});
+console.log(r.p, r.ms);        // 0.822, about 150 ms
+
+// System 2: an explanation, only when it is worth seconds
+const t = await model.generate({
+  state: "...the same evidence...",
+  prompt: "You are a security reviewer. Name the vulnerability in this code and the fix, in 2-3 sentences.",
+  maxNewTokens: 90,
+});
+console.log(t.text, t.tokPerS);
+```
+
+## The typed interface
+
+A decision is one causal sequence, `<state> s <q> q <opt> o1 </opt> … <opt> oK </opt> <decide>`. The markers
+are not new vocabulary: they are five special tokens of the base tokenizer, and the library writes them by
+id.
+
+| Marker | Token | Id | Role |
+|---|---|---|---|
+| `<state>` | `<\|fim_prefix\|>` | 248060 | opens the evidence |
+| `<q>` | `<\|fim_middle\|>` | 248061 | opens the question |
+| `<opt>` | `<\|box_start\|>` | 248049 | opens an option |
+| `</opt>` | `<\|box_end\|>` | 248050 | closes an option: the key is read here |
+| `<decide>` | `<\|fim_suffix\|>` | 248062 | closes the row: the query is read here |
+
+The head scores option *i* as `q(h_decide) · k(h_opt_i) / (sqrt(256) · T)` on the normalised hidden states
+and a softmax over the options gives the probabilities. Text supplied by the caller is sanitised (a literal
+`<|name|>` becomes `<¦name¦>`), so that the evidence cannot forge an option boundary.
+
+| `kind` | Options | Returns | Status |
+|---|---|---|---|
+| `noul` | Yes, No | `p`, the probability of yes | the kind to use |
+| `choice` | your list | `choice`, `top` | answers in the categories of this checkpoint's training, see the limits |
+| `score` | 1 to 5 | `level`, `expected` | orders severity only weakly, see the limits |
+
+## Measurements
+
+All on one Apple M3 Max laptop (128 GB) in Chrome with WebGPU, the weights served from the local server.
+
+| Quantity | Value |
+|---|---|
+| Model ready, second load in the same browser | 2.33 s |
+| System 1, per question on short code snippets | 152 ms mean of twelve (110 to 200 ms); the head itself takes 1.18 ms |
+| System 2 | 10.5 tokens/s, about 96 ms per token |
+| A generated answer against a decision on the same snippet | 6 to 39 times the cost |
+
+One directed yes/no question per snippet:
+
+| Snippet | Question | P(yes) |
+|---|---|---|
+| DOM XSS: `innerHTML` with a query parameter | Is user input written into the DOM without escaping? | **0.822** |
+| SQL injection: string concatenation in `db.query` | Does this code concatenate user input into a SQL query? | **1.000** |
+| Command injection: `exec("curl " + url)` | Does this code pass user input to a shell command? | **1.000** |
+| Path traversal: `sendFile("/var/data/" + f)` | Can user input escape the intended directory in this file path? | 0.428 |
+| Hard-coded secret: an API key in the source | Does this code contain a hardcoded secret? | **1.000** |
+| Safe: pure arithmetic | Is user input written into the DOM without escaping? | **0.000** |
+
+Before publication the files of this repository were loaded in Chrome for Testing 157 and asked the same
+six questions: every probability above was reproduced to the third decimal. A first load in a fresh
+browser profile took 2.5 to 4.0 s.
+
+The question is the lever. On the DOM XSS snippet the generic question "Does this code contain a security
+vulnerability?" returns 0.040 and the directed one 0.822: same head, same evidence. Ask one directed
+question per class.
+
+In BIS, a battery of seven such questions returned the expected page verdict on 7 of the 8 sites of the
+paper's benchmark, in 0.9 to 6.4 s per page, with identical verdicts across samples and across Chrome and
+Firefox.
+
+## Limits
+
+- **WebGPU only.** The 4-bit graph has no CPU path. Measured in Chrome; Firefox Nightly with a window runs
+  it 5.9 times slower; Safari and Windows are unmeasured.
+- **Text inside the evidence can move the answer.** In the paper's benchmark a comment that declared a
+  script harmless took a miner detection from 1.00 to 0.00. Treat the state as untrusted input.
+- **Questions need calibration before they filter anything.** Two of the seven BIS questions, one about
+  scripts loaded from another server and one about keystroke capture asked of a login form, answer yes on
+  ordinary pages.
+- **`choice` and `score` speak the language of this checkpoint's training,** the context categories of
+  capture-the-flag campaigns. Asked to pick among weakness classes, `choice` returns the same label for any
+  injectable snippet, and `score` is not a calibrated severity. Use `noul`.
+- **System 2 needs a forced prefix.** The 4-bit checkpoint does not close its deliberation block on its
+  own; `generate()` starts the answer after the closing marker. A directive prompt and a temperature of 0.3
+  avoid narrated pseudo-deliberation.
+- **Agreement with the full-precision weights was checked on one prompt,** where the 4-bit graph returned
+  the same decision direction. How often the two precisions agree is not measured.
+- **One machine.** There is no measurement on a modest integrated GPU.
+
+## Provenance
+
+- **Parent.** [alias3-micro](https://huggingface.co/aliasrobotics/alias3-micro-1026), a 4B cybersecurity
+  transformer on a `Qwen3.5-4B` backbone (32 layers, hidden width 2560, a 248,320-token vocabulary),
+  described in the first paper cited below.
+- **What alias3-web adds to the weights.** Two rank-16 adapters, fused: the parent's decision adapter,
+  trained together with the pointer head, and a context-category sensor trained for two epochs on 12,576
+  replayed decision examples and 4,172 context-category examples, with the head frozen.
+- **The graph.** ONNX Runtime GenAI model builder 0.18 with `-p int4 -e webgpu` and
+  `include_hidden_states=true exclude_mtp=true`, run on Linux x86_64, following the recipe of the edge
+  study by Eduardo Worrel that this work reproduces and extends.
+- **Not included.** The fused full-precision checkpoint (8.4 GB) and the BIS extension are not part of this
+  repository.
+
+## License
+
+Apache-2.0 for the model files, the library, the demo page and the server, as for the parent model. The
+vendored runner in `vendor/` is MIT; its licence file is beside it.
+
+## Citation
+
+```bibtex
+@article{mayoralvilches2026bis,
+  author = {Mayoral-Vilches, V{\'i}ctor and Worrel, Eduardo},
+  title  = {Browser Immune System ({BIS}): Innate and Adaptive Threat Detection in the Browser with a Cybersecurity Transformer},
+  year   = {2026}
+}
+
+@article{mayoralvilches2026transformer,
+  author  = {Mayoral-Vilches, V{\'i}ctor},
+  title   = {{CT0}: Cybersecurity Transformer},
+  journal = {arXiv preprint arXiv:2610.16550},
+  year    = {2026}
+}
+```

aliasweb.mjs

@@ -0,0 +1,211 @@
+// alias3-web (alias-web in the paper) · a cybersecurity transformer in the browser (WebGPU).
+//
+// Two regimes from one loaded 4-bit graph:
+//   System 1  ask()       one typed question, one prefill, no token decoded: a probability per option
+//   System 2  generate()  text from the same weights, token by token, on request
+//
+// The prefill engine is the vendored runner (vendor/ct0.js: ct0-edge by Eduardo Worrel, MIT, see
+// vendor/ct0-edge.LICENSE), unchanged. This file adds the readout the model was trained with:
+//
+//   · the System 1 markers as the model's own special tokens, by id:
+//       <state> = <|fim_prefix|>   <q> = <|fim_middle|>   <opt> = <|box_start|>
+//       </opt>  = <|box_end|>      <decide> = <|fim_suffix|>
+//   · the final RMSNorm (heads/norm.bin): the graph exports hidden states before it
+//   · the complete pointer head (heads/head.bin), read as in training:
+//       z_i = q(h_<decide>) · k(h_</opt>_i) / (sqrt(256) · T),  softmax over the options
+//   · yes/no and severity as choices over ("Yes", "No") and ("1" … "5"): one mechanism for every question
+//
+// The page that imports this module needs an import map for the runner and its two runtimes; see index.html.
+
+export { AliasWeb };
+
+const MARKERS = {
+  state: "<|fim_prefix|>",
+  q: "<|fim_middle|>",
+  opt: "<|box_start|>",
+  optEnd: "<|box_end|>",
+  decide: "<|fim_suffix|>",
+};
+const LEVELS = ["1", "2", "3", "4", "5"];
+export const DEFAULT_SCORE_Q = "How severe is the security risk in this content?";
+
+// ── head.bin: [u32 lenJSON][json][fp16 q][fp16 qb][fp16 k][fp16 kb] ────────
+function f16(h) {
+  const s = (h & 0x8000) >> 15, e = (h & 0x7c00) >> 10, f = h & 0x03ff;
+  if (e === 0) return (s ? -1 : 1) * Math.pow(2, -14) * (f / 1024);
+  if (e === 0x1f) return f ? NaN : s ? -Infinity : Infinity;
+  return (s ? -1 : 1) * Math.pow(2, e - 15) * (1 + f / 1024);
+}
+export function loadHead(buf) {
+  const dv = new DataView(buf);
+  const jl = dv.getUint32(0, true);
+  const meta = JSON.parse(new TextDecoder().decode(new Uint8Array(buf, 4, jl)));
+  let off = 4 + jl;
+  const take = (n) => { const f = new Float32Array(n); for (let i = 0; i < n; i++) f[i] = f16(dv.getUint16(off + i * 2, true)); off += n * 2; return f; };
+  const d = meta.headDim, h = meta.hiddenSize;
+  return { q: take(d * h), qb: take(d), k: take(d * h), kb: take(d), headDim: d, hiddenSize: h,
+    temperature: meta.temperature ?? 1.0, scale: meta.scale ?? 1 / Math.sqrt(d), scoreOffset: meta.score_offset ?? 0 };
+}
+// norm.bin: [u32 lenJSON][json {hiddenSize}][fp32 hiddenSize]
+async function loadNorm(buf) {
+  const dv = new DataView(buf);
+  const jl = dv.getUint32(0, true);
+  const meta = JSON.parse(new TextDecoder().decode(new Uint8Array(buf, 4, jl)));
+  const n = meta.hiddenSize, off = 4 + jl, f = new Float32Array(n);
+  for (let i = 0; i < n; i++) f[i] = dv.getFloat32(off + i * 4, true);
+  return f;
+}
+function proj(W, b, x, dim, hidden) {
+  const y = new Float32Array(dim);
+  for (let d = 0; d < dim; d++) { let a = b[d]; const r = d * hidden; for (let i = 0; i < hidden; i++) a += W[r + i] * x[i]; y[d] = a; }
+  return y;
+}
+const dot = (a, b) => { let s = 0; for (let i = 0; i < a.length; i++) s += a[i] * b[i]; return s; };
+const headLogit = (hd, hD, hO) => dot(proj(hd.q, hd.qb, hD, hd.headDim, hd.hiddenSize), proj(hd.k, hd.kb, hO, hd.headDim, hd.hiddenSize)) * hd.scale / hd.temperature + (hd.scoreOffset || 0);
+const softmax = (xs) => {
+  const mx = Math.max(...xs.filter(Number.isFinite));
+  const e = xs.map((x) => (Number.isFinite(x) ? Math.exp(x - mx) : 0));
+  const z = e.reduce((a, b) => a + b, 0) || 1;
+  return e.map((v) => v / z);
+};
+
+// text supplied by the caller can never produce a delimiter: <|name|> becomes <¦name¦>, as in training
+const SPECIAL_RE = /<\|([A-Za-z0-9_]+)\|>/g;
+const sanitize = (t) => t.replace(SPECIAL_RE, "<¦$1¦>");
+
+class AliasWeb {
+  constructor(tok, prefill, head, mid, normW) { this.tok = tok; this.prefill = prefill; this.head = head; this.mid = mid; this.normW = normW; }
+
+  // the graph exports hidden_states before the final norm; the head was trained on the normalised
+  // state, so the model's final RMSNorm is applied here
+  norm(h) {
+    if (!this.normW) return h;
+    let s = 0; for (let i = 0; i < h.length; i++) s += h[i] * h[i];
+    const inv = 1 / Math.sqrt(s / h.length);
+    const o = new Float32Array(h.length);
+    for (let i = 0; i < h.length; i++) o[i] = h[i] * inv * this.normW[i];
+    return o;
+  }
+
+  static async load(opts = {}) {
+    const base = opts.base ?? "./";
+    const status = opts.status ?? (() => { });
+    status("loading the runner and the 4-bit graph (2.4 GB)…");
+    const edge = await import("ct0-edge");
+    const inner = await edge.CT0.load({
+      runtime: "genai",
+      genaiBaseUrl: base + "model/",
+      genaiModel: "model.onnx",
+      baseUrl: base + "model/",
+      status: () => { },
+      verifyEp: false,          // placement was verified once against this graph in Chrome
+      skipVersionCheck: true,   // the import map pins the ONNX Runtime version
+      genai: { warmup: false },
+    });
+    const be = inner.backend ?? inner.be;
+    if (!be?.prefill) throw new Error("the runner did not expose its prefill backend");
+    status("loading the head and the final norm…");
+    const head = loadHead(await (await fetch(base + "heads/head.bin")).arrayBuffer());
+    const normW = await loadNorm(await (await fetch(base + "heads/norm.bin")).arrayBuffer());
+    // marker ids from the tokenizer's added_tokens
+    const tk = await (await fetch(base + "model/tokenizer.json")).json();
+    const added = new Map((tk.added_tokens ?? []).map((t) => [t.content, t.id]));
+    const mid = {};
+    for (const [k, m] of Object.entries(MARKERS)) {
+      const id = added.get(m);
+      if (typeof id !== "number") throw new Error("marker without a token id: " + m);
+      mid[k] = id;
+    }
+    const model = new AliasWeb(inner.tok?.tokenizer ?? inner.tok, (ids, positions) => be.prefill(ids, { positions }), head, mid, normW);
+    model.be = be; model.base = base;
+    status("warm-up…");
+    const w = model.encode("warmup", "ok?", ["Yes", "No"]);
+    await model.prefill(w.ids, []);
+    status("ready");
+    return model;
+  }
+
+  encode(state, question, options) {
+    const t = this.tok;
+    const idsOf = (text) => Array.from(t.encode(sanitize(text), { add_special_tokens: false }), Number);
+    const ids = [this.mid.state, ...idsOf(state), this.mid.q, ...idsOf(question)];
+    const optEnds = [];
+    for (const o of options) {
+      ids.push(this.mid.opt, ...idsOf(o));
+      optEnds.push(ids.length);
+      ids.push(this.mid.optEnd);
+    }
+    ids.push(this.mid.decide);
+    return { ids, decide: ids.length - 1, optEnds };
+  }
+
+  async ask(q) {
+    const t0 = performance.now();
+    let options, question, labels;
+    if (q.kind === "noul") { options = ["Yes", "No"]; question = q.q ?? ""; labels = ["yes", "no"]; }
+    else if (q.kind === "score") { options = LEVELS; question = q.q ?? DEFAULT_SCORE_Q; labels = LEVELS; }
+    else { options = q.options; question = q.q ?? ""; labels = options; }
+    const enc = this.encode(q.state, question, options);
+    const p0 = performance.now();
+    const { hiddens } = await this.prefill(enc.ids, [enc.decide, ...enc.optEnds]);
+    const prefillMs = performance.now() - p0;
+    const hDecide = this.norm(hiddens[0]), perOpt = hiddens.slice(1).map((h) => this.norm(h));
+    const raws = perOpt.map((h) => headLogit(this.head, hDecide, h));
+    const ps = softmax(raws);
+    const out = { kind: q.kind, ms: performance.now() - t0, prefillMs, nTokens: enc.ids.length, raws: {} };
+    labels.forEach((l, i) => out.raws[l] = raws[i]);
+    if (q.kind === "noul") out.p = ps[0];
+    else if (q.kind === "score") {
+      out.per = Object.fromEntries(labels.map((l, i) => [l, ps[i]]));
+      out.level = 1 + ps.indexOf(Math.max(...ps));
+      out.expected = ps.reduce((a, p, i) => a + p * (i + 1), 0);
+    } else {
+      out.choice = Object.fromEntries(labels.map((l, i) => [l, ps[i]]));
+      out.top = labels[ps.indexOf(Math.max(...ps))];
+      out.p = Math.max(...ps);
+    }
+    return out;
+  }
+
+  // ── System 2: text from the same 4-bit weights ─────────────────────────
+  // The graph exposes logits; the runner's backend samples from them (end tokens <|im_end|> and
+  // <|endoftext|>).
+  async generate(q) {
+    const t0 = performance.now();
+    const state = q.state ?? "";
+    const prompt = (q.prompt ?? "").trim();
+    const user = state ? prompt + "\n\n" + state : prompt;
+    const t = this.tok;
+    const idsOf = (text) => Array.from(t.encode(sanitize(text), { add_special_tokens: false }), Number);
+    if (!this._added) {
+      const tk = await (await fetch(this.base + "model/tokenizer.json")).json();
+      this._added = new Map((tk.added_tokens ?? []).map((x) => [x.content, x.id]));
+    }
+    const imS = this._added.get("<|im_start|>"), imE = this._added.get("<|im_end|>");
+    // The base family deliberates by default and this checkpoint in 4-bit does not close the block:
+    // the assistant turn is forced to start after the closing marker. The special tokens go in by id,
+    // never through idsOf(): the sanitiser would rewrite them.
+    const body = idsOf("user\n" + user);
+    const asst = q.forceNoThink === false
+      ? [imS, ...idsOf("assistant\n")]
+      : [imS, ...idsOf("assistant\n</think>\n\n")];
+    const ids = [imS, ...body, imE, ...asst];
+    const out = [];
+    const tt0 = performance.now();
+    for await (const tokId of this.be.generate(ids, {
+      maxNewTokens: q.maxNewTokens ?? 96,
+      temperature: q.temperature ?? 0.7,
+      topP: q.topP ?? 0.9,
+    })) {
+      out.push(tokId);
+      if (q.onToken) q.onToken(t.decode([tokId], { skip_special_tokens: true }), out.length);
+    }
+    const genMs = performance.now() - tt0;
+    return {
+      text: t.decode(out, { skip_special_tokens: true, clean_up_tokenization_spaces: false }).trim(),
+      tokens: out.length, genMs,
+      tokPerS: +(out.length / (genMs / 1000)).toFixed(1),
+      ms: performance.now() - t0,
+    };
+  }
+}

heads/head.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f586cb80f9f369c0d2ca00763e9402a883d7c759b712d2f81434a6a2e7e7495b
+size 2622545

heads/norm.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a0ae161d2fa1902a031434126a904fe665a5ebff488b8740d0de495b93b90ce
+size 10289

index.html

@@ -0,0 +1,199 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>alias3-web · a cybersecurity transformer in your browser</title>
+<style>
+  :root { --ink:#16202A; --muted:#5B6875; --rule:#D6DCE2; --bg:#F4F6F8; --card:#FFF;
+          --accent:#1F4E8C; --accent-soft:#E3EBF6; --good:#0ca30c; --mono:ui-monospace,Menlo,Consolas,monospace; }
+  * { box-sizing:border-box }
+  body { margin:0; background:var(--bg); color:var(--ink);
+         font:15px/1.5 -apple-system,"Segoe UI",Roboto,sans-serif; }
+  main { max-width:900px; margin:0 auto; padding:28px 18px 80px }
+  h1 { font-size:1.5rem; margin:.2em 0 .3em }
+  h1 small { color:var(--muted); font-weight:400; font-size:.95rem }
+  .sub { color:var(--muted); margin:0 0 18px }
+  .card { background:var(--card); border:1px solid var(--rule); border-radius:12px; padding:16px 18px; margin:14px 0 }
+  label { font-size:.85rem; color:var(--muted); display:block; margin-bottom:4px }
+  textarea, input[type=text] { width:100%; border:1px solid var(--rule); border-radius:8px; padding:8px 10px;
+         font:12.5px/1.45 var(--mono); background:#fbfcfd; color:var(--ink) }
+  textarea { min-height:120px; resize:vertical }
+  .row { display:flex; gap:10px; flex-wrap:wrap; align-items:flex-end }
+  .row > div { flex:1; min-width:180px }
+  button { background:var(--accent); color:#fff; border:0; border-radius:8px; padding:10px 18px;
+           font-size:.95rem; cursor:pointer; margin:12px 8px 0 0 }
+  button.secondary { background:var(--accent-soft); color:var(--accent) }
+  button:disabled { opacity:.45; cursor:wait }
+  #status { font-size:.9rem; color:var(--muted); margin-top:10px }
+  .result { margin-top:14px }
+  .bar-row { display:flex; align-items:center; gap:10px; margin:5px 0 }
+  .bar-label { width:190px; font-size:.85rem; text-align:right; overflow:hidden; text-overflow:ellipsis; white-space:nowrap }
+  .bar-track { flex:1; background:#eef1f4; border-radius:6px; height:20px; position:relative }
+  .bar-fill { height:100%; border-radius:6px; background:var(--accent); transition:width .25s }
+  .bar-fill.win { background:var(--good) }
+  .bar-val { width:64px; font-size:.85rem; font-family:var(--mono) }
+  .kpis { display:flex; gap:12px; flex-wrap:wrap; margin-top:12px }
+  .kpi { background:var(--accent-soft); border-radius:10px; padding:10px 14px; min-width:120px }
+  .kpi b { display:block; font-size:1.5rem; color:var(--accent) }
+  .kpi span { font-size:.8rem; color:var(--muted) }
+  .pill { display:inline-block; background:var(--accent-soft); color:var(--accent); border-radius:20px;
+          padding:2px 10px; font-size:.78rem; margin:2px 4px 2px 0; font-family:var(--mono) }
+  details { margin-top:10px } summary { cursor:pointer; color:var(--muted); font-size:.85rem }
+  pre { background:#eef1f4; border-radius:8px; padding:10px; font-size:.75rem; overflow:auto }
+  .err { color:#b00020; font-family:var(--mono); font-size:.8rem; margin-top:8px; white-space:pre-wrap }
+</style>
+</head>
+<body>
+<main>
+  <h1>alias3-web <small>· typed security decisions and explanations, on your GPU (WebGPU)</small></h1>
+  <p class="sub">A 4B cybersecurity transformer quantised to 4 bits (ONNX Runtime GenAI, 2.44 GB) with the
+  <b>complete trained head</b> and the <b>model's own marker tokens</b>. Nothing leaves this page.
+  Prefill engine: <a href="https://github.com/eduardoworrel/ct0-edge">ct0-edge</a> by Eduardo Worrel (MIT), vendored.</p>
+
+  <div class="card">
+    <div class="row">
+      <div><label>State (the material to judge: code, a log, the source of a page…)</label>
+        <textarea id="state">const q = new URLSearchParams(location.search).get("q");
+document.getElementById("out").innerHTML = "result: " + q;</textarea></div>
+    </div>
+    <div class="row" style="margin-top:10px">
+      <div><label>Question (yes/no and choice)</label>
+        <input type="text" id="q" value="Is user input written into the DOM without escaping?"></div>
+      <div><label>Options (choice, separated by ;)</label>
+        <input type="text" id="opts" value="dom-xss; sql-injection; ssrf; path-traversal"></div>
+    </div>
+    <button id="btn-load" class="secondary">1 · Load model (2.4 GB)</button>
+    <button id="btn-noul" disabled>Yes / No</button>
+    <button id="btn-choice" disabled>Choice</button>
+    <button id="btn-score" disabled>Severity 1-5</button>
+    <button id="btn-s2" disabled>Explanation (System 2)</button>
+    <div id="status">Press “Load model”. Needs Chrome or Edge with WebGPU.</div>
+    <div id="err" class="err"></div>
+    <details>
+      <summary>the marker tokens and the readout</summary>
+      <span class="pill">&lt;state&gt;→&lt;|fim_prefix|&gt;</span><span class="pill">&lt;q&gt;→&lt;|fim_middle|&gt;</span>
+      <span class="pill">&lt;opt&gt;→&lt;|box_start|&gt;</span><span class="pill">&lt;/opt&gt;→&lt;|box_end|&gt;</span>
+      <span class="pill">&lt;decide&gt;→&lt;|fim_suffix|&gt;</span>
+      <p style="font-size:.82rem;color:var(--muted)">readout: q(h&lt;decide&gt;)·k(h&lt;/opt&gt;ᵢ)·√256⁻¹/T, softmax over the options.
+      A yes/no question is a choice over (Yes, No) and severity a choice over (1..5): one mechanism, as trained.</p>
+    </details>
+  </div>
+
+  <div class="card result" id="result" style="display:none">
+    <div class="kpis">
+      <div class="kpi"><b id="k-top">·</b><span id="k-top-lbl">answer</span></div>
+      <div class="kpi"><b id="k-ms">·</b><span>total latency</span></div>
+      <div class="kpi"><b id="k-pref">·</b><span>prefill</span></div>
+      <div class="kpi"><b id="k-tok">·</b><span>tokens</span></div>
+    </div>
+    <div id="bars"></div>
+    <details><summary>raw</summary><pre id="raw"></pre></details>
+  </div>
+</main>
+
+<script type="importmap">
+{ "imports": {
+  "ct0-edge": "./vendor/ct0.js",
+  "@huggingface/transformers": "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.7.5",
+  "onnxruntime-web/webgpu": "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.30.0/dist/ort.webgpu.bundle.min.mjs",
+  "onnxruntime-web": "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.30.0/dist/ort.webgpu.bundle.min.mjs"
+} }
+</script>
+<script type="module">
+import { AliasWeb } from "./aliasweb.mjs";
+const $ = (id) => document.getElementById(id);
+let model = null;
+
+function bars(entries) {
+  $("bars").innerHTML = "";
+  const max = Math.max(...entries.map(([, v]) => v));
+  for (const [label, v] of entries) {
+    const row = document.createElement("div"); row.className = "bar-row";
+    const l = document.createElement("div"); l.className = "bar-label"; l.textContent = label; l.title = label;
+    const t = document.createElement("div"); t.className = "bar-track";
+    const f = document.createElement("div"); f.className = "bar-fill" + (v === max ? " win" : "");
+    f.style.width = (v * 100).toFixed(1) + "%";
+    const val = document.createElement("div"); val.className = "bar-val"; val.textContent = (v * 100).toFixed(1) + "%";
+    t.appendChild(f); row.append(l, t, val); $("bars").appendChild(row);
+  }
+}
+
+function show(r, topLabel, tok) {
+  $("result").style.display = "";
+  $("k-top").textContent = topLabel;
+  $("k-top-lbl").textContent = r.kind === "noul" ? "P(yes)" : r.kind === "score" ? "level" : "top";
+  $("k-ms").textContent = r.ms.toFixed(0) + " ms";
+  $("k-pref").textContent = r.prefillMs.toFixed(0) + " ms";
+  $("k-tok").textContent = tok;
+  const entries = r.kind === "noul" ? [["Yes", r.p], ["No", 1 - r.p]]
+    : r.kind === "score" ? Object.entries(r.per).map(([l, p]) => ["level " + l, p])
+    : Object.entries(r.choice);
+  bars(entries);
+  $("raw").textContent = JSON.stringify({ ...r, lastLogits: undefined }, null, 1).slice(0, 2000);
+}
+
+async function guard(fn) {
+  $("err").textContent = "";
+  if (!model) { $("err").textContent = "load the model first"; return; }
+  try { await fn(); } catch (e) { $("err").textContent = String(e?.stack || e); }
+}
+
+$("btn-load").onclick = async () => {
+  $("btn-load").disabled = true; $("err").textContent = "";
+  try {
+    model = await AliasWeb.load({ base: "./", status: (s) => $("status").textContent = s });
+    window.aliasweb = model;
+    for (const b of ["btn-noul", "btn-choice", "btn-score", "btn-s2"]) $(b).disabled = false;
+    $("status").textContent = "model ready · WebGPU active";
+  } catch (e) { $("err").textContent = String(e?.stack || e); $("btn-load").disabled = false; }
+};
+
+$("btn-noul").onclick = () => guard(async () => {
+  const state = $("state").value, q = $("q").value;
+  const r = await model.ask({ kind: "noul", state, q });
+  const enc = model.encode(state, q, ["Yes", "No"]);
+  show(r, (r.p * 100).toFixed(1) + "%", enc.ids.length);
+});
+
+$("btn-choice").onclick = () => guard(async () => {
+  const state = $("state").value;
+  const options = $("opts").value.split(";").map((s) => s.trim()).filter(Boolean);
+  const q = "Which vulnerability class does this code contain?";
+  const r = await model.ask({ kind: "choice", state, q, options });
+  const enc = model.encode(state, q, options);
+  show(r, r.top, enc.ids.length);
+});
+
+$("btn-s2").onclick = () => guard(async () => {
+  const state = $("state").value;
+  $("status").textContent = "System 2 is writing (about 10 tokens/s)…";
+  const r = await model.generate({
+    state,
+    prompt: "You are a security reviewer. Name the vulnerability in this code and the fix, in 2-3 sentences.",
+    maxNewTokens: 90, temperature: 0.7,
+  });
+  $("status").textContent = "model ready · WebGPU active";
+  $("result").style.display = "";
+  $("k-top").textContent = r.tokens + " tok";
+  $("k-top-lbl").textContent = "S2 · " + r.tokPerS + " tok/s";
+  $("k-ms").textContent = (r.ms / 1000).toFixed(1) + " s";
+  $("k-pref").textContent = "≈" + (r.ms / r.tokens).toFixed(0) + " ms/tok";
+  $("k-tok").textContent = "vs 0.15 s S1";
+  $("bars").innerHTML = "";
+  const p = document.createElement("p");
+  p.style.cssText = "font-size:.95rem;line-height:1.6";
+  p.textContent = r.text;
+  $("bars").appendChild(p);
+  $("raw").textContent = JSON.stringify({ tokens: r.tokens, tokPerS: r.tokPerS, ms: Math.round(r.ms) }, null, 1);
+});
+
+$("btn-score").onclick = () => guard(async () => {
+  const state = $("state").value;
+  const r = await model.ask({ kind: "score", state });
+  const enc = model.encode(state, "", ["1", "2", "3", "4", "5"]);
+  show(r, r.level + " / 5", enc.ids.length);
+});
+</script>
+</body>
+</html>

model/chat_template.jinja

@@ -0,0 +1,158 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- set num_sys = 0 %}
+{%- set merged_system = '' %}
+{%- if messages[0].role == 'system' or messages[0].role == 'developer' %}
+    {%- set first = render_content(messages[0].content, false, true)|trim %}
+    {%- if messages|length > 1 and (messages[1].role == 'system' or messages[1].role == 'developer') %}
+        {%- set second = render_content(messages[1].content, false, true)|trim %}
+        {%- set merged_system = first + '\n' + second %}
+        {%- set num_sys = 2 %}
+    {%- else %}
+        {%- set merged_system = first %}
+        {%- set num_sys = 1 %}
+    {%- endif %}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if merged_system %}
+        {{- '\n\n' + merged_system }}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if merged_system %}
+        {{- '<|im_start|>system\n' + merged_system + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if loop.index0 >= num_sys and message.role != "system" and message.role != "developer" %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is mapping %}
+                    {%- for args_name in tool_call.arguments %}
+                        {%- set args_value = tool_call.arguments[args_name] %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}
+{#- Unsloth fixes - developer role, tool calling #}

model/genai_config.json

@@ -0,0 +1,68 @@
+{
+    "model": {
+        "bos_token_id": 1,
+        "context_length": 262144,
+        "decoder": {
+            "session_options": {
+                "log_id": "onnxruntime-genai",
+                "provider_options": [
+                    {
+                        "webgpu": {
+                            "enableGraphCapture": "0",
+                            "validationMode": "basic"
+                        }
+                    }
+                ]
+            },
+            "filename": "model.onnx",
+            "head_size": 256,
+            "hidden_size": 2560,
+            "inputs": {
+                "input_ids": "input_ids",
+                "attention_mask": "attention_mask",
+                "position_ids": "position_ids",
+                "past_key_names": "past_key_values.%d.key",
+                "past_value_names": "past_key_values.%d.value",
+                "past_conv_names": "past.%d.conv",
+                "past_recurrent_names": "past.%d.recurrent"
+            },
+            "outputs": {
+                "logits": "logits",
+                "present_key_names": "present.%d.key",
+                "present_value_names": "present.%d.value",
+                "present_conv_names": "present.%d.conv",
+                "present_recurrent_names": "present.%d.recurrent"
+            },
+            "num_attention_heads": 16,
+            "num_hidden_layers": 32,
+            "num_key_value_heads": 4
+        },
+        "eos_token_id": [
+            248046,
+            248044
+        ],
+        "pad_token_id": 248055,
+        "type": "qwen3_5_text",
+        "vocab_size": 248320,
+        "bot_token_id": 248058,
+        "eot_token_id": 248059,
+        "bor_token_id": 248068,
+        "eor_token_id": 248069
+    },
+    "search": {
+        "diversity_penalty": 0.0,
+        "do_sample": false,
+        "early_stopping": true,
+        "length_penalty": 1.0,
+        "max_length": 262144,
+        "min_length": 0,
+        "no_repeat_ngram_size": 0,
+        "num_beams": 1,
+        "num_return_sequences": 1,
+        "past_present_share_buffer": true,
+        "repetition_penalty": 1.0,
+        "temperature": 1.0,
+        "top_k": 50,
+        "top_p": 1.0
+    }
+}

model/heads/head.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f586cb80f9f369c0d2ca00763e9402a883d7c759b712d2f81434a6a2e7e7495b
+size 2622545

model/model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94d67f6e1777aa45e6e99ef39df9c2b568801ab8c5eda91c697b18d8a8f0885d
+size 489574

model/model.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6563d99a1dc847ea4ce02e0ff51da15b88fe532fae4cb3b2f6a24f0d988e0a0e
+size 2440274944

model/tok/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523
+size 19989325

model/tok/tokenizer_config.json

@@ -0,0 +1,34 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|vision_pad|>",
+  "padding_side": "left",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "processor_class": "Qwen3VLProcessor",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

model/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523
+size 19989325

model/tokenizer_config.json

@@ -0,0 +1,34 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|vision_pad|>",
+  "padding_side": "left",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "processor_class": "Qwen3VLProcessor",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

serve.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Static server for the alias-web bundle, with HTTP Range support for the 2.4 GB weight file.
+
+    python3 serve.py [port]        # default 8924; then open http://127.0.0.1:<port> in Chrome or Edge
+
+Binds to 127.0.0.1 only. Responses are marked no-store so that a changed module is never served stale;
+CORS is open so that a local browser extension can fetch the model from this server.
+"""
+import http.server, os, re, socketserver, sys
+
+ROOT = os.path.dirname(os.path.abspath(__file__))
+
+
+class Handler(http.server.SimpleHTTPRequestHandler):
+    def __init__(self, *a, **kw):
+        super().__init__(*a, directory=ROOT, **kw)
+
+    def send_head(self):
+        self._remaining = None
+        path = self.translate_path(self.path)
+        rng = self.headers.get("Range")
+        if not rng or not os.path.isfile(path):
+            return super().send_head()
+        size = os.path.getsize(path)
+        m = re.match(r"bytes=(\d*)-(\d*)$", rng.strip())
+        if not m or not (m.group(1) or m.group(2)):
+            self.send_error(416)
+            return None
+        if m.group(1):
+            start, end = int(m.group(1)), min(int(m.group(2)) if m.group(2) else size - 1, size - 1)
+        else:  # suffix form: the last N bytes
+            start, end = max(0, size - int(m.group(2))), size - 1
+        if start > end:
+            self.send_error(416)
+            return None
+        f = open(path, "rb")
+        f.seek(start)
+        self._remaining = end - start + 1
+        self.send_response(206)
+        self.send_header("Content-Type", self.guess_type(path))
+        self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
+        self.send_header("Content-Length", str(self._remaining))
+        self.end_headers()
+        return f
+
+    def copyfile(self, source, outputfile):
+        if self._remaining is None:
+            return super().copyfile(source, outputfile)
+        left = self._remaining
+        while left > 0:
+            chunk = source.read(min(1 << 20, left))
+            if not chunk:
+                break
+            outputfile.write(chunk)
+            left -= len(chunk)
+
+    def end_headers(self):
+        self.send_header("Accept-Ranges", "bytes")
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        super().end_headers()
+
+
+socketserver.TCPServer.allow_reuse_address = True
+if __name__ == "__main__":
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8924
+    with socketserver.ThreadingTCPServer(("127.0.0.1", port), Handler) as s:
+        print(f"serving {ROOT} on http://127.0.0.1:{port}")
+        s.serve_forever()

vendor/ct0-edge.LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 eduardoworrel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/ct0.js

@@ -0,0 +1,2246 @@
+// src/backend.ts
+var GENERATE_DEFAULTS = { maxNewTokens: 512, temperature: 0.7, topP: 0.9, topK: 40, repetitionPenalty: 1.1, seed: 0 };
+function resolveGenerateOptions(o = {}) {
+  const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+  const D = GENERATE_DEFAULTS;
+  const temperature = num(o.temperature, D.temperature);
+  return {
+    maxNewTokens: Math.max(0, Math.floor(num(o.maxNewTokens, D.maxNewTokens))),
+    temperature,
+    topP: num(o.topP, D.topP),
+    topK: num(o.topK, D.topK),
+    repetitionPenalty: num(o.repetitionPenalty, temperature <= 0 ? 1 : D.repetitionPenalty),
+    seed: num(o.seed, D.seed),
+    signal: o.signal
+  };
+}
+function checkContinuation(name, h, ids, positions) {
+  const k = h.ids.length;
+  if (ids.length <= k || h.ids.some((x, i) => ids[i] !== x)) throw new Error(`${name}: prefillFrom ids must extend the snapshot prefix (${k} tokens) by at least one token`);
+  for (const p of positions) if (!Number.isInteger(p) || p < k || p >= ids.length) throw new Error(`${name}: position ${p} outside the continuation [${k},${ids.length})`);
+  return k;
+}
+function createGate(name) {
+  let tail = Promise.resolve();
+  let disposed = false;
+  let disposing = null;
+  const err = () => new Error(`${name}: backend already disposed`);
+  const lock = async () => {
+    const prev = tail;
+    let rel;
+    tail = new Promise((r) => {
+      rel = r;
+    });
+    await prev;
+    return rel;
+  };
+  return {
+    get disposed() {
+      return disposed;
+    },
+    assertLive() {
+      if (disposed) throw err();
+    },
+    async acquire() {
+      if (disposed) throw err();
+      return lock();
+    },
+    dispose(release) {
+      if (!disposing) {
+        disposed = true;
+        disposing = (async () => {
+          const rel = await lock();
+          try {
+            await release();
+          } finally {
+            rel();
+          }
+        })();
+      }
+      return disposing;
+    }
+  };
+}
+var gates = /* @__PURE__ */ new WeakMap();
+function gateFor(shared, name) {
+  let g = gates.get(shared);
+  if (!g) {
+    g = createGate(name);
+    gates.set(shared, g);
+  }
+  return g;
+}
+
+// src/ortVersion.ts
+function checkOrtVersion(v, min = [1, 30]) {
+  const m = /^(\d+)\.(\d+)/.exec(v ?? "");
+  if (!m) return;
+  if (Number(m[1]) < min[0] || Number(m[1]) === min[0] && Number(m[2]) < min[1])
+    throw new Error(`ct0-edge: onnxruntime-web ${v} is too old; requires >= ${min.join(".")} (WebGPU returns NaN below that; the genai backend needs the LinearAttention/CausalConvWithState kernels). Pass skipVersionCheck to ignore.`);
+}
+
+// src/backends/decodeOnly.ts
+var EOS = /* @__PURE__ */ new Set([248046, 248044]);
+var HIDDEN_NAMES = ["/model/norm/Mul_1_output_0", "mul_13450", "hidden_states", "type_as_80"];
+var F16 = globalThis.Float16Array;
+function mulberry32(seed) {
+  let a = seed >>> 0 || 1;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function halfToNumber(h) {
+  const s = h & 32768 ? -1 : 1, e = (h & 31744) >> 10, f = h & 1023;
+  return e === 0 ? s * Math.pow(2, -14) * (f / 1024) : e === 31 ? f ? NaN : s * Infinity : s * Math.pow(2, e - 15) * (1 + f / 1024);
+}
+function tensorToF32(data, type, off = 0, n = data.length - off) {
+  const out = new Float32Array(n);
+  const isF16Arr = typeof F16 !== "undefined" && data instanceof F16;
+  if (data instanceof Float32Array || isF16Arr) {
+    for (let i = 0; i < n; i++) out[i] = Number(data[off + i]);
+  } else if (type === "float16" || data instanceof Uint16Array) {
+    for (let i = 0; i < n; i++) out[i] = halfToNumber(data[off + i]);
+  } else for (let i = 0; i < n; i++) out[i] = Number(data[off + i]);
+  return out;
+}
+function lastRow(L) {
+  const V = L.dims.at(-1), off = (L.dims.at(-2) - 1) * V;
+  return tensorToF32(L.data, L.type, off, V);
+}
+function sample(logits, gen, rand, o) {
+  const { temperature: temp, topP, topK, repetitionPenalty: rep } = o;
+  if (rep !== 1) for (const t of new Set(gen)) logits[t] = logits[t] > 0 ? logits[t] / rep : logits[t] * rep;
+  if (temp <= 0) {
+    let bi = 0, bv = -1e30;
+    for (let i = 0; i < logits.length; i++) if (logits[i] > bv) {
+      bv = logits[i];
+      bi = i;
+    }
+    return bi;
+  }
+  let idx = Array.from(logits.keys());
+  idx.sort((a, b) => logits[b] - logits[a]);
+  if (topK > 0) idx = idx.slice(0, topK);
+  const mx = logits[idx[0]];
+  let probs = idx.map((i) => Math.exp((logits[i] - mx) / temp));
+  let s = probs.reduce((a, b) => a + b, 0);
+  probs = probs.map((p) => p / s);
+  if (topP < 1) {
+    let c = 0, cut = idx.length;
+    for (let i = 0; i < idx.length; i++) {
+      c += probs[i];
+      if (c >= topP) {
+        cut = i + 1;
+        break;
+      }
+    }
+    idx = idx.slice(0, cut);
+    probs = probs.slice(0, cut);
+    const z = probs.reduce((a, b) => a + b, 0);
+    probs = probs.map((p) => p / z);
+  }
+  let r = rand(), acc = 0;
+  for (let i = 0; i < idx.length; i++) {
+    acc += probs[i];
+    if (r <= acc) return idx[i];
+  }
+  return idx[idx.length - 1];
+}
+function pastNameFor(out) {
+  let m;
+  if (m = out.match(/^present_conv\.(\d+)$/)) return "past_conv." + m[1];
+  if (m = out.match(/^present_recurrent\.(\d+)$/)) return "past_recurrent." + m[1];
+  if (m = out.match(/^present\.(\d+)\.(key|value)$/)) return `past_key_values.${m[1]}.${m[2]}`;
+  if (m = out.match(/^present\.(\d+)\.(conv|recurrent)$/)) return `past.${m[1]}.${m[2]}`;
+  if (m = out.match(/^so(\d+)$/)) return "si" + m[1];
+  return null;
+}
+function cacheDims(name, shape, pastLen) {
+  const isKV = /^past_key_values\./.test(name) || shape.length === 4 && !/conv|recurrent/.test(name) && typeof shape[2] !== "number";
+  return shape.map((d, i) => typeof d === "number" && d >= 0 ? d : isKV && i === 2 ? pastLen : 1);
+}
+async function createDecodeOnly(session, tok, opts) {
+  if (!opts.skipVersionCheck) checkOrtVersion(opts.ort.env?.versions?.web);
+  const T = opts.ort.Tensor;
+  const pastLen = opts.pastLen ?? 1;
+  const inNames = session.inputNames, outNames = session.outputNames;
+  if (inNames.includes("attention_mask")) throw new Error("decode-only: a graph with attention_mask is not decode-only");
+  const meta = Array.isArray(session.inputMetadata) ? session.inputMetadata : Object.entries(session.inputMetadata ?? {}).map(([name, m]) => ({ name, ...m }));
+  const metaBy = new Map(meta.map((m) => [m.name, m]));
+  const specs = [];
+  for (const n of inNames) {
+    if (n === "input_ids" || n === "cache_position") continue;
+    const m = metaBy.get(n);
+    if (!m?.shape) throw new Error("decode-only: no shape metadata for input " + n);
+    specs.push({ name: n, type: m.type, dims: cacheDims(n, m.shape, pastLen) });
+  }
+  const pastOf = /* @__PURE__ */ new Map();
+  for (const o of outNames) {
+    const p = pastNameFor(o);
+    if (p && inNames.includes(p)) pastOf.set(o, p);
+  }
+  const missing = specs.filter((s) => ![...pastOf.values()].includes(s.name));
+  if (missing.length) throw new Error("decode-only: cache inputs without a matching present output: " + missing.slice(0, 3).map((s) => s.name).join(", "));
+  const hiddenName = HIDDEN_NAMES.find((n) => outNames.includes(n)) ?? null;
+  const hasCachePos = inNames.includes("cache_position");
+  const zeros = (s) => {
+    const n = s.dims.reduce((a, b) => a * b, 1);
+    if (s.type === "float32") return new T("float32", new Float32Array(n), s.dims);
+    if (s.type === "float16") return new T("float16", F16 ? new F16(n) : new Uint16Array(n), s.dims);
+    throw new Error(`decode-only: unsupported cache dtype: ${s.type} (${s.name})`);
+  };
+  const initState = () => {
+    const st = {};
+    for (const s of specs) st[s.name] = zeros(s);
+    return st;
+  };
+  const fetchBase = ["logits", ...pastOf.keys()];
+  async function step(tid, pos, st, wantHidden) {
+    const feed2 = { input_ids: new T("int64", BigInt64Array.from([BigInt(tid)]), [1, 1]), ...st };
+    if (hasCachePos) feed2.cache_position = new T("int64", BigInt64Array.from([BigInt(pos)]), [1]);
+    const names = wantHidden && hiddenName ? [...fetchBase, hiddenName] : fetchBase;
+    const r = await session.run(feed2, names);
+    const ns = {};
+    for (const [o, p] of pastOf) ns[p] = r[o];
+    const hidden = wantHidden && hiddenName ? tensorToF32(r[hiddenName].data, r[hiddenName].type) : void 0;
+    return { logits: r.logits, st: ns, hidden };
+  }
+  async function feed(ids, from, st, want) {
+    const wanted = new Set(want.positions), at = /* @__PURE__ */ new Map();
+    let last = null;
+    for (let i = from; i < ids.length; i++) {
+      const r = await step(ids[i], i, st, wanted.has(i));
+      st = r.st;
+      last = r.logits;
+      if (r.hidden) at.set(i, r.hidden);
+    }
+    return { hiddens: want.positions.map((p) => at.get(p)), lastLogits: lastRow(last) };
+  }
+  const checkHidden = (want) => {
+    if (want.positions.length && !hiddenName) throw new Error("decode-only: the graph does not expose a hidden state (outputs: " + outNames.slice(-3).join(", ") + ")");
+  };
+  const gate = createGate("decode-only");
+  const snaps = /* @__PURE__ */ new WeakMap();
+  return {
+    kind: "decode-only",
+    hiddenName,
+    dispose() {
+      return gate.dispose(() => session.release?.());
+    },
+    async prefill(ids, want) {
+      gate.assertLive();
+      checkHidden(want);
+      for (const p of new Set(want.positions)) if (p < 0 || p >= ids.length) throw new Error(`prefill: position ${p} out of [0,${ids.length})`);
+      if (!ids.length) throw new Error("prefill: empty ids");
+      const rel = await gate.acquire();
+      try {
+        return await feed(ids, 0, initState(), want);
+      } finally {
+        rel();
+      }
+    },
+    async snapshot(ids) {
+      gate.assertLive();
+      if (!ids.length) throw new Error("decode-only: snapshot of empty ids");
+      const rel = await gate.acquire();
+      try {
+        let st = initState();
+        for (let i = 0; i < ids.length; i++) st = (await step(ids[i], i, st, false)).st;
+        const h = { ids: ids.slice(), dispose() {
+          snaps.delete(h);
+        } };
+        snaps.set(h, st);
+        return h;
+      } finally {
+        rel();
+      }
+    },
+    async prefillFrom(h, ids, want) {
+      gate.assertLive();
+      const st = snaps.get(h);
+      if (!st) throw new Error("decode-only: unknown or released snapshot handle");
+      const k = checkContinuation("decode-only", h, ids, want.positions);
+      checkHidden(want);
+      const rel = await gate.acquire();
+      try {
+        return await feed(ids, k, st, want);
+      } finally {
+        rel();
+      }
+    },
+    async *generate(ids, o) {
+      gate.assertLive();
+      const g = resolveGenerateOptions(o);
+      const rand = mulberry32(g.seed);
+      if (!ids.length) throw new Error("generate: empty ids");
+      if (g.maxNewTokens === 0) return;
+      const rel = await gate.acquire();
+      try {
+        let st = initState(), pos = 0, last = null;
+        for (const t of ids) {
+          if (g.signal?.aborted) return;
+          ({ logits: last, st } = await step(t, pos, st, false));
+          pos++;
+        }
+        const gen = [];
+        for (let s = 0; s < g.maxNewTokens; s++) {
+          if (g.signal?.aborted) break;
+          const tid = sample(lastRow(last), gen, rand, g);
+          if (EOS.has(tid)) break;
+          gen.push(tid);
+          yield tid;
+          if (s + 1 >= g.maxNewTokens || g.signal?.aborted) break;
+          ({ logits: last, st } = await step(tid, pos, st, false));
+          pos++;
+        }
+      } finally {
+        rel();
+      }
+    }
+  };
+}
+
+// src/backends/genai.ts
+function parsePlacement(lines) {
+  const out = {};
+  for (const l of lines) {
+    const m = /Node\(s\) placed on \[(\w+)\]\.\s*Number of nodes:\s*(\d+)/.exec(l);
+    if (m) out[m[1]] = (out[m[1]] ?? 0) + Number(m[2]);
+  }
+  return out;
+}
+function assertWebGpuPlacement(p, maxCpuNodes = 32) {
+  const gpu = Object.entries(p).filter(([k]) => /webgpu/i.test(k)).reduce((a, [, n]) => a + n, 0);
+  const cpu = p.CPUExecutionProvider ?? 0;
+  if (!Object.keys(p).length) throw new Error("genai: could not verify the EP placement (no 'Node(s) placed on' logs); reject a bundle without WebGPU");
+  if (gpu === 0) throw new Error(`genai: no node on the WebGPU EP (placement: ${JSON.stringify(p)}); LinearAttention does not run on GPU`);
+  if (cpu > maxCpuNodes) throw new Error(`genai: ${cpu} nodes on CPU (> ${maxCpuNodes}); probably a bundle without the WebGPU kernels (use onnxruntime-web/webgpu). Placement: ${JSON.stringify(p)}`);
+}
+function genaiFromSession(session, ort, opts = {}) {
+  const T = ort.Tensor;
+  const eos = opts.eos ?? EOS;
+  const inNames = session.inputNames, outNames = session.outputNames;
+  for (const need of ["input_ids"]) if (!inNames.includes(need)) throw new Error(`genai: graph without input ${need}`);
+  if (!outNames.includes("logits")) throw new Error("genai: graph without a logits output");
+  const hasMask = inNames.includes("attention_mask"), hasPos = inNames.includes("position_ids");
+  const meta = Array.isArray(session.inputMetadata) ? session.inputMetadata : Object.entries(session.inputMetadata ?? {}).map(([name, m]) => ({ name, ...m }));
+  const metaBy = new Map(meta.map((m) => [m.name, m]));
+  const specs = [];
+  for (const n of inNames) {
+    if (n === "input_ids" || n === "attention_mask" || n === "position_ids") continue;
+    const m = metaBy.get(n);
+    if (!m?.shape) throw new Error("genai: no shape metadata for input " + n);
+    const dims = cacheDims(n, m.shape, 0);
+    if (/^past_key_values\./.test(n) && typeof m.shape[3] !== "number") dims[3] = opts.kvHeadDim ?? 256;
+    specs.push({ name: n, type: m.type, dims });
+  }
+  const pastOf = /* @__PURE__ */ new Map();
+  for (const o of outNames) {
+    const p = pastNameFor(o);
+    if (p && inNames.includes(p)) pastOf.set(o, p);
+  }
+  const covered = new Set(pastOf.values());
+  const missing = specs.filter((s) => !covered.has(s.name));
+  if (missing.length) throw new Error("genai: cache inputs without a present output: " + missing.slice(0, 3).map((s) => s.name).join(", "));
+  const hiddenName = HIDDEN_NAMES.find((n) => outNames.includes(n)) ?? null;
+  const posRows = (() => {
+    const sh = metaBy.get("position_ids")?.shape;
+    return typeof sh?.[0] === "number" ? sh[0] : 3;
+  })();
+  const zeros = (s) => {
+    const n = s.dims.reduce((a, b) => a * b, 1);
+    if (s.type === "float16") return new T("float16", new Uint16Array(n), s.dims);
+    if (s.type === "float32") return new T("float32", new Float32Array(n), s.dims);
+    throw new Error(`genai: unsupported cache dtype: ${s.type}`);
+  };
+  const initState = () => {
+    const st = {};
+    for (const s of specs) st[s.name] = zeros(s);
+    return st;
+  };
+  const free = (st) => {
+    if (st) {
+      for (const t of Object.values(st)) if (t?.location === "gpu-buffer") {
+        try {
+          t.dispose?.();
+        } catch {
+        }
+      }
+    }
+  };
+  const gate = createGate("genai");
+  async function run(chunk, past, st, wantLogits, wantHidden, keep = false) {
+    const S = chunk.length;
+    const feed = { input_ids: new T("int64", BigInt64Array.from(chunk.map(BigInt)), [1, S]), ...st };
+    if (hasMask) feed.attention_mask = new T("int64", new BigInt64Array(past + S).fill(1n), [1, past + S]);
+    if (hasPos) {
+      const pos = new BigInt64Array(posRows * S);
+      for (let r2 = 0; r2 < posRows; r2++) for (let i = 0; i < S; i++) pos[r2 * S + i] = BigInt(past + i);
+      feed.position_ids = new T("int64", pos, [posRows, 1, S]);
+    }
+    const fetches = [...pastOf.keys()];
+    if (wantLogits) fetches.unshift("logits");
+    if (wantHidden && hiddenName) fetches.push(hiddenName);
+    const r = await session.run(feed, fetches, { logSeverityLevel: 3 });
+    const ns = {};
+    for (const [o, p] of pastOf) ns[p] = r[o];
+    if (!keep) free(st);
+    const out = {};
+    if (wantLogits) out.logits = r.logits;
+    if (wantHidden && hiddenName) out.hidden = r[hiddenName];
+    return { st: ns, out };
+  }
+  const read = async (t) => typeof t.getData === "function" ? await t.getData(true) : t.data;
+  async function feedAll(ids, wanted, wantLast, signal, from) {
+    let st = from?.st ?? initState(), past = from?.past ?? 0;
+    const kept = from?.st;
+    const hid = /* @__PURE__ */ new Map();
+    let lastLogits;
+    try {
+      while (past < ids.length) {
+        if (signal?.aborted) return { st, past, hid, lastLogits, aborted: true };
+        const chunk = ids.slice(past, past + self.chunk), last = past + chunk.length >= ids.length;
+        const need = [...wanted].filter((p) => p >= past && p < past + chunk.length);
+        const r = await run(chunk, past, st, last && wantLast, need.length > 0, st === kept);
+        st = r.st;
+        if (r.out.hidden) {
+          const H = r.out.hidden, D = H.dims.at(-1), d = await read(H);
+          for (const p of need) hid.set(p, tensorToF32(d, H.type, (p - past) * D, D));
+        }
+        if (r.out.logits) {
+          const L = r.out.logits, V = L.dims.at(-1), d = await read(L);
+          lastLogits = tensorToF32(d, L.type, (L.dims.at(-2) - 1) * V, V);
+        }
+        past += chunk.length;
+      }
+    } catch (e) {
+      if (st !== kept) free(st);
+      throw e;
+    }
+    return { st, past, hid, lastLogits, aborted: false };
+  }
+  const snaps = /* @__PURE__ */ new WeakMap();
+  const self = {
+    kind: "genai",
+    chunk: Math.max(1, opts.chunk ?? 128),
+    hiddenName,
+    dispose() {
+      return gate.dispose(() => session.release?.());
+    },
+    async prefill(ids, want) {
+      gate.assertLive();
+      for (const p of want.positions) if (!Number.isInteger(p) || p < 0 || p >= ids.length) throw new Error(`genai: position ${p} out of [0,${ids.length})`);
+      if (!ids.length) throw new Error("prefill: empty ids");
+      if (want.positions.length && !hiddenName) throw new Error("genai: the graph does not expose a hidden state; use method 'logits'");
+      const rel = await gate.acquire();
+      try {
+        const f = await feedAll(ids, new Set(want.positions), true);
+        free(f.st);
+        return { hiddens: want.positions.map((p) => f.hid.get(p)), lastLogits: f.lastLogits };
+      } finally {
+        rel();
+      }
+    },
+    async snapshot(ids) {
+      gate.assertLive();
+      if (!ids.length) throw new Error("genai: snapshot of empty ids");
+      const rel = await gate.acquire();
+      try {
+        const f = await feedAll(ids, /* @__PURE__ */ new Set(), false);
+        let st = f.st;
+        const h = { ids: ids.slice(), dispose: async () => {
+          if (!st) return;
+          const s0 = st;
+          st = null;
+          snaps.delete(h);
+          let r = null;
+          try {
+            r = await gate.acquire();
+          } catch {
+          }
+          try {
+            free(s0);
+          } finally {
+            r?.();
+          }
+        } };
+        snaps.set(h, st);
+        return h;
+      } finally {
+        rel();
+      }
+    },
+    async prefillFrom(h, ids, want) {
+      gate.assertLive();
+      const st = snaps.get(h);
+      if (!st) throw new Error("genai: unknown or released snapshot handle");
+      const k = checkContinuation("genai", h, ids, want.positions);
+      if (want.positions.length && !hiddenName) throw new Error("genai: the graph does not expose a hidden state; use method 'logits'");
+      const rel = await gate.acquire();
+      try {
+        const f = await feedAll(ids, new Set(want.positions), true, void 0, { st, past: k });
+        free(f.st);
+        return { hiddens: want.positions.map((p) => f.hid.get(p)), lastLogits: f.lastLogits };
+      } finally {
+        rel();
+      }
+    },
+    async *generate(ids, o) {
+      gate.assertLive();
+      const g = resolveGenerateOptions(o);
+      const rand = mulberry32(g.seed);
+      if (!ids.length) throw new Error("generate: empty ids");
+      if (g.maxNewTokens === 0) return;
+      const rel = await gate.acquire();
+      let st = null;
+      try {
+        if (o.signal?.aborted) return;
+        const f = await feedAll(ids, /* @__PURE__ */ new Set(), true, o.signal);
+        st = f.st;
+        if (f.aborted) return;
+        let past = f.past, logits = f.lastLogits;
+        const gen = [];
+        for (let s = 0; s < g.maxNewTokens; s++) {
+          if (o.signal?.aborted) break;
+          const tid = sample(logits, gen, rand, g);
+          if (eos.has(tid)) break;
+          gen.push(tid);
+          yield tid;
+          if (o.signal?.aborted || s + 1 >= g.maxNewTokens) break;
+          const r = await run([tid], past, st, true, false);
+          st = r.st;
+          past++;
+          const L = r.out.logits, V = L.dims.at(-1);
+          logits = tensorToF32(await read(L), L.type, (L.dims.at(-2) - 1) * V, V);
+        }
+      } finally {
+        free(st);
+        rel();
+      }
+    }
+  };
+  return self;
+}
+function hashStr(x) {
+  let h = 2166136261;
+  for (let i = 0; i < x.length; i++) {
+    h ^= x.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+async function adapterTag(opts) {
+  if (typeof opts.adapterTag === "string") return opts.adapterTag;
+  if (typeof opts.adapterTag === "function") return opts.adapterTag();
+  try {
+    const gpu = globalThis.navigator?.gpu;
+    const ad = await gpu?.requestAdapter?.();
+    const i = ad?.info ?? await ad?.requestAdapterInfo?.();
+    if (!i) return "?";
+    return hashStr([i.vendor, i.architecture, i.device, i.description].join("|"));
+  } catch {
+    return "?";
+  }
+}
+function epStore(opts) {
+  if (opts.epCache !== void 0) return opts.epCache;
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+async function probePlacement(ort, modelUrl, sessionOpts, maxCpuNodes) {
+  const captured = [];
+  const names = ["log", "info", "warn", "error", "debug"];
+  const saved = {};
+  const prevLevel = ort.env?.logLevel;
+  if (ort.env) ort.env.logLevel = "verbose";
+  for (const n of names) {
+    saved[n] = console[n];
+    console[n] = (...a) => {
+      const s = a.join(" ");
+      if (s.includes("Node(s) placed on")) captured.push(s);
+      else if (!s.includes("[V:onnxruntime") && !/WebGPU Shader code|^\s*$/.test(s)) saved[n].apply(console, a);
+    };
+  }
+  let probe;
+  try {
+    probe = await ort.InferenceSession.create(modelUrl, sessionOpts(0));
+  } finally {
+    for (const n of names) console[n] = saved[n];
+    if (ort.env) ort.env.logLevel = prevLevel;
+  }
+  try {
+    assertWebGpuPlacement(parsePlacement(captured), maxCpuNodes);
+  } finally {
+    await probe.release?.();
+  }
+}
+async function createGenai(modelUrl, dataUrl, opts = {}) {
+  const providers = opts.providers ?? ["webgpu"];
+  if (providers[0] !== "webgpu") throw new Error("genai: the graph requires the webgpu EP as first provider (the LinearAttention/CausalConvWithState kernels only exist on WebGPU)");
+  const ort = opts.ort ?? await import("onnxruntime-web/webgpu");
+  const verify = opts.verifyEp ?? true;
+  const sessionOpts = (level) => ({
+    executionProviders: providers.map((n) => n === "webgpu" ? { name: "webgpu", validationMode: "disabled" } : n),
+    externalData: [{ path: "model.onnx.data", data: dataUrl }],
+    graphOptimizationLevel: "all",
+    enableGraphCapture: false,
+    preferredOutputLocation: "gpu-buffer",
+    logSeverityLevel: level
+  });
+  if (!opts.skipVersionCheck) checkOrtVersion(ort.env?.versions?.web);
+  if (verify) {
+    const store = epStore(opts);
+    const maxCpu = opts.maxCpuNodes ?? 32;
+    const key = store ? `ct0-edge:genai-ep:${ort.env?.versions?.web ?? "?"}:${await adapterTag(opts)}:${modelUrl}:${dataUrl}:${maxCpu}` : "";
+    let cached = false;
+    if (verify !== "force" && store) {
+      try {
+        cached = store.getItem(key) === "ok";
+      } catch {
+      }
+    }
+    if (!cached) {
+      await probePlacement(ort, modelUrl, sessionOpts, maxCpu);
+      if (store) {
+        try {
+          store.setItem(key, "ok");
+        } catch {
+        }
+      }
+    }
+  }
+  const session = await ort.InferenceSession.create(modelUrl, sessionOpts(3));
+  try {
+    const be = genaiFromSession(session, ort, opts);
+    if (opts.warmup ?? true) await be.prefill([248045], { positions: [] });
+    return be;
+  } catch (e) {
+    try {
+      await session.release?.();
+    } catch {
+    }
+    throw e;
+  }
+}
+
+// src/backends/transformersjs.ts
+function transformersJsFromModel(model, Tensor) {
+  const sess = model.sessions?.model ?? Object.values(model.sessions ?? {})[0];
+  const outs = sess?.outputNames ?? [];
+  const hiddenName = HIDDEN_NAMES.find((n) => outs.includes(n)) ?? null;
+  const toTensors = (ids) => ({
+    input_ids: new Tensor("int64", BigInt64Array.from(ids.map(BigInt)), [1, ids.length]),
+    attention_mask: new Tensor("int64", new BigInt64Array(ids.length).fill(1n), [1, ids.length])
+  });
+  const gate = createGate("scan");
+  return {
+    kind: "scan",
+    hiddenName,
+    async prefill(ids, want) {
+      gate.assertLive();
+      const n = ids.length;
+      if (!n) throw new Error("prefill: empty ids");
+      for (const p of want.positions) if (!Number.isInteger(p) || p < 0 || p >= n) throw new Error(`transformers.js: position ${p} out of range [0,${n})`);
+      if (want.positions.length && !hiddenName) throw new Error("transformers.js: graph has no hidden output; use method 'logits'");
+      const rel = await gate.acquire();
+      try {
+        const out = await model.forward(toTensors(ids));
+        const L = out.logits, V = L.dims.at(-1);
+        const lastLogits = tensorToF32(L.data, L.type, (L.dims.at(-2) - 1) * V, V);
+        const hiddens = [];
+        if (want.positions.length) {
+          const H = out[hiddenName], D = H.dims.at(-1);
+          if (H.dims.at(-2) !== n) throw new Error(`transformers.js: hidden seq ${H.dims.at(-2)} != ${n}`);
+          for (const p of want.positions) hiddens.push(tensorToF32(H.data, H.type, p * D, D));
+        }
+        return { hiddens, lastLogits };
+      } finally {
+        rel();
+      }
+    },
+    dispose() {
+      return gate.dispose(() => model.dispose?.());
+    },
+    async *generate(ids, o) {
+      gate.assertLive();
+      const g = resolveGenerateOptions(o);
+      const max = g.maxNewTokens, temp = g.temperature;
+      if (!ids.length) throw new Error("generate: empty ids");
+      if (max === 0) return;
+      const rel = await gate.acquire();
+      const queue = [];
+      let done = false, wake = null, err = null, first = true, stop = false;
+      const ping = () => {
+        const w = wake;
+        wake = null;
+        w?.();
+      };
+      const streamer = {
+        put(v) {
+          if (first) {
+            first = false;
+            return;
+          }
+          if (stop) return;
+          for (const t of v.flat ? v.flat() : v) queue.push(Number(t));
+          ping();
+        },
+        end() {
+          done = true;
+          ping();
+        }
+      };
+      const criterion = (batch) => batch.map(() => stop || !!o.signal?.aborted);
+      const args = { ...toTensors(ids), max_new_tokens: max, streamer, stopping_criteria: [criterion], do_sample: temp > 0 };
+      if (temp > 0) {
+        args.temperature = temp;
+        args.top_p = g.topP;
+        args.top_k = g.topK;
+      }
+      args.repetition_penalty = g.repetitionPenalty;
+      const run = Promise.resolve().then(() => model.generate(args)).then(() => {
+        done = true;
+        ping();
+      }, (e) => {
+        err = e;
+        done = true;
+        ping();
+      });
+      let emitted = 0;
+      try {
+        while (true) {
+          if (o.signal?.aborted) break;
+          if (queue.length) {
+            const t = queue.shift();
+            if (EOS.has(t)) break;
+            yield t;
+            if (++emitted >= max) break;
+          } else if (done) break;
+          else await new Promise((r) => {
+            wake = r;
+            if (queue.length || done) ping();
+          });
+        }
+      } finally {
+        stop = true;
+        try {
+          await run;
+        } finally {
+          rel();
+        }
+      }
+      if (err && !o.signal?.aborted) throw err;
+    }
+  };
+}
+
+// src/positions.ts
+var CHOICE_Q = "Which vulnerability class does this code contain?";
+var SEV_Q = "How severe is the security risk in this content? (1=none, 5=critical)";
+function renderPrompt(state, question) {
+  return "<|im_start|>system\nYou are a security decision function. Answer with exactly one word: Yes or No.<|im_end|>\n<|im_start|>user\n<state>" + state + "</state>\n<q>" + question + "</q><decide><|im_end|>\n<|im_start|>assistant\n";
+}
+var KINDS = ["noul", "choice", "score"];
+function assertProbe(p) {
+  const q = p;
+  if (!q || typeof q !== "object") throw new Error("probe: expected an object {kind, state, ...}");
+  if (!KINDS.includes(q.kind)) {
+    const hint = q.kind === void 0 && "type" in q ? ` (the field is \`kind\`, not \`type\`: {kind: ${JSON.stringify(q.type)}, state, q})` : "";
+    throw new Error(`probe: invalid kind ${JSON.stringify(q.kind)}; use "noul", "choice" or "score"${hint}`);
+  }
+  if (typeof q.state !== "string") throw new Error("probe: state must be a string");
+  if (q.kind === "choice") {
+    const o = q.options;
+    if (!Array.isArray(o) || !o.length) throw new Error("probe: choice requires options (non-empty list)");
+    const seen = /* @__PURE__ */ new Set();
+    for (const x of o) {
+      if (typeof x !== "string" || !x.trim()) throw new Error("probe: option label empty or not a string: " + JSON.stringify(x));
+      if (/<\/?opt>/.test(x)) throw new Error("probe: option label cannot contain <opt> / </opt>: " + JSON.stringify(x));
+      if (seen.has(x)) throw new Error("probe: duplicate option label: " + JSON.stringify(x));
+      seen.add(x);
+    }
+  }
+}
+function promptFor(p) {
+  assertProbe(p);
+  if (p.kind === "noul") return renderPrompt(p.state, p.q ?? "");
+  if (p.kind === "choice") {
+    return renderPrompt(p.state, CHOICE_Q + " " + (p.options ?? []).map((o) => "<opt>" + o + "</opt>").join(""));
+  }
+  return renderPrompt(p.state, SEV_Q);
+}
+function decidePos(tokens) {
+  const imEnd = [];
+  tokens.forEach((s, i) => {
+    if (s === "<|im_end|>") imEnd.push(i);
+  });
+  if (!imEnd.length) throw new Error("decidePos: no <|im_end|> in " + JSON.stringify(tokens.slice(-8)));
+  let lastAsst = -1;
+  tokens.forEach((s, i) => {
+    if (s.trim() === "assistant") lastAsst = i;
+  });
+  const cand = lastAsst >= 0 ? imEnd.filter((i) => i < lastAsst) : [];
+  const end = cand.length ? cand[cand.length - 1] : imEnd[imEnd.length - 1];
+  if (end === 0) throw new Error("decidePos: <|im_end|> at position 0, no preceding token");
+  if (tokens[end - 1] !== ">") {
+    throw new Error("decidePos: token before <|im_end|> is " + JSON.stringify(tokens[end - 1]) + ", expected '>' (end of <decide>)");
+  }
+  return end - 1;
+}
+function optPositions(prompt, offsets) {
+  const out = [];
+  const from = Math.max(0, prompt.lastIndexOf("<q>"));
+  for (const m of prompt.slice(from).matchAll(/<\/opt>/g)) {
+    const c = from + m.index + m[0].length - 1;
+    const hit = offsets.findIndex(([s, e]) => s <= c && c < e);
+    if (hit < 0) throw new Error("optPositions: no token covers char " + c);
+    out.push(hit);
+  }
+  return out;
+}
+function optPositionsFor(prompt, offsets, nOptions) {
+  const pos = optPositions(prompt, offsets);
+  if (nOptions === void 0) nOptions = (prompt.slice(Math.max(0, prompt.lastIndexOf("<q>"))).match(/<opt>/g) ?? []).length;
+  if (pos.length !== nOptions) throw new Error(`positions: ${pos.length} </opt> markers after <q> for ${nOptions} options (label containing </opt>?)`);
+  return pos;
+}
+function tokenOffsets(tok, prompt) {
+  const ids = Array.from(tok.encode(prompt, { add_special_tokens: false }), (x) => Number(x));
+  const dec = (a) => tok.decode(a, { skip_special_tokens: false, clean_up_tokenization_spaces: false });
+  const tokens = ids.map((i) => dec([i]));
+  const offsets = [];
+  let prev = 0;
+  let full = "";
+  for (let i = 0; i < ids.length; i++) {
+    full = dec(ids.slice(0, i + 1));
+    let end = full.length;
+    while (end > prev && full.charCodeAt(end - 1) === 65533) end--;
+    offsets.push([prev, end]);
+    prev = end;
+  }
+  if (full !== prompt) throw new Error("tokenOffsets: reconstruction != prompt (offsets not reliable)");
+  return { ids, tokens, offsets };
+}
+
+// src/systemone.ts
+function loadHead(buf) {
+  const dv = new DataView(buf);
+  const jsonLen = dv.getUint32(0, true);
+  const meta = JSON.parse(new TextDecoder().decode(new Uint8Array(buf, 4, jsonLen)));
+  let off = 4 + jsonLen;
+  const take = (n) => {
+    const avail = Math.floor((buf.byteLength - off) / 2);
+    if (n > avail) throw new Error(`head binary too short: needs ${n} fp16, ${avail} available`);
+    const f32 = new Float32Array(n);
+    for (let i = 0; i < n; i++) f32[i] = f16ToF32(dv.getUint16(off + i * 2, true));
+    off += n * 2;
+    return f32;
+  };
+  return {
+    q: take(meta.headDim * meta.hiddenSize),
+    qb: take(meta.headDim),
+    k: take(meta.headDim * meta.hiddenSize),
+    kb: take(meta.headDim),
+    headDim: meta.headDim,
+    hiddenSize: meta.hiddenSize,
+    temperature: meta.temperature,
+    scoreOffset: meta.score_offset ?? 0
+  };
+}
+function f16ToF32(h) {
+  const s = (h & 32768) >> 15, e = (h & 31744) >> 10, f = h & 1023;
+  if (e === 0) return (s ? -1 : 1) * Math.pow(2, -14) * (f / 1024);
+  if (e === 31) return f ? NaN : s ? -Infinity : Infinity;
+  return (s ? -1 : 1) * Math.pow(2, e - 15) * (1 + f / 1024);
+}
+function proj(W, b, x, dim, hidden) {
+  const y = new Float32Array(dim);
+  for (let d = 0; d < dim; d++) {
+    let acc = b[d];
+    const row = d * hidden;
+    for (let i = 0; i < hidden; i++) acc += W[row + i] * x[i];
+    y[d] = acc;
+  }
+  return y;
+}
+function dot(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+var sigmoid = (z) => 1 / (1 + Math.exp(-z));
+function headScore(hd, hq, hk) {
+  if (!hq || !hk || hq.length < hd.hiddenSize || hk.length < hd.hiddenSize) return NaN;
+  const a = proj(hd.q, hd.qb, hq, hd.headDim, hd.hiddenSize);
+  const b = proj(hd.k, hd.kb, hk, hd.headDim, hd.hiddenSize);
+  const s = dot(a, b) / hd.temperature + (hd.scoreOffset || 0);
+  return Number.isFinite(s) ? s : NaN;
+}
+function answer(hd, q, hiddens) {
+  if (q.type === "noul") {
+    const raw2 = headScore(hd, hiddens.atDecide, hiddens.atLast);
+    return { type: "noul", noul: sigmoid(raw2), raw: raw2 };
+  }
+  if (q.type === "choice") {
+    const opts = q.options || [];
+    const per = hiddens.perOption || [];
+    if (!per.length) return { type: "choice", choice: {} };
+    const choice = {};
+    const raws = [];
+    for (let i = 0; i < opts.length; i++) {
+      const h = per[i];
+      if (!h) {
+        choice[opts[i]] = 0;
+        raws.push(-Infinity);
+        continue;
+      }
+      const r = headScore(hd, hiddens.atDecide, h);
+      raws.push(r);
+      choice[opts[i]] = r;
+    }
+    const mx = Math.max(...raws.filter(Number.isFinite));
+    let z = 0;
+    const exps = raws.map((r) => Number.isFinite(r) ? Math.exp(r - mx) : 0);
+    z = exps.reduce((a, b) => a + b, 0) || 1;
+    for (let i = 0; i < opts.length; i++) choice[opts[i]] = exps[i] / z;
+    return { type: "choice", choice };
+  }
+  const K = q.levels || 5;
+  const raw = headScore(hd, hiddens.atDecide, hiddens.atLast);
+  const p = sigmoid(raw);
+  const score = Math.max(1, Math.min(K, Math.round(p * (K - 1) + 1)));
+  return { type: "score", score, raw };
+}
+
+// src/ask.ts
+var YES_ID = 9175;
+var NO_ID = 2665;
+var DIGIT_IDS = [16, 17, 18, 19, 20];
+var DEFAULT_METHOD = { noul: "logits", choice: "head", score: "head" };
+var sigmoid2 = (z) => 1 / (1 + Math.exp(-z));
+function softmax(xs) {
+  const mx = Math.max(...xs);
+  const e = xs.map((x) => Math.exp(x - mx));
+  const z = e.reduce((a, b) => a + b, 0) || 1;
+  return e.map((v) => v / z);
+}
+function argmax(xs) {
+  let b = 0;
+  for (let i = 1; i < xs.length; i++) if (xs[i] > xs[b]) b = i;
+  return b;
+}
+function toChoice(options, probs) {
+  const choice = {};
+  options.forEach((o, i) => {
+    choice[o] = probs[i];
+  });
+  return { choice, top: options[argmax(probs)] };
+}
+function levelFromCuts(x, cuts) {
+  let l = 1;
+  for (const c of cuts) if (x >= c) l++;
+  return l;
+}
+function checkCuts(cuts, n, read) {
+  if (cuts === void 0) return void 0;
+  if (!Array.isArray(cuts) || cuts.length !== n || !cuts.every(Number.isFinite) || cuts.some((c, i) => i > 0 && c <= cuts[i - 1]))
+    throw new Error(`ask: scoreCuts for the ${read} read must be ${n} finite ascending numbers, got ${JSON.stringify(cuts)}`);
+  return cuts;
+}
+function planAsk(be, tok, heads, q, opts) {
+  const maxSafe = opts.maxSafeTokens ?? 2048;
+  const prompt = promptFor(q);
+  const type = q.kind;
+  const method = opts.method ?? DEFAULT_METHOD[type];
+  if (method !== "head" && method !== "logits" && method !== "both") throw new Error(`ask: unknown method ${JSON.stringify(method)}; use "head", "logits" or "both"`);
+  const options = q.options ?? [];
+  const t = tokenOffsets(tok, prompt);
+  if (t.ids.length > maxSafe) throw new Error(`ask: prompt has ${t.ids.length} tokens, over maxSafeTokens (${maxSafe})`);
+  let headCuts, logitCuts;
+  if (type === "score" && opts.scoreCuts !== void 0) {
+    const sc = opts.scoreCuts;
+    if (Array.isArray(sc)) {
+      if (method === "both") throw new Error('ask: method "both" reads two scales; pass scoreCuts as { head, logits }');
+      if (method === "head") headCuts = sc;
+      else logitCuts = sc;
+    } else ({ head: headCuts, logits: logitCuts } = sc ?? {});
+    headCuts = checkCuts(headCuts, (q.levels || 5) - 1, "head");
+    logitCuts = checkCuts(logitCuts, DIGIT_IDS.length - 1, "logits");
+  }
+  const optFirst = type === "choice" ? options.map((o) => Number(tok.encode(o, { add_special_tokens: false })[0])) : [];
+  const fromLogits = (L) => {
+    if (type === "noul") {
+      const raw = L[YES_ID] - L[NO_ID];
+      return { type, method: "logits", raw, p: sigmoid2(raw) };
+    }
+    if (type === "choice") return { type, method: "logits", ...toChoice(options, softmax(optFirst.map((id) => L[id]))) };
+    const d = DIGIT_IDS.map((i) => L[i]);
+    const expected = softmax(d).reduce((a, p, i) => a + (i + 1) * p, 0);
+    return { type, method: "logits", level: logitCuts ? levelFromCuts(expected, logitCuts) : argmax(d) + 1, expected };
+  };
+  if (method === "logits") return { ids: t.ids, positions: [], read: (r) => fromLogits(r.lastLogits) };
+  if (!be.hiddenName) throw new Error(`ask: method '${method}' needs a graph with a hidden output (backend.hiddenName is null); use method 'logits'`);
+  const hd = type === "score" ? heads.score : heads.noulChoice;
+  if (!hd) throw new Error(type === "score" ? `ask: method '${method}' for score needs the score head (head_score.bin); load it via loadHeads({score})` : `ask: method '${method}' needs a loaded head for '${type}'`);
+  const dp = decidePos(t.tokens);
+  const withLogits = (r, L) => method === "both" ? { ...r, logits: fromLogits(L) } : r;
+  if (type === "choice") {
+    const op = optPositionsFor(prompt, t.offsets, options.length);
+    return { ids: t.ids, positions: [dp, ...op], read: ({ hiddens, lastLogits }) => {
+      const perOption = hiddens.slice(1);
+      const a = answer(hd, { type: "choice", options }, { atDecide: hiddens[0], atLast: perOption[perOption.length - 1], perOption });
+      return withLogits({ type, method: "head", ...toChoice(options, options.map((o) => a.choice[o])) }, lastLogits);
+    } };
+  }
+  return { ids: t.ids, positions: [dp, t.ids.length - 1], read: ({ hiddens, lastLogits }) => {
+    const a = answer(hd, { type, levels: q.levels }, { atDecide: hiddens[0], atLast: hiddens[1] });
+    if (type === "noul") return withLogits({ type, method: "head", raw: a.raw, p: a.noul }, lastLogits);
+    const level = headCuts && Number.isFinite(a.raw) ? levelFromCuts(a.raw, headCuts) : a.score;
+    return withLogits({ type, method: "head", raw: a.raw, level }, lastLogits);
+  } };
+}
+async function ask(be, tok, heads, q, opts = {}) {
+  const p = planAsk(be, tok, heads, q, opts);
+  return p.read(await be.prefill(p.ids, { positions: p.positions }));
+}
+function sharedPrefix(plans) {
+  let k = Math.min(...plans.map((p) => p.ids.length - 1), ...plans.flatMap((p) => p.positions));
+  const a = plans[0].ids;
+  for (const p of plans.slice(1)) {
+    let i = 0;
+    while (i < k && p.ids[i] === a[i]) i++;
+    k = i;
+  }
+  return k;
+}
+function askMany(be, tok, heads, state, qs, opts = {}) {
+  return askManyWith(be, tok, heads, state, qs, () => opts);
+}
+async function askManyWith(be, tok, heads, state, qs, optsFor) {
+  if (typeof state !== "string") throw new Error("askMany: state must be a string");
+  const plans = qs.map((q0) => {
+    if (q0?.state !== void 0 && q0.state !== state) throw new Error("askMany: a question carries a state different from the shared state");
+    const q = { ...q0, state };
+    return planAsk(be, tok, heads, q, optsFor(q));
+  });
+  const out = [];
+  const k = plans.length > 1 && be.snapshot && be.prefillFrom ? sharedPrefix(plans) : 0;
+  if (k < 1) {
+    for (const p of plans) out.push(p.read(await be.prefill(p.ids, { positions: p.positions })));
+    return out;
+  }
+  const h = await be.snapshot(plans[0].ids.slice(0, k));
+  try {
+    for (const p of plans) out.push(p.read(await be.prefillFrom(h, p.ids, { positions: p.positions })));
+  } finally {
+    await h.dispose();
+  }
+  return out;
+}
+
+// src/webllm.ts
+function logitCapture() {
+  let armed = false, cap = null, sampled = [];
+  return {
+    processor: {
+      processLogits(l) {
+        if (armed) {
+          cap = new Float32Array(l);
+          armed = false;
+        }
+        return l;
+      },
+      processSampledToken(t) {
+        sampled.push(t);
+      },
+      resetState() {
+      }
+    },
+    arm() {
+      armed = true;
+      cap = null;
+    },
+    take() {
+      const c = cap;
+      cap = null;
+      armed = false;
+      return c;
+    },
+    drain() {
+      const s = sampled;
+      sampled = [];
+      return s;
+    },
+    reset() {
+      armed = false;
+      cap = null;
+      sampled = [];
+    }
+  };
+}
+function normalizeRecovery(r) {
+  const N = r.rows.length;
+  if (!N || r.P.length % N) throw new Error(`webllm: P (${r.P.length}) is not a multiple of rows (${N})`);
+  let P;
+  if (r.P instanceof Uint16Array) {
+    P = new Float32Array(r.P.length);
+    for (let i = 0; i < P.length; i++) P[i] = halfToNumber(r.P[i]);
+  } else P = r.P;
+  return { rows: r.rows, P, D: P.length / N };
+}
+function recoverHidden(rec, logits) {
+  const r = "D" in rec ? rec : normalizeRecovery(rec);
+  const N = r.rows.length, sub = new Float32Array(N), h = new Float32Array(r.D);
+  for (let n = 0; n < N; n++) sub[n] = logits[r.rows[n]];
+  for (let d = 0; d < r.D; d++) {
+    let acc = 0;
+    const off = d * N;
+    for (let n = 0; n < N; n++) acc += r.P[off + n] * sub[n];
+    h[d] = acc;
+  }
+  return h;
+}
+async function loadRecovery(rowsUrl, pUrl, format = pUrl.endsWith(".f16") ? "f16" : "f32", fetchFn = fetch) {
+  const [rb, pb] = await Promise.all([
+    fetchFn(rowsUrl).then((r) => {
+      if (!r.ok) throw new Error("webllm: " + rowsUrl + " " + r.status);
+      return r.arrayBuffer();
+    }),
+    fetchFn(pUrl).then((r) => {
+      if (!r.ok) throw new Error("webllm: " + pUrl + " " + r.status);
+      return r.arrayBuffer();
+    })
+  ]);
+  return { rows: new Int32Array(rb), P: format === "f16" ? new Uint16Array(pb) : new Float32Array(pb) };
+}
+async function tryLoadRecovery(base, files, fetchFn = fetch) {
+  try {
+    const rec = await loadRecovery(new URL(files.rows, base).href, new URL(files.P, base).href, files.P.endsWith(".f16") ? "f16" : "f32", fetchFn);
+    const N = rec.rows.length;
+    if (!N || rec.P.length % N) throw new Error(`P (${rec.P.length}) is not a multiple of rows (${N})`);
+    return { recovery: rec };
+  } catch (e) {
+    return { reason: e?.message ?? String(e) };
+  }
+}
+function webllmBackend(engine, capture, opts) {
+  if (!opts.tok?.decode) throw new Error("webllm: opts.tok (tokenizer with decode) is required; WebLLM only accepts text");
+  const eos = opts.eos ?? EOS;
+  let rec = opts.recovery ? normalizeRecovery(opts.recovery) : null;
+  const gate = gateFor(engine, "webllm");
+  const decode = (ids) => opts.tok.decode(ids, { skip_special_tokens: false, clean_up_tokenization_spaces: false });
+  async function logitsAt(ids, k) {
+    await engine.resetChat();
+    capture.reset();
+    capture.arm();
+    const r = await engine.completions.create({ prompt: decode(ids.slice(0, k + 1)), max_tokens: 1, temperature: 0 });
+    const L = capture.take();
+    if (!L) throw new Error("webllm: the LogitProcessor captured no logits (engine created without this capture's logitProcessorRegistry, or a Web Worker?)");
+    const n = r?.usage?.prompt_tokens;
+    if (n !== void 0 && n !== k + 1) throw new Error(`webllm: the prompt truncated at position ${k} re-tokenized to ${n} tokens (expected ${k + 1}); the position read would be wrong`);
+    return L;
+  }
+  return {
+    kind: "webllm",
+    hiddenName: rec ? "recovered-from-logits" : null,
+    dispose() {
+      return gate.dispose(async () => {
+        rec = null;
+        await engine.unload?.();
+      });
+    },
+    async prefill(ids, want) {
+      gate.assertLive();
+      if (!ids.length) throw new Error("prefill: empty ids");
+      for (const p of want.positions) if (!Number.isInteger(p) || p < 0 || p >= ids.length) throw new Error(`webllm: position ${p} out of [0,${ids.length})`);
+      if (want.positions.length && !rec) throw new Error("webllm: without opts.recovery the backend cannot recover hidden states; use method 'logits'");
+      const rel = await gate.acquire();
+      try {
+        const last = ids.length - 1;
+        const lastLogits = await logitsAt(ids, last);
+        const at = /* @__PURE__ */ new Map();
+        for (const p of new Set(want.positions)) at.set(p, recoverHidden(rec, p === last ? lastLogits : await logitsAt(ids, p)));
+        return { hiddens: want.positions.map((p) => at.get(p).slice()), lastLogits };
+      } finally {
+        rel();
+      }
+    },
+    async *generate(ids, o) {
+      gate.assertLive();
+      const g = resolveGenerateOptions(o);
+      if (!ids.length) throw new Error("generate: empty ids");
+      if (g.maxNewTokens === 0) return;
+      const rel = await gate.acquire();
+      let iter = null, finished = false;
+      try {
+        if (o.signal?.aborted) return;
+        await engine.resetChat();
+        capture.reset();
+        const stream = await engine.completions.create({
+          prompt: decode(ids),
+          stream: true,
+          max_tokens: g.maxNewTokens,
+          temperature: g.temperature,
+          top_p: g.topP,
+          seed: g.seed,
+          repetition_penalty: g.repetitionPenalty
+        });
+        iter = stream[Symbol.asyncIterator]();
+        let n = 0, stop = false;
+        while (!stop) {
+          if (o.signal?.aborted) break;
+          const nx = await iter.next();
+          const toks = capture.drain();
+          if (nx.done) finished = true;
+          for (const t of toks) {
+            if (eos.has(t)) {
+              stop = true;
+              break;
+            }
+            if (n >= g.maxNewTokens) {
+              stop = true;
+              break;
+            }
+            n++;
+            yield t;
+            if (o.signal?.aborted) {
+              stop = true;
+              break;
+            }
+          }
+          if (nx.done) break;
+        }
+      } finally {
+        if (iter) {
+          try {
+            if (!finished) {
+              await engine.interruptGenerate();
+              for (let i = 0; i < 1e5; i++) {
+                const nx = await iter.next();
+                if (nx.done) break;
+              }
+            }
+          } catch {
+          }
+          try {
+            await iter.return?.();
+          } catch {
+          }
+        }
+        capture.reset();
+        rel();
+      }
+    }
+  };
+}
+async function createWebllm(webllm, opts) {
+  const capture = logitCapture();
+  const appConfig = opts.appConfig ?? { model_list: [{ model: opts.modelUrl, model_id: opts.modelId, model_lib: opts.libUrl }] };
+  const recovery = opts.recovery ?? (opts.recoveryUrls ? await loadRecovery(opts.recoveryUrls.rows, opts.recoveryUrls.P, opts.recoveryUrls.format) : void 0);
+  const engine = await webllm.CreateMLCEngine(opts.modelId, {
+    appConfig,
+    logitProcessorRegistry: /* @__PURE__ */ new Map([[opts.modelId, capture.processor]]),
+    initProgressCallback: opts.initProgressCallback
+  });
+  return Object.assign(webllmBackend(engine, capture, { tok: opts.tok, recovery, eos: opts.eos }), { engine, capture });
+}
+
+// src/backends/litert.ts
+var LITERTJS_VERSION = "2.6.0";
+var LITERT_WARNING = `ct0-edge: runtime "litert" is opt-in (LiteRT.js @litertjs/core ${LITERTJS_VERSION}, WebGPU with streamed weights; about 10x slower per decision than "genai"). Pass quiet: true to silence this note.`;
+function h2f(h) {
+  const s = h & 32768 ? -1 : 1, e = h >> 10 & 31, f = h & 1023;
+  return e === 0 ? s * 2 ** -14 * (f / 1024) : e === 31 ? f ? NaN : s * Infinity : s * 2 ** (e - 15) * (1 + f / 1024);
+}
+function embedFromF16Reader(read, hidden) {
+  return {
+    async rows(ids) {
+      const out = new Float32Array(ids.length * hidden), got = /* @__PURE__ */ new Map();
+      await Promise.all([...new Set(ids)].map(async (id) => {
+        const b = await read(id * hidden * 2, hidden * 2);
+        const c = b.byteOffset % 2 ? b.slice() : b;
+        got.set(id, new Uint16Array(c.buffer, c.byteOffset, hidden));
+      }));
+      ids.forEach((id, r) => {
+        const q = got.get(id);
+        for (let j = 0; j < hidden; j++) out[r * hidden + j] = h2f(q[j]);
+      });
+      return out;
+    }
+  };
+}
+function httpRangeReader(url, fetchFn = fetch) {
+  return async (offset, length) => {
+    const r = await fetchFn(url, { headers: { Range: `bytes=${offset}-${offset + length - 1}` } });
+    if (!r.ok) throw new Error(`litert: ${url} -> HTTP ${r.status}`);
+    const b = new Uint8Array(await r.arrayBuffer());
+    return r.status === 206 ? b : b.subarray(offset, offset + length);
+  };
+}
+var MASK_OFF = globalThis.__CT0_MASK_OFF ?? -1e30;
+function buildMask(pos, cache, dtype) {
+  const rows = pos.length;
+  if (dtype === "bool") {
+    const m2 = new Uint8Array(rows * cache);
+    for (let r = 0; r < rows; r++) m2.fill(1, r * cache, r * cache + pos[r] + 1);
+    return m2;
+  }
+  const m = new Float32Array(rows * cache).fill(MASK_OFF);
+  for (let r = 0; r < rows; r++) m.fill(0, r * cache, r * cache + pos[r] + 1);
+  return m;
+}
+function prefillChunks(n, P) {
+  const out = [];
+  for (let s = 0; s < n; s += P) out.push({ start: s, len: Math.min(P, n - s) });
+  return out;
+}
+var isState = (n) => n.startsWith("kv_cache_");
+var zerosOf = (io) => {
+  const n = io.shape.reduce((a, b) => a * b, 1);
+  return io.dtype === "int32" ? new Int32Array(n) : new Float32Array(n);
+};
+async function createLiteRt(lrt, graph, manifest, embed, opts = {}) {
+  if (!opts.quiet) console.warn(LITERT_WARNING);
+  const accelerator = opts.accelerator ?? "webgpu";
+  const sigNames = Object.keys(manifest.signatures);
+  const prefillName = sigNames.filter((s) => /^prefill_\d+$/.test(s)).sort((a, b) => +b.split("_")[1] - +a.split("_")[1])[0];
+  if (!prefillName || !manifest.signatures.decode) throw new Error(`litert: the graph needs prefill_<N> and decode signatures (has ${sigNames.join(", ")})`);
+  const P = +prefillName.split("_")[1];
+  const dec = manifest.signatures.decode;
+  const stateIO = dec.inputs.filter((i) => isState(i.name));
+  const maskIO = dec.inputs.find((i) => i.name === "mask");
+  if (!maskIO) throw new Error("litert: decode signature has no mask input");
+  const cache = maskIO.shape[maskIO.shape.length - 1];
+  const H = manifest.hidden;
+  const paramIO = dec.inputs.find((i) => i.name === "param_tensor");
+  const inplace = !!paramIO;
+  const hiddenOut = (dec.outputs.find((o) => o.name === "hidden") ?? dec.outputs.find((o) => /(^|[_/])hidden(_states)?$/.test(o.name)))?.name ?? null;
+  const gpuOptions = { precision: opts.gpuPrecision ?? "fp32" };
+  const copyState = opts.copyState ?? accelerator === "webgpu";
+  const model = accelerator === "webgpu" && opts.weights ? await lrt.loadModelAndWeights(graph, { getReader: () => opts.weights().getReader() }, { accelerator: "webgpu", gpuOptions }) : await lrt.loadAndCompile(graph, accelerator === "webgpu" ? { accelerator, gpuOptions } : { accelerator });
+  const T = (data, shape, dtype) => dtype ? new lrt.Tensor(data, shape, dtype) : new lrt.Tensor(data, shape);
+  const del = (t) => {
+    try {
+      t?.delete?.();
+    } catch {
+    }
+  };
+  const zeroStateHost = () => {
+    const st = {};
+    for (const io of stateIO) st[io.name] = T(zerosOf(io), io.shape);
+    return st;
+  };
+  async function freshState() {
+    const st = zeroStateHost();
+    if (inplace && accelerator === "webgpu") for (const k in st) {
+      const g = await st[k].moveTo("webgpu");
+      st[k] = g;
+    }
+    return st;
+  }
+  const freeState = (st) => {
+    for (const k in st) del(st[k]);
+  };
+  async function run(sig, emb, rows, pos, st, valid = rows) {
+    const feed = { ...st, embeddings: T(emb, [1, rows, H]), input_pos: T(pos, [rows]), mask: T(buildMask(pos, cache, maskIO.dtype), [1, 1, rows, cache], maskIO.dtype === "bool" ? "bool" : void 0) };
+    if (paramIO) {
+      const p = new Int32Array(paramIO.shape.reduce((a, b) => a * b, 1));
+      p[0] = pos[0];
+      p[1] = pos[0] + valid;
+      p[2] = pos[0] + valid;
+      feed.param_tensor = T(p, paramIO.shape);
+    }
+    const out = await model.run(sig, feed);
+    del(feed.embeddings);
+    del(feed.input_pos);
+    del(feed.mask);
+    del(feed.param_tensor);
+    if (inplace) return { st, logits: out.logits, hidden: hiddenOut ? out[hiddenOut] : void 0 };
+    const ns = {};
+    for (const io of stateIO) {
+      const t = out[io.name];
+      if (!t) throw new Error(`litert: ${sig} did not return ${io.name}`);
+      if (copyState && t.copyTo) {
+        ns[io.name] = await t.copyTo("wasm");
+        del(t);
+      } else ns[io.name] = t;
+    }
+    freeState(st);
+    return { st: ns, logits: out.logits, hidden: hiddenOut ? out[hiddenOut] : void 0 };
+  }
+  async function readLogits(L) {
+    const c = L.moveTo ? await L.moveTo("wasm") : L;
+    const a = Float32Array.from(c.toTypedArray());
+    if (c !== L) del(c);
+    del(L);
+    return a.subarray(a.length - manifest.vocab);
+  }
+  async function collectHidden(hid, firstPos, rows, want, at) {
+    if (!hid || !want.size) {
+      del(hid);
+      return;
+    }
+    const c = hid.moveTo ? await hid.moveTo("wasm") : hid;
+    const a = c.toTypedArray();
+    for (let r = 0; r < rows; r++) {
+      const p = firstPos + r;
+      if (want.has(p)) at.set(p, Float32Array.from(a.subarray(r * H, r * H + H)));
+    }
+    if (c !== hid) del(c);
+    del(hid);
+  }
+  async function prefillTokens(ids, from, end, st, want, at) {
+    const grab = async (r, firstPos, rows) => {
+      if (want && at) await collectHidden(r.hidden, firstPos, rows, want, at);
+      else del(r.hidden);
+    };
+    if (opts.decodeOnlyPrefill) {
+      for (let i = from; i < end; i++) {
+        const r = await run("decode", await embed.rows([ids[i]]), 1, Int32Array.from([i]), st);
+        st = r.st;
+        del(r.logits);
+        await grab(r, i, 1);
+      }
+      return st;
+    }
+    const remDec = opts.remainderViaDecode ?? accelerator === "webgpu";
+    for (const c of prefillChunks(end - from, P)) {
+      if (remDec && c.len < P) {
+        for (let i = from + c.start; i < from + c.start + c.len; i++) {
+          const r2 = await run("decode", await embed.rows([ids[i]]), 1, Int32Array.from([i]), st);
+          st = r2.st;
+          del(r2.logits);
+          await grab(r2, i, 1);
+        }
+        continue;
+      }
+      const toks = ids.slice(from + c.start, from + c.start + c.len);
+      const emb = new Float32Array(P * H);
+      emb.set(await embed.rows(toks));
+      const pos = new Int32Array(P);
+      for (let i = 0; i < c.len; i++) pos[i] = from + c.start + i;
+      const r = await run(prefillName, emb, P, pos, st, c.len);
+      st = r.st;
+      await grab(r, from + c.start, c.len);
+    }
+    return st;
+  }
+  async function decodeOne(tid, p, st) {
+    const r = await run("decode", await embed.rows([tid]), 1, Int32Array.from([p]), st);
+    return { st: r.st, logits: await readLogits(r.logits), hidden: r.hidden };
+  }
+  async function feedFrom(ids, from, st, positions) {
+    const want = new Set(positions);
+    const at = /* @__PURE__ */ new Map();
+    const last = ids.length - 1;
+    st = await prefillTokens(ids, from, last, st, want, at);
+    const r = await decodeOne(ids[last], last, st);
+    await collectHidden(r.hidden, last, 1, want, at);
+    freeState(r.st);
+    return { lastLogits: r.logits, hiddens: positions.map((p) => at.get(p)) };
+  }
+  const checkHidden = (want) => {
+    if (want.positions.length && !hiddenOut) throw new Error('litert: this graph has no hidden-state output; use ask() with method "logits"');
+  };
+  const gate = createGate("litert");
+  const snaps = /* @__PURE__ */ new WeakMap();
+  const snapshotState = async (st) => Promise.all(stateIO.map(async (io) => {
+    const t = st[io.name];
+    const c = t.moveTo ? await t.moveTo("wasm") : t;
+    const a = Float32Array.from(c.toTypedArray());
+    if (c !== t) del(c);
+    return a;
+  }));
+  const fromCopy = async (arrs) => {
+    const st = {};
+    stateIO.forEach((io, i) => {
+      st[io.name] = T(arrs[i].slice(), io.shape);
+    });
+    if (inplace && accelerator === "webgpu") for (const k in st) st[k] = await st[k].moveTo("webgpu");
+    return st;
+  };
+  return {
+    kind: "litert",
+    hiddenName: hiddenOut,
+    dispose() {
+      return gate.dispose(() => model.delete?.());
+    },
+    async prefill(ids, want) {
+      gate.assertLive();
+      checkHidden(want);
+      if (!ids.length) throw new Error("prefill: empty ids");
+      const rel = await gate.acquire();
+      try {
+        return await feedFrom(ids, 0, await freshState(), want.positions);
+      } finally {
+        rel();
+      }
+    },
+    async snapshot(ids) {
+      gate.assertLive();
+      if (!ids.length) throw new Error("litert: snapshot of empty ids");
+      const rel = await gate.acquire();
+      try {
+        const st = await prefillTokens(ids, 0, ids.length, await freshState());
+        const h = { ids: ids.slice(), dispose() {
+          snaps.delete(h);
+        } };
+        snaps.set(h, await snapshotState(st));
+        freeState(st);
+        return h;
+      } finally {
+        rel();
+      }
+    },
+    async prefillFrom(h, ids, want) {
+      gate.assertLive();
+      checkHidden(want);
+      const arrs = snaps.get(h);
+      if (!arrs) throw new Error("litert: unknown or released snapshot handle");
+      const k = checkContinuation("litert", h, ids, want.positions);
+      const rel = await gate.acquire();
+      try {
+        return await feedFrom(ids, k, await fromCopy(arrs), want.positions);
+      } finally {
+        rel();
+      }
+    },
+    async *generate(ids, o) {
+      gate.assertLive();
+      const g = resolveGenerateOptions(o), rand = mulberry32(g.seed);
+      if (!ids.length) throw new Error("generate: empty ids");
+      if (g.maxNewTokens === 0) return;
+      const rel = await gate.acquire();
+      let st = null;
+      try {
+        st = await prefillTokens(ids, 0, ids.length - 1, await freshState());
+        let r = await decodeOne(ids[ids.length - 1], ids.length - 1, st);
+        st = r.st;
+        const gen = [];
+        for (let s = 0, pos = ids.length; s < g.maxNewTokens; s++, pos++) {
+          if (g.signal?.aborted || pos >= cache) break;
+          const tid = sample(r.logits, gen, rand, g);
+          if (EOS.has(tid)) break;
+          gen.push(tid);
+          yield tid;
+          if (s + 1 >= g.maxNewTokens || g.signal?.aborted) break;
+          r = await decodeOne(tid, pos, st);
+          st = r.st;
+        }
+      } finally {
+        if (st) freeState(st);
+        rel();
+      }
+    }
+  };
+}
+
+// src/runtime.ts
+var DEFAULT_REPOS = {
+  genai: "eduardoworrel/alias3-micro-1026-ONNX-genai",
+  decodeOnly: "eduardoworrel/alias3-micro-1026-ONNX-decode-only",
+  onnx: "eduardoworrel/alias3-micro-1026-ONNX",
+  mlcQ4f16: "eduardoworrel/alias3-micro-1026-MLC-q4f16_1",
+  mlcQ4f32: "eduardoworrel/alias3-micro-1026-MLC-q4f32_1",
+  litert: "eduardoworrel/alias3-micro-1026-LiteRT"
+};
+var LITERT_QUANTS = ["int4", "int8", "int4-b64"];
+function litertBundleBase(o = {}) {
+  if (o.litertBaseUrl) return o.litertBaseUrl;
+  const q = o.litertQuant ?? "int4";
+  if (!LITERT_QUANTS.includes(q)) throw new Error(`ct0-edge: litertQuant must be one of ${LITERT_QUANTS.join(", ")} (got ${JSON.stringify(q)})`);
+  return `https://huggingface.co/${o.litertRepo ?? DEFAULT_REPOS.litert}/resolve/main/litert/${q}/`;
+}
+var DEFAULT_FILES = {
+  head: "heads/head.bin",
+  headScore: "heads/head_score.bin"
+};
+async function detectWebGPU(nav = globalThis.navigator) {
+  try {
+    const gpu = nav?.gpu;
+    if (!gpu?.requestAdapter) return false;
+    return !!await gpu.requestAdapter();
+  } catch {
+    return false;
+  }
+}
+var RUNTIMES = ["genai", "decode-only", "transformers.js", "webllm", "litert"];
+var DEVICES = ["webgpu", "wasm", "cpu", "cuda"];
+var RUNTIME_LIMITS = {
+  genai: { maxSafeTokens: 2048, byDevice: { webgpu: 7200 } },
+  "decode-only": { maxSafeTokens: 2048, byDevice: { webgpu: 3600, cpu: 7200 } },
+  "transformers.js": { maxSafeTokens: 2048 },
+  webllm: { maxSafeTokens: 2048 },
+  litert: { maxSafeTokens: 2e3 }
+};
+function maxSafeTokensFor(runtime, device) {
+  const l = RUNTIME_LIMITS[runtime];
+  return l.byDevice?.[device] ?? l.maxSafeTokens;
+}
+var MLC_Q4F32_LIB = "https://raw.githubusercontent.com/mlc-ai/binary-mlc-llm-libs/main/web-llm-models/v0_2_86/base/Qwen3.5-4B-q4f32_1_cs1k-webgpu.wasm";
+var RUNTIME_DEFAULTS = {
+  genai: {
+    repo: DEFAULT_REPOS.genai,
+    files: { webgpu: "webgpu/int4/model.onnx", cuda: "cuda/int4/model.onnx" },
+    heads: true,
+    methods: DEFAULT_METHOD
+  },
+  "decode-only": {
+    repo: DEFAULT_REPOS.decodeOnly,
+    file: "onnx/model_q4.onnx",
+    heads: true,
+    methods: DEFAULT_METHOD
+  },
+  "transformers.js": {
+    repo: DEFAULT_REPOS.onnx,
+    dtype: "q4",
+    heads: true,
+    methods: DEFAULT_METHOD
+  },
+  webllm: {
+    builds: {
+      q4f16_1: {
+        repo: DEFAULT_REPOS.mlcQ4f16,
+        modelId: "alias3-micro-1026-q4f16_1",
+        lib: "model-lib.wasm",
+        recovery: { rows: "recovery/P_q4f16_rows.i32", P: "recovery/P_q4f16_8192.f16" }
+      },
+      q4f32_1: {
+        repo: DEFAULT_REPOS.mlcQ4f32,
+        modelId: "alias3-micro-1026-q4f32_1",
+        lib: MLC_Q4F32_LIB,
+        recovery: { rows: "recovery/P_q4f32_rows.i32", P: "recovery/P_q4f32_8192.f16" }
+      }
+    },
+    build: "q4f32_1",
+    heads: true,
+    methods: DEFAULT_METHOD,
+    logitsOnlyMethods: { noul: "logits", choice: "logits", score: "logits" }
+  },
+  litert: {
+    repo: DEFAULT_REPOS.litert,
+    files: { manifest: "litert/manifest.json", graph: "litert/model.graph.tflite", weights: "litert/model.weights.bin", embed: "litert/embed.f16.bin" },
+    wasm: "https://cdn.jsdelivr.net/npm/@litertjs/core@2.6.0/wasm/",
+    heads: false,
+    methods: { noul: "logits", choice: "logits", score: "logits" }
+  }
+};
+function defaultMethods(runtime, opts = {}) {
+  if (runtime === "webllm" && !opts.webllmRecovery) return RUNTIME_DEFAULTS.webllm.logitsOnlyMethods;
+  if (runtime === "litert") return RUNTIME_DEFAULTS.litert.methods;
+  return DEFAULT_METHOD;
+}
+function resolveRuntimeChoice(o, fallback = "auto") {
+  if (o.runtime === void 0) return { choice: fallback };
+  if (o.runtime !== "auto" && !RUNTIMES.includes(o.runtime))
+    throw new Error(`ct0-edge: unknown runtime "${o.runtime}". Use "auto", ${RUNTIMES.map((r) => `"${r}"`).join(", ")}.`);
+  return { choice: o.runtime };
+}
+function detectPlatform(g = globalThis) {
+  const isNode = !!g.process?.versions?.node;
+  const hasDom = typeof g.window !== "undefined" && typeof g.document !== "undefined";
+  const isWorker = typeof g.WorkerGlobalScope !== "undefined" && typeof g.importScripts === "function";
+  return isNode && !hasDom && !isWorker ? "node" : "browser";
+}
+var GENAI_NODE_CPU_ERROR = 'ct0-edge: runtime "genai" does not run on onnxruntime-node CPU (the int4 graph fails with "not enough space: expected 49152, got 0"). In Node use runtime "decode-only" (CPU) or "transformers.js", or run genai on a CUDA machine (device "cuda").';
+function checkDevice(platform, device) {
+  if (!DEVICES.includes(device)) throw new Error(`ct0-edge: unknown device "${device}". Use "auto", ${DEVICES.map((d) => `"${d}"`).join(", ")}.`);
+  if (platform === "browser" && device === "cuda") throw new Error('ct0-edge: device "cuda" is Node-only. In the browser use "webgpu" or "wasm".');
+  if (platform === "node" && (device === "webgpu" || device === "wasm")) throw new Error(`ct0-edge: device "${device}" is browser-only. In Node use "cpu" or "cuda".`);
+}
+function deviceFor(runtime, want, caps) {
+  const { platform } = caps;
+  const dev = platform === "browser" && want === "cpu" ? "wasm" : want;
+  if (dev !== "auto") checkDevice(platform, dev);
+  const needGpu = (d) => {
+    if (d === "webgpu" && !caps.webgpu) throw new Error(`ct0-edge: runtime "${runtime}" on WebGPU, but WebGPU is not available in this browser.`);
+    return d;
+  };
+  const needCuda = (d) => {
+    if (d === "cuda" && !caps.cuda) throw new Error(`ct0-edge: runtime "${runtime}" on CUDA, but onnxruntime-node lists no CUDA execution provider here.`);
+    return d;
+  };
+  switch (runtime) {
+    case "genai":
+      if (platform === "browser") {
+        if (dev === "wasm") throw new Error('ct0-edge: runtime "genai" needs WebGPU in the browser (its LinearAttention kernels have no WASM build). Use runtime "decode-only" on "wasm".');
+        return needGpu("webgpu");
+      }
+      if (dev === "cpu") throw new Error(GENAI_NODE_CPU_ERROR);
+      if (!caps.cuda) throw new Error(GENAI_NODE_CPU_ERROR + " No CUDA execution provider was found.");
+      return "cuda";
+    case "webllm":
+      if (platform === "node") throw new Error('ct0-edge: runtime "webllm" runs only in the browser (WebGPU). In Node use "decode-only" or "transformers.js".');
+      if (dev === "wasm") throw new Error('ct0-edge: runtime "webllm" needs WebGPU.');
+      return needGpu("webgpu");
+    case "litert":
+      if (platform === "node") throw new Error('ct0-edge: runtime "litert" runs in the browser (LiteRT.js streams the weights into WebGPU buffers). In Node use "decode-only" or "transformers.js".');
+      if (dev === "wasm") throw new Error('ct0-edge: runtime "litert" needs WebGPU (the CT0 weights exceed the 2 GiB LiteRT.js Wasm heap).');
+      return needGpu("webgpu");
+    case "decode-only":
+    case "transformers.js":
+      if (dev !== "auto") return platform === "browser" ? needGpu(dev) : needCuda(dev);
+      return platform === "browser" ? caps.webgpu ? "webgpu" : "wasm" : "cpu";
+  }
+}
+function planRuntime(choice, device = "auto", caps) {
+  if (choice !== "auto") {
+    if (!RUNTIMES.includes(choice)) throw new Error(`ct0-edge: unknown runtime "${String(choice)}".`);
+    return [{ runtime: choice, device: deviceFor(choice, device, caps) }];
+  }
+  const { platform } = caps;
+  const dev = platform === "browser" && device === "cpu" ? "wasm" : device;
+  if (dev !== "auto") checkDevice(platform, dev);
+  if (platform === "browser") {
+    if (dev === "wasm") return [{ runtime: "decode-only", device: "wasm" }];
+    if (dev === "webgpu" && !caps.webgpu) throw new Error('ct0-edge: device "webgpu" requested, but WebGPU is not available in this browser.');
+    if (caps.webgpu) return [{ runtime: "genai", device: "webgpu" }, { runtime: "decode-only", device: "webgpu" }];
+    return [{ runtime: "decode-only", device: "wasm" }];
+  }
+  const nodeCpu = [{ runtime: "transformers.js", device: "cpu" }, { runtime: "decode-only", device: "cpu" }];
+  if (dev === "cpu") return nodeCpu;
+  if (dev === "cuda") {
+    if (!caps.cuda) throw new Error('ct0-edge: device "cuda" requested, but onnxruntime-node lists no CUDA execution provider here.');
+    return [{ runtime: "genai", device: "cuda" }, { runtime: "transformers.js", device: "cuda" }];
+  }
+  if (caps.cuda) return [{ runtime: "genai", device: "cuda" }, { runtime: "transformers.js", device: "cuda" }, ...nodeCpu];
+  return nodeCpu;
+}
+async function selectRuntime(choice, device, deps) {
+  const status = deps.onStatus ?? (() => {
+  });
+  const plans = planRuntime(choice, device, deps.caps);
+  if (choice !== "auto") return { ...plans[0], backend: await deps.load(plans[0]) };
+  const reasons = [];
+  if (plans[0].runtime !== "genai") {
+    const { platform, webgpu, cuda } = deps.caps;
+    reasons.push(platform === "browser" ? webgpu ? `device "${plans[0].device}" requested` : "WebGPU not available" : cuda ? `device "${plans[0].device}" requested` : "no CUDA execution provider (genai does not run on onnxruntime-node CPU)");
+  }
+  for (const [i, plan] of plans.entries()) {
+    if (i > 0) status(`${reasons.at(-1)} -> ${plan.runtime} (${plan.device})`);
+    try {
+      const backend = await deps.load(plan);
+      return { ...plan, backend, fallbackReason: reasons.length ? reasons.join("; ") : void 0 };
+    } catch (e) {
+      reasons.push(`${plan.runtime} (${plan.device}) unavailable: ${e?.message ?? String(e)}`);
+      if (i === plans.length - 1) {
+        const err = new Error(`ct0-edge: no runtime loaded. ${reasons.join("; ")}`);
+        err.cause = e;
+        throw err;
+      }
+    }
+  }
+  throw new Error("ct0-edge: no runtime candidate");
+}
+function packagesFor(runtime, platform) {
+  const ort = platform === "node" ? "onnxruntime-node" : "onnxruntime-web";
+  if (runtime === "genai" || runtime === "decode-only") return ["@huggingface/transformers", ort];
+  if (runtime === "webllm") return ["@huggingface/transformers", "@mlc-ai/web-llm"];
+  if (runtime === "litert") return ["@huggingface/transformers", "@litertjs/core"];
+  return ["@huggingface/transformers"];
+}
+function isNotFound(e, pkg) {
+  const msg = String(e?.message ?? e);
+  if (e?.code === "ERR_MODULE_NOT_FOUND" || e?.code === "MODULE_NOT_FOUND" || /Cannot find (package|module)/.test(msg)) return msg.includes(pkg);
+  return /Failed to resolve module specifier|Failed to fetch dynamically imported module|error loading dynamically imported module|Importing a module script failed/i.test(msg);
+}
+async function importOptional(pkg, importer, why) {
+  try {
+    return await importer();
+  } catch (e) {
+    if (!isNotFound(e, pkg)) throw e;
+    const err = new Error(`ct0-edge: ${why} needs the package "${pkg}", which is not installed. Install it: npm i ${pkg}`);
+    err.cause = e;
+    throw err;
+  }
+}
+function detectCuda(ortNode) {
+  try {
+    return !!ortNode?.listSupportedBackends?.().some((b) => b?.name === "cuda");
+  } catch {
+    return false;
+  }
+}
+
+// src/nodeFiles.ts
+var nodeImport = (spec) => import(spec);
+async function defaultCacheDir() {
+  const env = globalThis.process?.env ?? {};
+  if (env.CT0_CACHE) return env.CT0_CACHE;
+  const os = await nodeImport("node:os"), path = await nodeImport("node:path");
+  return path.join(env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache"), "ct0-edge");
+}
+async function localFile(url, cacheDir, onStatus = () => {
+}) {
+  const { fileURLToPath } = await nodeImport("node:url");
+  if (url.startsWith("file:")) return fileURLToPath(url);
+  if (!/^https?:/i.test(url)) return url;
+  const fs = await nodeImport("node:fs"), path = await nodeImport("node:path");
+  const u = new URL(url);
+  const dest = path.join(cacheDir, u.hostname, ...decodeURIComponent(u.pathname).split("/").filter((s) => s && s !== ".."));
+  if (fs.existsSync(dest)) return dest;
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  const part = `${dest}.part-${globalThis.process?.pid ?? 0}`;
+  const name = path.basename(dest);
+  try {
+    const res = await get(url);
+    const total = Number(res.headers["content-length"]) || 0;
+    let got = 0, shown = -1;
+    res.on("data", (c) => {
+      got += c.length;
+      const pct = total ? Math.floor(100 * got / total / 10) * 10 : -1;
+      if (pct !== shown && pct >= 0) {
+        shown = pct;
+        onStatus(`downloading ${name}: ${pct}% of ${(total / 1e9).toFixed(2)} GB`);
+      }
+    });
+    const { pipeline } = await nodeImport("node:stream/promises");
+    await pipeline(res, fs.createWriteStream(part));
+    if (total && got !== total) throw new Error(`ct0-edge: download truncated: ${url} (${got} of ${total} bytes)`);
+    fs.renameSync(part, dest);
+  } catch (e) {
+    try {
+      fs.rmSync(part, { force: true });
+    } catch {
+    }
+    throw e;
+  }
+  return dest;
+}
+async function get(url, hops = 0) {
+  const mod = await nodeImport(url.startsWith("https:") ? "node:https" : "node:http");
+  const res = await new Promise((resolve, reject) => mod.get(url, { headers: { "user-agent": "ct0-edge" } }, resolve).on("error", reject));
+  if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location && hops < 10) {
+    res.resume();
+    return get(new URL(res.headers.location, url).href, hops + 1);
+  }
+  if (res.statusCode !== 200) {
+    res.resume();
+    throw new Error(`ct0-edge: download failed: ${url} -> HTTP ${res.statusCode}`);
+  }
+  return res;
+}
+async function readLocalBytes(url) {
+  const { fileURLToPath } = await nodeImport("node:url");
+  const fs = await nodeImport("node:fs");
+  const b = fs.readFileSync(url.startsWith("file:") ? fileURLToPath(url) : url);
+  return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+
+// src/ct0.ts
+var CT0 = class _CT0 {
+  maxContext = 262144;
+  maxSafeTokens = 2048;
+  tok;
+  backend;
+  yesIds = [];
+  noIds = [];
+  constructor(tok, backend) {
+    this.tok = tok;
+    this.backend = backend;
+  }
+  heads = {};
+  methods = defaultMethods("decode-only");
+  runtime;
+  device;
+  fallbackReason;
+  dispose() {
+    return this.backend.dispose();
+  }
+  get hiddenOutput() {
+    return this.backend.hiddenName;
+  }
+  get defaultMethod() {
+    return this.methods;
+  }
+  static async load(opts = {}) {
+    const status = opts.onStatus ?? (() => {
+    });
+    const platform = detectPlatform();
+    const { choice } = resolveRuntimeChoice(opts, opts.baseUrl && !opts.genaiBaseUrl && !opts.genaiRepo ? "decode-only" : "auto");
+    const device = opts.device ?? "auto";
+    const webgpu = platform === "browser" ? await detectWebGPU() : false;
+    planRuntime(choice, device, { platform, webgpu, cuda: true });
+    const mods = opts.modules ?? {};
+    const needsOrt = choice === "auto" || choice === "genai" || choice === "decode-only";
+    const loadOrt = async () => {
+      if (mods.ort) return mods.ort;
+      if (platform === "node") return importOptional("onnxruntime-node", () => import(NODE_ORT), `runtime "${choice}" in Node`);
+      return importOptional("onnxruntime-web", () => import("onnxruntime-web/webgpu"), `runtime "${choice}" in the browser`);
+    };
+    let ort = null;
+    let cuda = false;
+    if (platform === "node" && (needsOrt || device === "cuda")) {
+      try {
+        ort = await loadOrt();
+        cuda = detectCuda(ort);
+      } catch (e) {
+        if (needsOrt) throw e;
+      }
+    }
+    const caps = { platform, webgpu, cuda };
+    status("loading tokenizer\u2026");
+    const tjs = mods.transformers ?? await importOptional("@huggingface/transformers", () => import("@huggingface/transformers"), "ct0-edge (tokenizer)");
+    const env = tjs.env;
+    const pageBase = () => {
+      if (typeof location !== "undefined") return location.href;
+      const cwd = globalThis.process?.cwd?.();
+      return cwd ? "file://" + encodeURI(cwd.replace(/\\/g, "/").replace(/^(?!\/)/, "/")) + "/" : void 0;
+    };
+    const absBase = (b) => new URL(b, pageBase()).href;
+    const at = (p, b) => new URL(p, absBase(b)).href;
+    const mlc = opts.mlc ?? {};
+    const mlcBuild = RUNTIME_DEFAULTS.webllm.builds[mlc.build ?? RUNTIME_DEFAULTS.webllm.build];
+    if (choice === "webllm" && !mlcBuild) throw new Error(`ct0-edge: unknown MLC build "${mlc.build}" (use "q4f32_1" or "q4f16_1")`);
+    const repo = opts.repo ?? (choice === "webllm" ? mlcBuild.repo : opts.baseUrl ? void 0 : DEFAULT_REPOS.decodeOnly);
+    let tok, base;
+    if (repo) {
+      env.allowRemoteModels = true;
+      env.allowLocalModels = false;
+      tok = await tjs.AutoTokenizer.from_pretrained(repo, { local_files_only: false });
+      base = opts.baseUrl ?? `https://huggingface.co/${repo}/resolve/main/`;
+    } else {
+      base = absBase(opts.baseUrl);
+      env.allowRemoteModels = false;
+      env.allowLocalModels = true;
+      const bu = new URL(base);
+      if (bu.protocol === "file:") {
+        const { fileURLToPath } = await import(NODE_URL);
+        env.localModelPath = fileURLToPath(bu);
+      } else env.localModelPath = typeof location !== "undefined" && bu.origin === location.origin ? bu.pathname : base;
+      tok = await tjs.AutoTokenizer.from_pretrained("tok");
+    }
+    const genaiBase = opts.genaiBaseUrl ?? `https://huggingface.co/${opts.genaiRepo ?? DEFAULT_REPOS.genai}/resolve/main/`;
+    const tjsRepo = opts.transformersRepo ?? RUNTIME_DEFAULTS["transformers.js"].repo;
+    const tjsBase = `https://huggingface.co/${tjsRepo}/resolve/main/`;
+    let cacheDir;
+    const fileFor = async (url) => {
+      if (platform !== "node") return url;
+      cacheDir ??= opts.cacheDir ?? await defaultCacheDir();
+      return localFile(url, cacheDir, status);
+    };
+    const loadDecodeOnly = async (dev) => {
+      ort ??= await loadOrt();
+      if (platform === "browser" && !opts.skipVersionCheck) checkOrtVersion(ort.env?.versions?.web);
+      const file = opts.decodeModel ?? RUNTIME_DEFAULTS["decode-only"].file;
+      const dataPath = opts.externalDataFile ?? file + "_data";
+      const providers = opts.providers ?? [dev];
+      const isLocal = /^(\.\/|\/)/.test(dataPath) || /^(\.\/|\/)/.test(file);
+      const modelUrl = isLocal ? at(file, pageBase()) : at(file, base);
+      const dataUrl = isLocal ? at(dataPath, pageBase()) : at(dataPath, base);
+      status(`loading decode-only graph (${providers.join(",")})\u2026`);
+      let S;
+      if (platform === "node") {
+        await fileFor(dataUrl);
+        S = await ort.InferenceSession.create(await fileFor(modelUrl), { executionProviders: providers, logSeverityLevel: 3 });
+      } else {
+        S = await ort.InferenceSession.create(modelUrl, {
+          executionProviders: providers,
+          externalData: [{ path: dataPath.split("/").pop(), data: dataUrl }]
+        });
+      }
+      try {
+        return await createDecodeOnly(S, tok, { ort, pastLen: opts.pastLen, skipVersionCheck: opts.skipVersionCheck });
+      } catch (e) {
+        try {
+          await S.release?.();
+        } catch {
+        }
+        throw e;
+      }
+    };
+    const loadGenai = async (dev) => {
+      ort ??= await loadOrt();
+      const file = opts.genaiModel ?? (dev === "cuda" ? RUNTIME_DEFAULTS.genai.files.cuda : RUNTIME_DEFAULTS.genai.files.webgpu);
+      status(`loading genai int4 graph (${dev})\u2026`);
+      if (platform === "browser")
+        return createGenai(
+          at(file, genaiBase),
+          at(file + ".data", genaiBase),
+          { ...opts.genai, verifyEp: opts.verifyEp ?? opts.genai?.verifyEp ?? false, ort, skipVersionCheck: opts.skipVersionCheck ?? opts.genai?.skipVersionCheck }
+        );
+      await fileFor(at(file + ".data", genaiBase));
+      const S = await ort.InferenceSession.create(await fileFor(at(file, genaiBase)), { executionProviders: [dev], graphOptimizationLevel: "all", logSeverityLevel: 3 });
+      try {
+        const be = genaiFromSession(S, ort, opts.genai);
+        if (opts.genai?.warmup ?? true) await be.prefill([248045], { positions: [] });
+        return be;
+      } catch (e) {
+        try {
+          await S.release?.();
+        } catch {
+        }
+        throw e;
+      }
+    };
+    const loadTransformers = async (dev) => {
+      const dtype = opts.dtype ?? RUNTIME_DEFAULTS["transformers.js"].dtype;
+      status(`loading transformers.js graph (${dtype}, ${dev})\u2026`);
+      env.allowRemoteModels = true;
+      env.allowLocalModels = false;
+      if (platform === "node" && opts.cacheDir) env.cacheDir = opts.cacheDir;
+      const model = await tjs.AutoModelForCausalLM.from_pretrained(tjsRepo, { dtype, device: dev });
+      return transformersJsFromModel(model, tjs.Tensor);
+    };
+    let mlcBase = null, mlcNote, webllmRecovery = false;
+    const loadWebllm = async () => {
+      const webllm = mods.webllm ?? await importOptional("@mlc-ai/web-llm", () => import(WEBLLM_PKG), 'runtime "webllm"');
+      const build = mlcBuild;
+      const modelUrl = mlc.modelUrl ?? `https://huggingface.co/${build.repo}/`;
+      const modelLib = mlc.modelLib ?? (/^https?:/.test(build.lib) ? build.lib : new URL("resolve/main/" + build.lib, modelUrl).href);
+      mlcBase = new URL("resolve/main/", modelUrl).href;
+      let recovery = mlc.recovery || void 0;
+      if (!recovery && mlc.recovery !== false) {
+        status("loading WebLLM hidden-state recovery\u2026");
+        const files = mlc.recoveryUrls ?? build.recovery;
+        const r = await tryLoadRecovery(mlcBase, files);
+        recovery = r.recovery;
+        if (!recovery) {
+          mlcNote = `webllm recovery unavailable (${r.reason}): every question type reads the logits`;
+          status(mlcNote);
+        }
+      }
+      webllmRecovery = !!recovery;
+      status(`loading WebLLM build ${mlc.build ?? RUNTIME_DEFAULTS.webllm.build}\u2026`);
+      return createWebllm(webllm, {
+        modelId: mlc.modelId ?? build.modelId,
+        modelUrl,
+        libUrl: modelLib,
+        appConfig: mlc.appConfig,
+        tok,
+        recovery,
+        initProgressCallback: mlc.initProgressCallback
+      });
+    };
+    const loadLitert = async (dev) => {
+      const lrt = mods.litert ?? await importOptional("@litertjs/core", () => import(LITERT_PKG), 'runtime "litert"');
+      const D = RUNTIME_DEFAULTS.litert;
+      const lbase = absBase(litertBundleBase(opts));
+      const name = (f) => f.replace(/^litert\//, "");
+      status(`loading LiteRT.js ${LITERTJS_VERSION} runtime\u2026`);
+      try {
+        await lrt.loadLiteRt(opts.litertWasmUrl ?? D.wasm, { jspi: !!globalThis.WebAssembly?.Suspending });
+      } catch (e) {
+        if (!/already loading|already loaded/i.test(String(e?.message ?? e))) throw e;
+      }
+      const manifest = await (await fetch(at(name(D.files.manifest), lbase))).json();
+      const graph = new Uint8Array(await (await fetch(at(name(D.files.graph), lbase))).arrayBuffer());
+      const weightsUrl = at(name(D.files.weights), lbase);
+      status("streaming LiteRT weights into WebGPU\u2026");
+      return createLiteRt(lrt, graph, manifest, embedFromF16Reader(httpRangeReader(at(name(D.files.embed), lbase)), manifest.hidden), {
+        accelerator: dev === "webgpu" ? "webgpu" : "wasm",
+        gpuPrecision: opts.litertPrecision,
+        weights: manifest.externalized === false ? void 0 : () => {
+          let body = null;
+          return new ReadableStream({
+            async pull(c) {
+              body ??= (await fetch(weightsUrl)).body.getReader();
+              const { done, value } = await body.read();
+              if (done) c.close();
+              else c.enqueue(value);
+            },
+            cancel() {
+              body?.cancel();
+            }
+          });
+        }
+      });
+    };
+    const load = (p) => {
+      switch (p.runtime) {
+        case "genai":
+          return loadGenai(p.device);
+        case "decode-only":
+          return loadDecodeOnly(p.device);
+        case "transformers.js":
+          return loadTransformers(p.device);
+        case "webllm":
+          return loadWebllm();
+        case "litert":
+          return loadLitert(p.device);
+      }
+    };
+    const sel = await selectRuntime(choice, device, { caps, load, onStatus: status });
+    const ct0 = new _CT0(tok, sel.backend);
+    ct0.runtime = sel.runtime;
+    ct0.device = sel.device;
+    ct0.fallbackReason = [sel.fallbackReason, sel.runtime === "webllm" ? mlcNote : void 0].filter(Boolean).join("; ") || void 0;
+    ct0.methods = defaultMethods(sel.runtime, { webllmRecovery });
+    ct0.maxSafeTokens = opts.maxSafeTokens ?? maxSafeTokensFor(sel.runtime, sel.device);
+    status(`runtime: ${sel.runtime} (${sel.device})`);
+    const headsBase = sel.runtime === "genai" ? genaiBase : sel.runtime === "decode-only" ? base : sel.runtime === "transformers.js" ? tjsBase : sel.runtime === "webllm" && webllmRecovery ? mlcBase : null;
+    if ((opts.heads ?? true) && headsBase) {
+      try {
+        await ct0.loadHeads({ noul: at(DEFAULT_FILES.head, headsBase), score: at(DEFAULT_FILES.headScore, headsBase) });
+      } catch (e) {
+        status("heads not loaded (" + (e?.message ?? e) + "); ask() with method head will throw");
+      }
+    }
+    const firstId = (s) => {
+      const a = ct0.ids(s);
+      return a.length ? a[0] : null;
+    };
+    ct0.yesIds = [...new Set(["Yes", " Yes", "yes", " yes", "YES"].map(firstId).filter((x) => x != null))];
+    ct0.noIds = [...new Set(["No", " No", "no", " no", "NO"].map(firstId).filter((x) => x != null))];
+    status("ready.");
+    return ct0;
+  }
+  ids(text) {
+    return this.tok(text, { add_special_tokens: false }).input_ids.tolist()[0].map(Number);
+  }
+  countTokens(text) {
+    return this.ids(text).length;
+  }
+  fitContext(text, opts = {}) {
+    const reserve = opts.reserve ?? 300;
+    const budget = Math.max(64, this.maxSafeTokens - reserve);
+    const toks = this.ids(text);
+    if (toks.length <= budget) return text;
+    const head = Math.floor(budget * 0.6), tail = budget - head;
+    const kept = [...toks.slice(0, head), ...toks.slice(toks.length - tail)];
+    opts.onTrim?.({ original: toks.length, kept: budget });
+    return this.tok.decode(kept, { skip_special_tokens: true });
+  }
+  async scanLong(text, question, opts = {}) {
+    const win = opts.windowTokens ?? this.maxSafeTokens - 400;
+    const overlap = opts.overlapTokens ?? 128;
+    const thr = opts.threshold ?? 0.5;
+    const toks = this.ids(text);
+    const hits = [];
+    if (toks.length <= win) {
+      const p = await this.decide(text, question);
+      opts.onChunk?.(0, p, 1);
+      hits.push({ i: 0, start: 0, p, preview: text.slice(0, 100) });
+    } else {
+      const total = Math.ceil((toks.length - overlap) / (win - overlap));
+      let i = 0, idx = 0;
+      while (i < toks.length) {
+        const chunk = this.tok.decode(toks.slice(i, i + win), { skip_special_tokens: true });
+        const p = await this.decide(chunk, question);
+        hits.push({ i: idx, start: i, p, preview: chunk.slice(0, 100) });
+        opts.onChunk?.(idx, p, total);
+        idx++;
+        i += win - overlap;
+      }
+    }
+    return { chunks: hits.length, max: Math.max(...hits.map((h) => h.p)), hits, flagged: hits.filter((h) => h.p >= thr) };
+  }
+  static inspectPage(doc) {
+    const q = (s, f) => [...doc.querySelectorAll(s)].map(f);
+    const comments = [];
+    const w = doc.createTreeWalker(doc.body || doc.documentElement, 128);
+    while (w.nextNode()) comments.push((w.currentNode.nodeValue || "").trim().slice(0, 180));
+    const store = {};
+    try {
+      const ls = (doc.defaultView || window).localStorage;
+      for (let i = 0; i < ls.length; i++) {
+        const k = ls.key(i);
+        store[k] = (ls.getItem(k) || "").slice(0, 80);
+      }
+    } catch {
+    }
+    return {
+      title: doc.title,
+      url: (doc.defaultView || {}).location?.search || "/",
+      forms: q("form", (f) => ({ action: f.getAttribute("action"), method: f.method, inputs: [...f.querySelectorAll("input")].map((i) => ({ name: i.name, type: i.type, value: i.type === "hidden" ? i.value : void 0, autocomplete: i.autocomplete })) })),
+      inputs: q("input,textarea", (i) => ({ sel: i.id ? "#" + i.id : i.name ? `[name=${i.name}]` : i.tagName.toLowerCase(), type: i.type })),
+      buttons: q("button", (b) => ({ sel: b.id ? "#" + b.id : null, text: b.textContent.trim() })),
+      links: q("a[href]", (a) => a.getAttribute("href")),
+      texts: q("pre,code,[class*='debug'],[class*='error'],[class*='stack']", (e) => (e.textContent || "").trim().slice(0, 300)).filter(Boolean),
+      comments,
+      inlineScripts: q("script:not([src])", (s) => s.textContent.trim().slice(0, 220)).filter(Boolean),
+      localStorage: store
+    };
+  }
+  static pageSource(doc, max = 2500) {
+    return (doc.body || doc.documentElement).outerHTML.slice(0, max);
+  }
+  turn(msg, system, think) {
+    let t = "";
+    if (system) t += "<|im_start|>system\n" + system + "<|im_end|>\n";
+    t += "<|im_start|>user\n" + msg + "<|im_end|>\n<|im_start|>assistant\n";
+    return t + (think ? "<think>\n" : "<think>\n\n</think>\n\n");
+  }
+  async *generate(prompt, opts = {}) {
+    yield* this.stream(this.turn(prompt, opts.system, opts.think ?? true), opts);
+  }
+  async *stream(prompt, opts = {}) {
+    for await (const tid of this.backend.generate(this.ids(prompt), opts)) yield this.tok.decode([tid], { skip_special_tokens: true });
+  }
+  async decide(state, question) {
+    const sys = "You are a security decision function. Given a STATE and a yes/no QUESTION, answer with exactly one word: Yes or No.";
+    const text = "<|im_start|>system\n" + sys + "<|im_end|>\n<|im_start|>user\nSTATE:\n" + state + "\n\nQUESTION: " + question + "\nAnswer Yes or No.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n";
+    const { lastLogits: L } = await this.backend.prefill(this.ids(text), { positions: [] });
+    const all = [...this.yesIds, ...this.noIds];
+    if (!all.length) return NaN;
+    const mx = Math.max(...all.map((i) => L[i]));
+    const Z = all.reduce((a, i) => a + Math.exp(L[i] - mx), 0);
+    return this.yesIds.reduce((a, i) => a + Math.exp(L[i] - mx), 0) / Z;
+  }
+  async loadHeads(src) {
+    const get2 = async (x) => {
+      if (typeof x !== "string") return loadHead(x);
+      if (x.startsWith("file:")) return loadHead(await readLocalBytes(x));
+      const r = await fetch(x);
+      if (!r.ok) throw new Error(`loadHeads: ${x} -> HTTP ${r.status}`);
+      return loadHead(await r.arrayBuffer());
+    };
+    const nc = src.noul ?? src.choice;
+    if (nc) this.heads.noulChoice = await get2(nc);
+    if (src.score) this.heads.score = await get2(src.score);
+  }
+  ask(q, opts = {}) {
+    return ask(this.backend, this.tok, this.heads, q, this.askOpts(q, opts));
+  }
+  askMany(state, qs, opts = {}) {
+    return askManyWith(this.backend, this.tok, this.heads, state, qs, (q) => this.askOpts(q, opts));
+  }
+  askOpts(q, opts) {
+    return { ...opts, method: opts.method ?? this.methods[q.kind], maxSafeTokens: opts.maxSafeTokens ?? this.maxSafeTokens };
+  }
+  async prefillHiddens(prompt) {
+    if (!this.backend.hiddenName) return null;
+    const t = tokenOffsets(this.tok, prompt);
+    const dp = decidePos(t.tokens), lp = t.ids.length - 1, op = optPositionsFor(prompt, t.offsets);
+    const { hiddens } = await this.backend.prefill(t.ids, { positions: [dp, lp, ...op] });
+    return { atDecide: hiddens[0], atLast: hiddens[1], atOpts: hiddens.slice(2) };
+  }
+};
+var NODE_ORT = "onnxruntime-node";
+var NODE_URL = "node:url";
+var WEBLLM_PKG = "@mlc-ai/web-llm";
+var LITERT_PKG = "@litertjs/core";
+export {
+  CT0,
+  DEFAULT_FILES,
+  DEFAULT_METHOD,
+  DEFAULT_REPOS,
+  GENAI_NODE_CPU_ERROR,
+  GENERATE_DEFAULTS,
+  LITERT_QUANTS,
+  MLC_Q4F32_LIB,
+  RUNTIMES,
+  RUNTIME_DEFAULTS,
+  RUNTIME_LIMITS,
+  askMany,
+  defaultMethods,
+  detectCuda,
+  detectPlatform,
+  detectWebGPU,
+  importOptional,
+  levelFromCuts,
+  litertBundleBase,
+  maxSafeTokensFor,
+  packagesFor,
+  planRuntime,
+  resolveGenerateOptions,
+  resolveRuntimeChoice,
+  selectRuntime
+};