Upload folder using huggingface_hub

core/agents.js

@@ -0,0 +1,74 @@
+// core/agents.js — AGENTS as κ-objects (LibreChat agent semantics, substrate-native). An agent
+// bundles identity + instructions + model + parameters + armed tools + conversation starters;
+// selecting one shapes every turn (instructions ride the system block, its tool selection arms
+// the MCP loop). Field names follow the LibreChat agent schema so exports interoperate; each
+// version re-seals to a new κ (history is free, Law L3).
+
+import { normPreset } from "./schema.js";
+
+const LC = { lc: "https://librechat.ai/ns#" };
+
+export function normAgent(a = {}) {
+  return {
+    id: typeof a.id === "string" ? a.id : null,
+    name: a.name || "New Agent",
+    description: a.description || "",
+    instructions: a.instructions || "",
+    avatar: a.avatar || null,                          // { filepath, source } | emoji string | null
+    provider: a.provider || "holo-q",                  // the local substrate engine
+    model: a.model || null,                            // a MODELS[] name
+    model_parameters: {
+      temperature: +(a.model_parameters?.temperature ?? 0) || 0,
+      max_output_tokens: +(a.model_parameters?.max_output_tokens ?? 900) || 900,
+    },
+    tools: Array.isArray(a.tools) ? a.tools : [],      // armed tool names (the MCP loop selection)
+    mcpServerNames: Array.isArray(a.mcpServerNames) ? a.mcpServerNames : [],
+    conversation_starters: Array.isArray(a.conversation_starters) ? a.conversation_starters.filter(Boolean).slice(0, 4) : [],
+    artifacts: a.artifacts || "default",               // 'default' | 'custom' (custom: instructions own the format)
+    recursion_limit: +(a.recursion_limit ?? 4) || 4,   // max tool rounds
+    category: a.category || "general",
+    version: +(a.version ?? 1) || 1,
+  };
+}
+
+export function makeAgents(chatStore) {
+  const { store, getIndex, newId } = chatStore;
+  const putIndex = async (idx) => { const b = new TextEncoder().encode(JSON.stringify(idx)); return store.backend.putRaw ? store.backend.putRaw("index:org.hologram.HoloQ", b) : store.backend.put("index:org.hologram.HoloQ", b); };
+
+  async function save(a) {
+    const norm = normAgent(a);
+    if (!norm.id) norm.id = newId("agent");
+    const prevPtr = ((await getIndex()).agents || []).find((x) => x.id === norm.id);
+    if (prevPtr) norm.version = (prevPtr.version || 1) + 1;
+    const obj = await store.makeObject({
+      type: ["schema:SoftwareAgent", "prov:Entity"], context: [LC],
+      "schema:identifier": norm.id, "schema:name": norm.name, "schema:description": norm.description,
+      "lc:agent": norm,
+      ...(prevPtr ? { links: [{ ...store.contentLink("prov:wasRevisionOf", prevPtr.kappa, "schema:SoftwareAgent"), "schema:name": "previousVersion" }] } : {}),
+    });
+    const idx = await getIndex();
+    idx.agents = idx.agents || [];
+    const ptr = { id: norm.id, kappa: obj.id, name: norm.name, avatar: norm.avatar, category: norm.category, version: norm.version };
+    const i = idx.agents.findIndex((x) => x.id === norm.id);
+    if (i >= 0) idx.agents[i] = ptr; else idx.agents.push(ptr);
+    await putIndex(idx);
+    return { ...norm, kappa: obj.id };
+  }
+
+  async function list() { return (await getIndex()).agents || []; }
+
+  async function get(id) {
+    const ptr = (await list()).find((x) => x.id === id); if (!ptr) return null;
+    const obj = await store.getObj(ptr.kappa); if (!obj) return null;
+    if (!(await store.verify(obj))) return null;       // Law L5: a tampered agent is refused
+    return { ...normAgent(obj["lc:agent"]), kappa: ptr.kappa };
+  }
+
+  async function remove(id) {
+    const idx = await getIndex();
+    idx.agents = (idx.agents || []).filter((x) => x.id !== id);
+    await putIndex(idx);
+  }
+
+  return { save, list, get, remove, normAgent };
+}

core/backend.js

@@ -0,0 +1,23 @@
+// core/backend.js — the durable byte backend for the κ-object store: IndexedDB via the OS
+// runtime's _shared/holo-store.js (Law L3: the store is the memory; RAM is a bounded cache).
+// Keys are κ hex strings (plus the one well-known boot-index pointer key). Same async shape
+// as the witness's Map backend, so the L5 contract exercises identical code in both runtimes.
+
+import { idbBackend } from "../_shared/holo-store.js";
+
+export function kappaBackend() {
+  const idb = idbBackend({ db: "holo-q", store: "kappa" });
+  return {
+    get: async (hex) => (await idb.get(hex)) || undefined,
+    put: (hex, bytes) => idb.set(hex, bytes),
+    getRaw: async (k) => (await idb.get(k)) || undefined,
+    putRaw: (k, bytes) => idb.set(k, bytes),
+    has: (k) => idb.has(k),
+  };
+}
+
+// Storage usage for the Settings → Data tab (W3C StorageManager).
+export async function storageEstimate() {
+  try { const e = await navigator.storage.estimate(); return { usage: e.usage || 0, quota: e.quota || 0 }; }
+  catch { return { usage: 0, quota: 0 }; }
+}

core/code-tools.js

@@ -0,0 +1,130 @@
+// core/code-tools.js — NATIVE agentic-coding tools for Holo Q's Code mode. Self-contained over the
+// browser's OPFS (navigator.storage.getDirectory) — no external VFS, works in any browser, 100%
+// serverless. Each tool returns Holo Q's agent-tool shape { def, serverName:"code", call }, so the
+// Coder-7B brain drives real file work through the existing agentic loop + conscience gate + receipts.
+// The workspace is an OPFS "workspace" dir = the agent's writable home; every result is content-addressable.
+//
+// C2 semantic skin (extended to all κ-objects): build_app emits a schema:SoftwareApplication node and
+// verify_object returns the file's schema.org @type — so every object the agent makes is W3C-legible.
+
+import { appAsSoftware, fileAsDocument } from "./semantic.js";
+
+const te = new TextEncoder(), td = new TextDecoder();
+const sha256Hex = async (bytes) => [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((b) => b.toString(16).padStart(2, "0")).join("");
+const norm = (p) => ("/" + String(p || "").replace(/^\/+/, "").replace(/\/+/g, "/")).replace(/\/$/, "") || "/";
+
+async function root() { const d = await navigator.storage.getDirectory(); return d.getDirectoryHandle("workspace", { create: true }); }
+async function dirOf(parts, create = false) {
+  let h = await root();
+  for (const p of parts) if (p) h = await h.getDirectoryHandle(p, { create });
+  return h;
+}
+function split(path) { const parts = norm(path).split("/").filter(Boolean); const name = parts.pop(); return { parts, name }; }
+
+async function readFile(path) {
+  const { parts, name } = split(path);
+  const dir = await dirOf(parts);
+  const fh = await dir.getFileHandle(name);
+  const f = await fh.getFile();
+  return new Uint8Array(await f.arrayBuffer());
+}
+async function writeFile(path, content) {
+  const { parts, name } = split(path);
+  const dir = await dirOf(parts, true);
+  const fh = await dir.getFileHandle(name, { create: true });
+  const w = await fh.createWritable(); await w.write(te.encode(String(content ?? ""))); await w.close();
+}
+async function walk(dirHandle, prefix, out) {
+  for await (const [n, h] of dirHandle.entries()) {
+    const p = prefix + "/" + n;
+    if (h.kind === "file") out.push(p);
+    else await walk(h, p, out);
+  }
+}
+async function listAll() { const out = []; await walk(await root(), "", out); return out.sort(); }
+
+function globToRe(glob) {
+  let re = "^";
+  for (let i = 0; i < glob.length; i++) { const c = glob[i];
+    if (c === "*") { if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++; } else re += "[^/]*"; }
+    else if (c === "?") re += "[^/]"; else if ("\\^$.|+()[]{}".includes(c)) re += "\\" + c; else re += c; }
+  return new RegExp(re + "$");
+}
+
+export function codeTools() {
+  return [
+    {
+      def: { name: "read_file", description: "Read a text file from the workspace. Returns its content.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+      serverName: "code", call: async ({ path }) => {
+        try { const bytes = await readFile(path); return { text: td.decode(bytes), isError: false }; }
+        catch (e) { return { text: "read error: " + (e.message || e), isError: true }; }
+      },
+    },
+    {
+      def: { name: "write_file", description: "Create or overwrite a file in the workspace with the given content.", inputSchema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
+      serverName: "code", call: async ({ path, content }) => {
+        try { await writeFile(path, content); const k = await sha256Hex(te.encode(String(content ?? ""))); return { text: `wrote ${norm(path)} (${String(content ?? "").length} bytes) · did:holo:sha256:${k.slice(0, 16)}`, isError: false }; }
+        catch (e) { return { text: "write error: " + (e.message || e), isError: true }; }
+      },
+    },
+    {
+      def: { name: "edit_file", description: "Replace the first exact occurrence of old_text with new_text in a file.", inputSchema: { type: "object", properties: { path: { type: "string" }, old_text: { type: "string" }, new_text: { type: "string" } }, required: ["path", "old_text", "new_text"] } },
+      serverName: "code", call: async ({ path, old_text, new_text }) => {
+        try { const cur = td.decode(await readFile(path)); if (!cur.includes(old_text)) return { text: "edit error: old_text not found", isError: true };
+          const next = cur.replace(old_text, new_text); await writeFile(path, next); return { text: `edited ${norm(path)} (${cur.length}→${next.length} bytes)`, isError: false }; }
+        catch (e) { return { text: "edit error: " + (e.message || e), isError: true }; }
+      },
+    },
+    {
+      def: { name: "list_files", description: "List all files in the workspace, optionally filtered by a glob (e.g. **/*.py).", inputSchema: { type: "object", properties: { glob: { type: "string" } }, required: [] } },
+      serverName: "code", call: async ({ glob }) => {
+        try { let files = await listAll(); if (glob) { const re = globToRe(glob); files = files.filter((f) => re.test(f)); }
+          return { text: files.length ? files.join("\n") : "(workspace empty)", isError: false }; }
+        catch (e) { return { text: "list error: " + (e.message || e), isError: true }; }
+      },
+    },
+    {
+      def: { name: "grep", description: "Search file contents for a regular expression. Returns matching path:line: text.", inputSchema: { type: "object", properties: { pattern: { type: "string" }, glob: { type: "string" } }, required: ["pattern"] } },
+      serverName: "code", call: async ({ pattern, glob }) => {
+        try { const re = new RegExp(pattern); let files = await listAll(); if (glob) { const g = globToRe(glob); files = files.filter((f) => g.test(f)); }
+          const hits = [];
+          for (const f of files) { let text; try { text = td.decode(await readFile(f)); } catch { continue; }
+            text.split("\n").forEach((ln, i) => { if (re.test(ln) && hits.length < 100) hits.push(`${f}:${i + 1}: ${ln.trim().slice(0, 160)}`); }); }
+          return { text: hits.length ? hits.join("\n") : "(no matches)", isError: false }; }
+        catch (e) { return { text: "grep error: " + (e.message || e), isError: true }; }
+      },
+    },
+    // ── κ-NATIVE: build a RENDERABLE app object, sealed (the neural-computer flagship: an agent
+    // produces a real app, content-addressed, that renders + re-derives — serverless, verifiable) ──
+    {
+      def: { name: "build_app", description: "Build a complete self-contained HTML app (one file, inline CSS/JS) and seal it as a content-addressed object. Returns its did:holo κ; the app renders live in the preview pane. Use for 'build me an app/page/tool' requests.", inputSchema: { type: "object", properties: { name: { type: "string" }, html: { type: "string" } }, required: ["name", "html"] } },
+      serverName: "code", call: async ({ name, html }) => {
+        try {
+          const path = (name.endsWith(".html") ? name : name + ".html");
+          await writeFile(path, html);
+          const bytes = te.encode(String(html));
+          const kappa = "did:holo:sha256:" + await sha256Hex(bytes);
+          // semantic skin: the app object carries a W3C @type (schema:SoftwareApplication + prov:Entity),
+          // written as a sidecar .jsonld so the object is self-describing to any agent / RDF tool.
+          const ld = appAsSoftware({ name: path, kappa, bytes: bytes.length });
+          await writeFile(path.replace(/\.html$/i, "") + ".app.jsonld", JSON.stringify(ld, null, 1));
+          return { text: `built app "${path}" (${html.length} bytes), sealed ${kappa.slice(0, 30)}… · typed ${ld["@type"].join("+")} — renders in the preview, re-derivable (Law L5).`, isError: false, render: { kind: "app", path: norm(path), kappa, html: String(html), ld } };
+        } catch (e) { return { text: "build_app error: " + (e.message || e), isError: true }; }
+      },
+    },
+    {
+      def: { name: "verify_object", description: "Re-derive a workspace file's content address and confirm it matches (Law L5 — verify every byte). Returns whether the bytes are authentic.", inputSchema: { type: "object", properties: { path: { type: "string" }, kappa: { type: "string" } }, required: ["path"] } },
+      serverName: "code", call: async ({ path, kappa }) => {
+        try {
+          const bytes = await readFile(path);
+          const got = "did:holo:sha256:" + await sha256Hex(bytes);
+          const ok = !kappa || got === kappa || got.startsWith(kappa) || kappa.startsWith(got.slice(0, kappa.length));
+          // verify = re-derive κ (Law L5) AND emit the W3C @type — apps are SoftwareApplication, all else DigitalDocument.
+          const ld = /\.html$/i.test(path) ? appAsSoftware({ name: norm(path), kappa: got, bytes: bytes.length })
+                                           : fileAsDocument({ path: norm(path), kappa: got, bytes: bytes.length });
+          return { text: `${norm(path)} re-derives to ${got.slice(0, 34)}…${kappa ? (ok ? " ✓ matches (authentic)" : " ✗ MISMATCH") : ""} · @type ${ld["@type"].join("+")}`, isError: false, render: { kind: "linked-data", ld } };
+        } catch (e) { return { text: "verify error: " + (e.message || e), isError: true }; }
+      },
+    },
+  ];
+}

core/engine.js

@@ -0,0 +1,189 @@
+// core/engine.js — the inference ENGINE adapter (the only module that touches the wasm
+// tokenizer + the WebGPU `gpu` object). DOM-free. Wraps a model that core/loader.js has
+// already loaded onto the GPU and exposes a clean, UI-agnostic API:
+//
+//   const engine = await createEngine(modelEntry, { gpu, info, imageKappa });
+//   const { text, outIds } = await engine.generate(ids, { onToken, signal });
+//   const rec = await engine.buildReceipt({ ... });   // PROV-O, re-derivable (Law L5)
+//
+// The token loop, framing, memo and receipt logic are lifted byte-for-byte from the
+// original index.html think()/run()/sealReceipt — only the DOM writes are replaced by an
+// onToken callback and the running/handedOff flags by an AbortSignal, so output (and the
+// receipt κ) is identical to the original app.
+
+import { qvac_tokenize, qvac_continue, kappa } from "../pkg/holospaces_web.js";
+import { clean, didHolo, kappaTokens, sealReceipt, verifyIntegrity, idBytes, kappaBytes } from "./kappa.js";
+
+const _perf = () => (typeof performance !== "undefined" ? performance.now() : 0);
+const _sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// The engine is itself a content-addressed object — hash the wasm once (lazy).
+let _engineK = null;
+export async function engineKappa() {
+  if (_engineK) return _engineK;
+  try { const b = new Uint8Array(await (await fetch(new URL("../pkg/holospaces_web_bg.wasm", import.meta.url))).arrayBuffer()); _engineK = await kappaBytes(b); }
+  catch { _engineK = "did:holo:sha256:(engine unavailable)"; }
+  return _engineK;
+}
+
+export async function createEngine(modelEntry, loaded) {
+  const { gpu, info, imageKappa } = loaded;
+  const m = modelEntry;
+  const engineReady = engineKappa();
+
+  // model κ: the κ-disk's VERIFIED image_kappa when present (a real content address of the
+  // weights, every sector re-derived); else the model's declared identity.
+  const modelKappa = imageKappa
+    ? "did:holo:sha256:" + String(imageKappa).replace(/^(did:holo:)?sha256:/, "")
+    : await didHolo({ "@type": "schema:SoftwareSourceCode", name: m.name, size: m.size, fmt: m.fmt || "", family: m.fam || "" });
+
+  const memo = new Map();
+  let _drafter = null;   // learned speculative drafter (fn(seq,max)=>ids); null → standard decode. Set via setDrafter().
+
+  const tokenize = (text) => { try { return JSON.parse(qvac_tokenize(text)).ids || []; } catch { return []; } };
+  const detokenize = (ids) => { try { return clean(JSON.parse(qvac_continue(JSON.stringify(ids), 0, 0, 0, ids.length)).text || ""); } catch { return ""; } };
+  const fingerprint = (ids) => kappa(idBytes(ids));   // live mind κ (blake3, from wasm)
+
+  // Frame one user turn. Qwen2/3 use ChatML (its <|im_*|> markers are atomic BPE tokens);
+  // other instruction models use a plain Q/A frame. (Verbatim from the original run().)
+  function frameTurn(prompt, hasHistory) {
+    if (m.qwen) {
+      const noThink = m.qwen3 ? "<think>\n\n</think>\n\n" : "";   // Qwen3: skip the thinking block for fast direct answers
+      return (hasHistory ? "<|im_end|>\n" : "") + `<|im_start|>user\n${prompt}<|im_end|>\n<|im_start|>assistant\n` + noThink;
+    }
+    if (m.llama3)                                                  // LLaMA-3 header template (BitNet b1.58 etc.)
+      return (hasHistory ? "<|eot_id|>" : "") + `<|start_header_id|>user<|end_header_id|>\n\n${prompt}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n`;
+    if (m.olmo)                                                    // OLMo/OLMoE: <|user|>/<|assistant|> role tags (each turn self-delimited; leading bos via m.bos)
+      return `<|user|>\n${prompt}\n<|assistant|>\n`;
+    if (m.userWord)                                                // word-frame (Falcon-E: its ChatML template stalls EMPIRICALLY; "User:/Falcon:" answers — see q-falcon-templates sweep)
+      return (hasHistory ? "\n" : "") + "User: " + prompt + "\nFalcon:";
+    return "Question: " + prompt + "\nAnswer:";
+  }
+
+  function params() {
+    const temp = m.temp || 0;
+    return { decode: temp > 0 ? "sampled@t=" + temp : "greedy-argmax", maxTokens: m.cap, repetitionPenalty: m.rep ?? 1.05, template: m.qwen ? "chatml" : m.llama3 ? "llama3" : "qa", thinking: !m.qwen3 };
+  }
+
+  // The streaming token loop. `ids` is the whole running conversation (the mind); generation
+  // appends to it. onToken({ text, ids, outIds, stats }) fires per step; signal aborts.
+  async function generate(ids, { onToken, signal, repPenalty, maxNew } = {}) {
+    const rep = repPenalty ?? m.rep ?? 1.3;
+    const newCap = maxNew ?? m.cap ?? 80;                       // max NEW tokens this call
+    const kvCap = (m.ctx || m.cap || 80) + 8;                   // the engine's KV allocation (loader kvOf)
+    const promptLen = ids.length;
+    const tStart = _perf();
+    let first = true, decodeStart = 0, decodeTok = 0, ttft = 0, tokps = 0, msExec = 0, err = null, outText = "";
+    if (promptLen >= kvCap - 1) err = new Error(`context full: ${promptLen} tokens ≥ ${kvCap} KV positions`);
+
+    // SPECULATIVE PATH (opt-in): when a learned drafter is registered and the engine has the batched-verify
+    // head, the drafter proposes and the target batch-verifies — output is BYTE-IDENTICAL to greedy decode
+    // (greedy verify), streamed via onCommit. Any incompatibility/throw falls straight through to the standard
+    // loop below, so default Q (no drafter) and unsupported models are completely unaffected.
+    if (!err && _drafter && gpu.specDecode && gpu.setDrafter) {
+      try {
+        gpu.setDrafter(_drafter);
+        const out = []; const t0 = _perf(); let ttft2 = 0, tokps2 = 0;
+        const seq = await gpu.specDecode(ids.slice(), newCap, rep, (tk) => {
+          if (signal && signal.aborted) return false;
+          out.push(tk);
+          if (!ttft2) ttft2 = _perf() - tStart;
+          const dt = _perf() - t0; if (dt > 0) tokps2 = out.length / (dt / 1000);
+          if (onToken) onToken({ text: detokenize(out), ids: ids.slice(0, promptLen).concat(out), outIds: out.slice(), stats: { ttft: ttft2, tokps: tokps2, msExec: gpu.timing ? gpu.timing.exec : 0, gpuBytes: gpu.gpuBytes, spec: gpu.specStats ? gpu.specStats() : null } });
+          return out.length < newCap;
+        });
+        const outIds = seq.slice(promptLen);
+        let text = detokenize(outIds);
+        if (m.stopText) { const ix = text.indexOf(m.stopText); if (ix >= 0) text = text.slice(0, ix); }
+        return { text, outIds, ids: seq, stats: { ttft: ttft2, tokps: tokps2, msExec: gpu.timing ? gpu.timing.exec : 0, spec: gpu.specStats ? gpu.specStats() : null }, error: null };
+      } catch (e) { try { gpu.setDrafter(null); } catch {} /* fall through to the standard decode loop */ }
+    }
+
+    while (!err && !(signal && signal.aborted) && ids.length - promptLen < newCap && ids.length < kvCap - 1) {
+      const prevLen = ids.length;
+      try { ids = await (gpu.decode || gpu.generate)(ids, first ? 1 : 6, rep); }   // batched GPU decode head (4 B/token readback) when the engine has it
+      catch (e) { err = e; break; }
+      const dn = ids.length - prevLen;
+      if (dn > 0) {
+        msExec = gpu.timing ? gpu.timing.exec : msExec;
+        if (first) { ttft = _perf() - tStart; decodeStart = _perf(); first = false; }   // TTFT = prefill + first token
+        else { decodeTok += dn; const dt = _perf() - decodeStart; if (dt > 0) tokps = decodeTok / (dt / 1000); }   // steady decode rate
+      }
+      const di = ids.slice(promptLen);
+      // incremental detokenize: decode only a bounded window (the dn new tokens + a small left context)
+      // and append the delta — O(1) per step, not re-detokenizing the whole growing output (was O(n²)).
+      { const a = Math.max(promptLen, ids.length - (dn + 8)); const wf = detokenize(ids.slice(a)); const wp = a >= ids.length - dn ? "" : detokenize(ids.slice(a, ids.length - dn)); outText += wf.slice(wp.length); }
+      let text = outText, hitStop = false;
+      if (m.stopText) { const ix = text.indexOf(m.stopText); if (ix >= 0) { text = text.slice(0, ix); hitStop = true; } }   // word-framed models stop on the next "User:" turn
+      if (onToken) onToken({ text, ids: ids.slice(), outIds: di.slice(), stats: { ttft, tokps, msExec, gpuBytes: gpu.gpuBytes } });
+      if (hitStop) break;
+      if (ids.length <= prevLen) break;    // EOS / no progress
+      // degeneration guard: a long run of one repeated character (the repetition collapse of
+      // small/experimental quants) will never recover — stop instead of burning the budget.
+      if (text.length > 80 && /(.)\1{63}$/.test(text)) { err = new Error("degenerate repetition — stopped"); break; }
+      await _sleep(0);   // yield to the event loop so the UI can paint — no artificial throttle (gpu.decode already awaits the GPU)
+    }
+    const outIds = ids.slice(promptLen);
+    let text = detokenize(outIds);
+    if (m.stopText) { const ix = text.indexOf(m.stopText); if (ix >= 0) text = text.slice(0, ix); }
+    return { text, outIds, ids, stats: { ttft, tokps, msExec }, error: err };
+  }
+
+  // DIFFUSION decode (Dream-class): iterative bidirectional unmasking over a fixed `steps` budget,
+  // wall-clock fixed by steps not output length. Greedy ⇒ deterministic ⇒ κ-re-derivable (Law L5).
+  // `ids` is the framed prompt; we diffuse `genLen` masked positions after it. Returns the same shape
+  // as generate() so callers (and the brain seam) are agnostic. onToken fires ONCE with the final fill
+  // (diffusion has no left-to-right token stream — the whole block resolves together).
+  // Two modes: APPEND (genLen masks at the suffix — generation) or FILL (ids ALREADY contain mask ids
+  // anywhere → infill/surgical edit, conditioning on BOTH sides; diffusion's structural edge over AR).
+  // `causal` flips the parity gate (causal block=1 must equal the sequential engine — validates the pass).
+  async function diffuse(ids, { genLen, steps, fill, causal, signal, onToken } = {}) {
+    if (!gpu || !gpu.diffuse) throw new Error("this model has no diffusion engine (load a diffusion κ-object)");
+    const gl = fill ? 0 : (genLen ?? Math.min(m.cap || 64, (m.ctx || 192) - ids.length - 1));
+    const S = steps ?? m.steps ?? 12;
+    const tStart = _perf();
+    const seq = await gpu.diffuse(ids, gl, { steps: S, fill: !!fill, causal: !!causal, signal });
+    // append → output is the generated suffix; fill → the whole sequence is the answer (a span edited in place)
+    const outIds = fill ? seq.slice() : seq.slice(ids.length);
+    let text = detokenize(outIds);
+    if (m.stopText && !fill) { const ix = text.indexOf(m.stopText); if (ix >= 0) text = text.slice(0, ix); }
+    const stats = { ttft: _perf() - tStart, tokps: 0, msExec: gpu.timing ? gpu.timing.exec : 0, steps: S, fill: !!fill, diff: gpu.diffStats ? gpu.diffStats() : null };
+    if (onToken) onToken({ text, ids: seq.slice(), outIds: outIds.slice(), stats });
+    return { text, outIds, ids: seq, stats, error: null };
+  }
+
+  // κ-memo: identical (context ⊕ prompt ⊕ model ⊕ params) → replay in O(1), no decode.
+  const memoKey = async (ctxIds, turnIds, p) => didHolo({ ctx: await kappaTokens(ctxIds.concat(turnIds)), model: modelKappa, params: p || params() });
+
+  async function buildReceipt({ promptText, ctxIds, turnIds, outIds, fromMemo, evaluateText, paramsPatch, extraUsed }) {
+    return sealReceipt({
+      promptText, ctxIds, turnIds, outIds, text: detokenize(outIds), params: { ...params(), ...(paramsPatch || {}) }, fromMemo,
+      modelKappa, engineKappa: await engineReady, evaluateText, extraUsed,
+    });
+  }
+
+  // Re-derivation (greedy only): re-run the exact inference and reproduce κ(output) byte-for-byte.
+  async function reDerive(rec) {
+    if (!gpu) return { ok: false, reason: "load the model to re-derive" };
+    if (/sampled/.test(rec.params.decode)) return { ok: false, reason: "sampled decode — only the κ-binding is verifiable, not re-derivation" };
+    try {
+      let seq = rec.ctxIds.concat(rec.turnIds); const start = seq.length;
+      gpu.reset();
+      seq = await (gpu.decode || gpu.generate)(seq, rec.outIds.length, rec.params.repetitionPenalty);   // same head as the live path — replay must match byte-for-byte
+      const got = await kappaTokens(seq.slice(start)), want = rec.body["prov:generated"]["holo:outputTokens"];
+      return { ok: got === want, got, want };
+    } finally { try { gpu.reset(); } catch {} }
+  }
+
+  return {
+    model: m, dims: gpu.dims, modelKappa, bosId: info?.bos ?? null, get gpuBytes() { return gpu.gpuBytes; },
+    tokenize, detokenize, fingerprint, frameTurn, params,
+    generate,
+    // register/clear the learned speculative drafter (fn(seq,max)=>ids). Off by default; safe fallback.
+    setDrafter: (fn) => { _drafter = fn || null; try { gpu.setDrafter && gpu.setDrafter(_drafter); } catch (e) {} },
+    specAvailable: !!(gpu.specDecode && gpu.setDrafter),
+    memoKey, memoGet: (k) => memo.get(k), memoHas: (k) => memo.has(k), memoSet: (k, v) => memo.set(k, v),
+    buildReceipt, verify: verifyIntegrity, reDerive,
+    stats: () => gpu.timing, reset: () => { try { gpu.reset(); } catch {} }, destroy: () => { try { gpu.destroy(); } catch {} },
+  };
+}

core/kappa.js

@@ -0,0 +1,76 @@
+// core/kappa.js — the PURE content-addressing + receipt layer (no wasm, no DOM).
+//
+// Lifted verbatim (behaviour-identical) from the original Holo Q index.html so that
+// BOTH the browser app and the pure-Node witness (tools/q-witness.mjs) import the same
+// re-derivation logic. Uses only Web Crypto (crypto.subtle), which exists in the browser
+// and in Node ≥ 20 as globalThis.crypto.subtle — so a receipt's κ re-derives identically
+// in either runtime (Law L5). The PROV-O receipt body and its did:holo are byte-for-byte
+// what the original sealed, so existing receipts keep verifying.
+
+const _enc = new TextEncoder();
+const _td = new TextDecoder();
+
+// RFC 8785 JCS — canonical JSON, so a receipt's κ re-derives identically anywhere.
+export const jcs = (v) => Array.isArray(v) ? "[" + v.map(jcs).join(",") + "]"
+  : (v && typeof v === "object") ? "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + jcs(v[k])).join(",") + "}"
+  : JSON.stringify(v);
+
+export async function sha256hex(u8) {
+  const d = await crypto.subtle.digest("SHA-256", u8);
+  return Array.from(new Uint8Array(d), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export const idBytes = (ids) => new Uint8Array(new Uint32Array(ids).buffer);
+
+export const didHolo     = async (obj) => "did:holo:sha256:" + await sha256hex(_enc.encode(jcs(obj)));
+export const kappaText   = async (s)   => "did:holo:sha256:" + await sha256hex(_enc.encode(s || ""));
+export const kappaTokens = async (a)   => "did:holo:sha256:" + await sha256hex(idBytes(a));   // the answer's tokens, by content
+export const kappaBytes  = async (u8)  => "did:holo:sha256:" + await sha256hex(u8);
+
+export const shortK = (k) => {
+  const s = String(k || ""); const ax = s.split(":").slice(0, 2).join(":"); const h = s.split(":").pop();
+  return ax + ":" + (h.length > 18 ? h.slice(0, 12) + "…" + h.slice(-4) : h);
+};
+
+// SentencePiece byte-fallback tokens (<0xNN>) → their actual bytes, UTF-8 decoded.
+export const decodeBytes = (t) => t.replace(/(?:<0x[0-9A-Fa-f]{2}>)+/g, (run) => {
+  const b = []; run.replace(/<0x([0-9A-Fa-f]{2})>/g, (_, h) => (b.push(parseInt(h, 16)), ""));
+  try { return _td.decode(new Uint8Array(b)); } catch { return ""; }
+});
+export const clean = (t) => decodeBytes(
+  t.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/<\/?think>/g, "").replace(/<\|[^>]*\|>/g, "").replace(/<unk>|<s>|<\/s>/g, "")
+).replace(/^\s+/, "");
+
+// ── verifiable-inference receipt ────────────────────────────────────────────────
+// An answer is a content-addressed, re-derivable transform on the substrate:
+//   κ(context) ⊕ κ(prompt) ⊕ κ(model) ⊕ κ(params) ⊕ κ(engine) → κ(output)
+// sealed as a PROV-O receipt with its OWN did:holo. Greedy decode is deterministic,
+// so anyone re-runs it and reproduces κ(output) byte for byte (Law L5).
+
+// Build the canonical PROV-O receipt body. All κ inputs are already did:holo strings.
+// `extraUsed` merges additional provenance (e.g. holo:toolReceipts — the agentic work-trail).
+export function receiptBody({ modelKappa, engineKappa, promptKappa, contextKappa, outputKappa, tokenCount, params, conscience, extraUsed }) {
+  return {
+    "@context": ["http://www.w3.org/ns/prov#", { holo: "https://hologram.os/ns/q#" }],
+    "@type": "prov:Activity", "holo:kind": "verifiable-inference",
+    "prov:used": { "holo:model": modelKappa, "holo:engine": engineKappa, "holo:prompt": promptKappa, "holo:context": contextKappa, "holo:params": params, ...(extraUsed || {}) },
+    "prov:generated": { "holo:outputTokens": outputKappa, "holo:tokenCount": tokenCount },
+    "holo:conscience": conscience || { outcome: "unverified" },
+  };
+}
+
+// Seal a receipt: compute the κ inputs from raw tokens/text, assemble the body, address it.
+// `text` is the already-decoded answer; `evaluateText` (optional) is the conscience judge.
+export async function sealReceipt({ promptText, ctxIds, turnIds, outIds, text, params, fromMemo, modelKappa, engineKappa, evaluateText, extraUsed }) {
+  const [promptKappa, contextKappa, outputKappa] = await Promise.all([
+    kappaText(promptText), kappaTokens(ctxIds.concat(turnIds)), kappaTokens(outIds),
+  ]);
+  let conscience = { outcome: "unverified" };
+  try { if (evaluateText) { const v = evaluateText(text); conscience = { outcome: v.outcome, blocked: v.blocked || [], caveats: v.caveats || [], sealed: v.sealed !== false }; } } catch {}
+  const body = receiptBody({ modelKappa, engineKappa, promptKappa, contextKappa, outputKappa, tokenCount: outIds.length, params, conscience, extraUsed });
+  const id = await didHolo(body);
+  return { id, body, text, promptText, ctxIds: ctxIds.slice(), turnIds: turnIds.slice(), outIds: outIds.slice(), params, fromMemo: !!fromMemo };
+}
+
+// Integrity: recompute the receipt's did:holo from its body — tamper any byte and it won't match.
+export const verifyIntegrity = async (rec) => { const again = await didHolo(rec.body); return { ok: again === rec.id, again }; };

core/keymap.js

@@ -0,0 +1,29 @@
+// core/keymap.js — the keyboard map as a data table (LibreChat's native set): Alt+N new chat,
+// Alt+S toggle sidebar, Alt+W focus the input, Ctrl/⌘+Enter send, Esc stop generation,
+// Ctrl/⌘+K model menu. `/` and `@` composer menus live in ui/composer.js (they are caret-local).
+
+export const BINDINGS = [
+  { combo: "Alt+N", action: "newChat", label: "New chat" },
+  { combo: "Alt+S", action: "toggleNav", label: "Toggle sidebar" },
+  { combo: "Alt+W", action: "focusInput", label: "Focus message box" },
+  { combo: "Ctrl+Enter", action: "send", label: "Send message" },
+  { combo: "Escape", action: "stop", label: "Stop generating" },
+  { combo: "Ctrl+K", action: "modelMenu", label: "Choose model" },
+];
+
+export function installKeymap(handlers) {
+  const onKey = (e) => {
+    const ctrl = e.ctrlKey || e.metaKey;
+    const fire = (name) => { const fn = handlers[name]; if (fn) { e.preventDefault(); fn(e); } };
+    if (e.altKey && !ctrl && !e.shiftKey) {
+      if (e.code === "KeyN") return fire("newChat");
+      if (e.code === "KeyS") return fire("toggleNav");
+      if (e.code === "KeyW") return fire("focusInput");
+    }
+    if (ctrl && e.key === "Enter") return fire("send");
+    if (ctrl && !e.shiftKey && e.code === "KeyK") return fire("modelMenu");
+    if (e.key === "Escape") { const fn = handlers.stop; if (fn) fn(e); }   // don't preventDefault — Esc also closes menus
+  };
+  document.addEventListener("keydown", onKey);
+  return () => document.removeEventListener("keydown", onKey);
+}

core/loader.js

@@ -0,0 +1,204 @@
+// core/loader.js — model LOADING (the 5 substrate paths) + the model catalog + the
+// browser-cache manager. Lifted faithfully from the original index.html so a model still
+// loads byte-identically; the only change is that DOM status writes become onStatus/onProgress
+// callbacks, and each path RETURNS { gpu, info, manifest, imageKappa } instead of mutating
+// globals. core/engine.js then wraps the returned gpu. (window.__gpu / window.__kd handles are
+// still exposed for the probe + system-monitor panels.)
+
+import init, { kappa, qvac_load_model, qvac_load_gpu, qvac_tokenize, qvac_continue, qvac_gpu_manifest, qvac_gpu_tensor, qvac_gpu_free, qvac_panic_hook } from "../pkg/holospaces_web.js";
+import { createQvacGPU } from "../qvac-gpu.js?v=60";
+import { modelAsSource } from "./semantic.js";   // C2: a loaded model carries a W3C @type (schema:SoftwareSourceCode)
+
+// the model κ-object's W3C linked-data view — content-addressed identity (Law L1) + schema.org type.
+const modelLinkedData = (m, root) => modelAsSource({
+  name: m.name, family: m.fam, params: m.size, format: m.fmt,
+  kappa: root ? (String(root).startsWith("did:") ? root : "did:holo:" + String(root)) : "did:holo:sha256:0",
+});
+
+// The compiled κ-objects present on disk (models/<name>, built by compile2bit.mjs). Each loads
+// DIRECT off the substrate (verified by re-derivation, no re-quant) via its `kappaUrl`.
+// cap = max NEW tokens per turn; ctx = KV-cache positions allocated on the GPU (the context
+// window — sized so agentic turns with tool schemas + tool responses fit; KV VRAM scales with it).
+export const MODELS = [
+  // NATIVELY-TERNARY κ-objects (t2, 1.58 bpw trained-in — see the atlas-bridge witness receipts):
+  // Falcon-E: its declared ChatML template STALLS empirically (instant <|end_of_text|>); the
+  // measured working frame is word-style "User:/Falcon:" with a textual stop (q-falcon-templates sweep).
+  { fam: "Falcon-E", name: "Falcon-E-3B · ternary", kappaUrl: "https://huggingface.co/HOLOGRAMTECH/q-falcon-e-3b/resolve/main", manifestKappa: "did:holo:sha256:6b753fe8186f2b4194424115c36014698580a2aab8427e9b40365893ac6b77ca", size: "0.63 GB", fmt: "t2 1.58-bit κ", cap: 200, ctx: 3000, kv4: true, gpu: true, gpuOnly: true, chat: true, userWord: true, stopText: "\nUser:", tools: false, rep: 1.18, kappa: true },
+  { fam: "BitNet", name: "BitNet-2B-4T · ternary", kappaUrl: "https://huggingface.co/HOLOGRAMTECH/q-bitnet-2b/resolve/main", manifestKappa: "did:holo:sha256:fcf835659d88d2fe6f683cf1ab8de6a6ba6214ea0deeee4b1bcf3da1a4c05412", size: "0.69 GB", fmt: "t2 1.58-bit κ", cap: 900, ctx: 3000, kv4: true, gpu: true, gpuOnly: true, chat: true, llama3: true, tools: false, bos: true, eosText: "<|eot_id|>", rep: 1.05, kappa: true },
+  // TriLM: the LARGEST natively-ternary-trained model (Spectra 3.9B, ICLR'25); per-row/channel
+  // scale structure → t2r (trit codes + per-256-block scales, exact). BASE model → QA frame + stop.
+  { fam: "TriLM", name: "TriLM-3.9B · ternary", kappaUrl: "https://huggingface.co/HOLOGRAMTECH/q-trilm-3.9b/resolve/main", manifestKappa: "did:holo:sha256:499032ceb19c0476345a72cf5fea6caec83054c98486c91a5891dfad0d25ea30", size: "0.87 GB", fmt: "t2r 2.1-bit κ", cap: 200, ctx: 3000, kv4: true, gpu: true, gpuOnly: true, chat: true, stopText: "\nQuestion:", tools: false, rep: 1.18, kappa: true },
+  // AGENTIC CODER: Qwen2.5-Coder-7B (q3f) — the Holo Code agent brain. Qwen2.5 arch ⇒ ChatML +
+  // agentic tool framing work (capability floor for tool use is ~7B; the small ternary models opt out).
+  // Self-contained κ-object: tokenizer bundled (source="tokenizer.gguf"), no external dependency.
+  { fam: "Qwen2.5-Coder", name: "Qwen2.5-Coder-7B · agentic", kappaUrl: "https://huggingface.co/HOLOGRAMTECH/q-qwen-coder-7b/resolve/main", manifestKappa: "did:holo:sha256:539941cb060c7dd583e2e86697e53f2c5d511d597c65d09d9c780fbded2c3edf", size: "3.4 GB", fmt: "q3f κ", cap: 900, ctx: 3000, kv4: true, gpu: true, gpuOnly: true, chat: true, code: true, qwen: true, rep: 1.05, kappa: true },
+  // MIXTURE-OF-EXPERTS (G5): OLMoE-1B-7B (Allen AI, Apache-2.0) — 64 experts, 8 active/token, ~1.3B
+  // active of 7B. The first RESIDENT-MoE κ-object: experts RAM-resident + CPU top-k router (softmax
+  // over all 64, no renorm = OLMoE norm_topk_prob:false). q4 (the engine's resident expert FFN path).
+  { fam: "OLMoE", name: "OLMoE-1B-7B · MoE (64×8)", kappaUrl: "https://huggingface.co/HOLOGRAMTECH/q-olmoe-1b-7b/resolve/main", manifestKappa: "did:holo:sha256:9cf97ec1c761fd4ef51bc0cd4ac37a0cd8eaa11f1b19b3ae6a141486ad3fe5ad", size: "3.6 GB", fmt: "q4 MoE κ", cap: 400, ctx: 3000, kv4: false, gpu: true, gpuOnly: true, chat: true, olmo: true, bos: true, eosText: "<|endoftext|>", tools: false, rep: 1.1, kappa: true },
+  // DIFFUSION (G6): Dream-7B (Dream-org/Dream-v0-Instruct-7B) — masked-diffusion LM on the Qwen2.5-7B
+  // backbone (same dims ⇒ ChatML). NOT autoregressive: generation is iterative bidirectional unmasking
+  // over `steps` denoising passes (engine.diffuse / gpu.diffuse), wall-clock fixed by steps not length.
+  // maskId 151666 rides in the manifest (never tokenized from text). Greedy ⇒ deterministic ⇒ κ-re-derivable.
+  { fam: "Dream", name: "Dream-7B · diffusion", kappaUrl: "https://huggingface.co/HOLOGRAMTECH/q-dream-7b/resolve/main", manifestKappa: "did:holo:sha256:7b862931ae088f348f1f7e9ea3adbd418924c2e07e6ddd134f926e5681ad760d", size: "2.9 GB", fmt: "q3f diffusion κ", cap: 192, ctx: 192, kv4: false, gpu: true, gpuOnly: true, chat: true, qwen: true, diffusion: true, steps: 12, rep: 1.0, kappa: true },
+  // Qwen κ-objects (q3f/q4) were pruned from disk for space — re-derive via compile2bit, then re-list.
+];
+const kvOf = (m) => Math.max(96, (m.ctx || m.cap) + 8);
+
+const _sizeGb = (s) => { const n = parseFloat(s) || 0; return /mb/i.test(s) ? n / 1024 : n; };
+// default to the SMALLEST usable model — lowest latency, fastest first answer.
+export const defaultModelIndex = () => (MODELS.map((m, i) => i).filter((i) => !MODELS[i].disabled).sort((a, b) => _sizeGb(MODELS[a].size) - _sizeGb(MODELS[b].size))[0]) ?? 0;
+
+// ── wasm init (once) + tokenizer re-export so the rest of the app shares this instance ──
+let _initOnce = null;
+export function ready() { if (!_initOnce) _initOnce = init().then(() => { try { qvac_panic_hook(); } catch {} }); return _initOnce; }
+export { qvac_tokenize, qvac_continue, kappa };
+
+// ── browser-cache model manager (Cache API) — "Get" downloads + keeps; loading uses the copy ──
+export const MCACHE = "holo-q-models";
+const absUrl = (u) => new URL(u, location.href).href;
+let _cachedUrls = new Set();
+export async function refreshCached() { try { const c = await caches.open(MCACHE); _cachedUrls = new Set((await c.keys()).map((r) => r.url)); } catch { _cachedUrls = new Set(); } return _cachedUrls; }
+export const isCached = (m) => !!m.url && _cachedUrls.has(absUrl(m.url));
+export async function deleteCache(m) { try { const c = await caches.open(MCACHE); await c.delete(m.url); } catch {} await refreshCached(); }
+async function modelBytes(m, onStatus) {
+  try { const c = await caches.open(MCACHE); const hit = await c.match(m.url); if (hit) return new Uint8Array(await hit.arrayBuffer()); } catch {}
+  onStatus?.(`Downloading ${m.name} (${m.size})…`);
+  const res = await fetch(m.url); if (!res.ok) { onStatus?.("download failed: HTTP " + res.status); return null; }
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+const noop = () => {};
+
+// loadModel(entry, { onStatus, onProgress }) → { gpu, info, manifest, imageKappa } | null
+// `imageKappa` is the VERIFIED content address of the weights when the path provides one
+// (κ-object root, or κ-disk image_kappa); core/engine.js binds it as the receipt's model κ.
+export async function loadModel(m, { onStatus = noop, onProgress = noop } = {}) {
+  await ready();
+  onStatus(`Loading ${m.name}…`);
+  try {
+    if (m.gpuOnly && !navigator.gpu) { onStatus("This model needs WebGPU (not available here)."); return null; }
+    if (m.kappaUrl)   return await loadKappa(m, onStatus, onProgress);
+    if (m.kdisk)      return await loadModelKDisk(m, onStatus, onProgress);
+    if (m.remote)     return await loadModelRemote(m, onStatus, onProgress);
+    if (m.diskIngest) return await loadModelDisk(m, onStatus, onProgress);
+    let gguf = await modelBytes(m, onStatus); if (!gguf) { onStatus("could not load model"); return null; }
+    const lr = JSON.parse(m.gpuOnly ? qvac_load_gpu(gguf) : qvac_load_model(gguf));
+    gguf = null;
+    if (lr.error) { onStatus("model error: " + lr.error); return null; }
+    let gpu = null, manifest = null;
+    if (navigator.gpu && m.gpu) {
+      try {
+        onStatus(`Uploading ${m.name} to the GPU…`);
+        const bits = m.q4 ? 4 : 8;
+        manifest = JSON.parse(qvac_gpu_manifest(bits)); manifest.twoBit = !!window.__twoBit;
+        const __qp = new URLSearchParams(location.search).get("stream");
+        const __qmode = __qp === null ? undefined : (__qp === "resident" || __qp === "false" ? false : __qp);
+        const stream = __qmode ?? window.__stream ?? m.stream ?? false;
+        const __ft = (name) => { const raw = qvac_gpu_tensor(name, bits); return window.__weightHook ? window.__weightHook(name, raw, bits, manifest) : raw; };
+        gpu = await createQvacGPU(manifest, __ft, kvOf(m), lr.eos ?? 2, stream);
+        window.__gpu = gpu; qvac_gpu_free();
+      } catch (e) { gpu = null; if (m.gpuOnly) { onStatus("GPU upload failed: " + e); return null; } }
+    }
+    onStatus("");
+    return { gpu, info: lr, manifest, imageKappa: null };
+  } catch (e) { onStatus("could not load model: " + e); return null; }
+}
+
+// LOAD-DIRECT: a pre-compiled 2-bit/Q4 κ-object (compile2bit.mjs output). Weights arrive ALREADY
+// quantized (no re-quant at load); the tokenizer comes from the source GGUF's header only.
+async function loadKappa(m, onStatus, onProgress) {
+  onStatus("Loading κ-object manifest…");
+  const ld = await import("../holo-load2bit.mjs");
+  // Law L5: pin the manifest κ when the catalog supplies one (m.manifestKappa, or a string m.kappa).
+  // Until every model carries a pin, unpinned entries load explicitly (allowUnpinned) — the gap is then
+  // a visible data task (populate manifestKappa), not a silent trust of an unauthenticated root.
+  const pin = (typeof m.manifestKappa === "string" && m.manifestKappa) || (typeof m.kappa === "string" && m.kappa) || null;
+  const { manifest, fetchTensor, info } = await ld.loadKappaObject(m.kappaUrl.replace(/\/+$/, ""), pin ? { expectKappa: pin } : { allowUnpinned: true });
+  const ing = await import("../qvac-ingest.mjs");
+  onStatus("Building tokenizer (source header, no full download)…");
+  const hdr = await ing.readHeader(info.source, ing.rangeReader());
+  const lr = JSON.parse(qvac_load_gpu(hdr.headerBytes));
+  if (lr.error) { onStatus("tokenizer error: " + lr.error); return null; }
+  if (m.eosText) { try { const e = JSON.parse(qvac_tokenize(m.eosText)).ids; if (e && e.length === 1) lr.eos = e[0]; } catch {} }   // chat-stop override (e.g. LLaMA-3 <|eot_id|> ≠ header eos)
+  qvac_gpu_free();
+  manifest.kv4 = !!m.kv4;                                  // int4 KV cache (E6) — catalog opt-in
+  // MoE forward reads the layer-packed attention (Wb[l]) + RAM-resident experts (readExpert via
+  // fetchTensor) — i.e. stream="layer": attention JS-resident & paged per token, experts cached.
+  const sm = manifest.moe ? "layer" : (m.stream || window.__kappaStream || false);
+  onStatus(`Building engine from κ-object (${info.mode === "q4" ? "native Q4" : info.incoherent ? "incoherent 2-bit" : "LDLQ 2-bit"}, ${sm || "resident"}, no requant)…`);
+  const prog = (done, total) => onProgress(done, total, "streaming");
+  const gpu = await createQvacGPU(manifest, fetchTensor, kvOf(m), lr.eos ?? 2, sm, sm ? prog : null);
+  window.__gpu = gpu;
+  onStatus("");
+  return { gpu, info: lr, manifest, imageKappa: info.root || null, ld: modelLinkedData(m, info.root) };
+}
+
+// Very-large-model path: the GGUF never enters wasm; only the header does (tokenizer + manifest),
+// then each tensor is streamed off disk (HTTP Range), converted in JS, paged to the GPU per layer.
+async function loadModelDisk(m, onStatus, onProgress) {
+  const bits = m.q4 ? 4 : 8;
+  const ing = await import("../qvac-ingest.mjs");
+  let read = ing.rangeReader();
+  try { const cachedResp = await (await caches.open(MCACHE)).match(m.url); if (cachedResp) { const blob = await cachedResp.blob(); read = async (_u, start, len) => new Uint8Array(await blob.slice(start, start + len).arrayBuffer()); } } catch {}
+  onStatus(`Reading ${m.name} header…`);
+  const hdr = await ing.readHeader(m.url, read);
+  const lr = JSON.parse(qvac_load_gpu(hdr.headerBytes));
+  if (lr.error) { onStatus("model error: " + lr.error); return null; }
+  const manifest = JSON.parse(qvac_gpu_manifest(bits));
+  qvac_gpu_free();
+  const fetchTensor = ing.makeDiskFetcher({ url: m.url, readRange: read, dataOffset: hdr.dataOffset, tensors: hdr.tensors, manifest, bits });
+  const mode = m.stream || "layer";
+  onStatus(`Preparing ${m.name} (one-time, streamed off disk)…`);
+  const gpu = await createQvacGPU(manifest, fetchTensor, kvOf(m), lr.eos ?? 2, mode, (d, t) => onProgress(d, t, "layers"));
+  window.__gpu = gpu; onStatus("");
+  return { gpu, info: lr, manifest, imageKappa: null };
+}
+
+// Out-of-core: stream a PRE-BUILT .qvf frames file from the server, one layer per token via HTTP Range.
+async function loadModelRemote(m, onStatus, onProgress) {
+  onStatus(`Loading ${m.name} index…`);
+  const index = await (await fetch(m.framesUrl + ".json")).json();
+  const url = m.framesUrl;
+  const rr = async (off, len) => { const r = await fetch(url, { headers: { Range: `bytes=${off}-${off + len - 1}` } }); if (!r.ok && r.status !== 206) throw new Error("HTTP " + r.status); return new Uint8Array(await r.arrayBuffer()); };
+  const header = await rr(index.headerOff, index.headerLen);
+  const lr = JSON.parse(qvac_load_gpu(header));
+  if (lr.error) { onStatus("model error: " + lr.error); return null; }
+  const manifest = index.manifest; qvac_gpu_free();
+  const fetchTensor = async (name) => { const s = index.singles[name]; return s ? await rr(s.off, s.len) : new Uint8Array(0); };
+  const frameStore = { ready: true, read: (off, len) => rr(index.layersOff + off, len), readExpert: (l, e, role) => { const ri = { gate: 0, up: 1, down: 2 }[role]; const off = index.expertsOff + ((l * index.nExperts + e) * 3 + ri) * index.expertBytes; return rr(off, index.expertBytes); } };
+  const layersBytes = (index.packStride || 0) * (index.n_layers || 0) + (manifest.moe ? (index.nExperts * 3 * index.expertBytes * index.n_layers) : 0);
+  const cacheBudget = window.__cacheGB != null ? window.__cacheGB * 1073741824 : Math.min(layersBytes, 12 * 1073741824);
+  onStatus(`Preparing ${m.name} (served off disk)…`);
+  const gpu = await createQvacGPU(manifest, fetchTensor, kvOf(m), lr.eos ?? 2, "remote", (d, t) => onProgress(d, t, "remote"), frameStore, cacheBudget);
+  window.__gpu = gpu; onStatus("");
+  return { gpu, info: lr, manifest, imageKappa: null };
+}
+
+// HOLOGRAM: load through a content-addressed κ-DISK — every sector VERIFIED by re-derivation (Law L3/L5).
+async function loadModelKDisk(m, onStatus, onProgress) {
+  onStatus(`Resolving ${m.name} κ-disk…`);
+  const index = await (await fetch(m.kdiskUrl)).json();
+  const { makeKDisk } = await import("../qvac-kdisk.mjs");
+  const bases = window.__kdiskSources || m.kdiskSources || [location.origin];
+  const sources = bases.map((b) => b.replace(/\/$/, "") + "/" + (index.dataFile || (m.dataUrl || "").replace(/^\.\//, "")));
+  const kd = makeKDisk({ index, sources });
+  window.__kd = kd;
+  const iv = await kd.verifyImage();
+  if (!iv.ok) { onStatus("κ-disk image_kappa mismatch — refusing to load"); return null; }
+  const rr = kd.rr, qvf = index.qvf;
+  const header = await rr(qvf.headerOff, qvf.headerLen);
+  const lr = JSON.parse(qvac_load_gpu(header));
+  if (lr.error) { onStatus("model error: " + lr.error); return null; }
+  const manifest = qvf.manifest; qvac_gpu_free();
+  const fetchTensor = async (name) => { const s = qvf.singles[name]; return s ? await rr(s.off, s.len) : new Uint8Array(0); };
+  const frameStore = { ready: true, read: (off, len) => rr(qvf.layersOff + off, len),
+    readExpert: async (l, e, role) => { const ri = { gate: 0, up: 1, down: 2 }[role]; const blkOff = qvf.expertsOff + (l * qvf.nExperts + e) * 3 * qvf.expertBytes; const blk = await rr(blkOff, 3 * qvf.expertBytes); return blk.slice(ri * qvf.expertBytes, (ri + 1) * qvf.expertBytes); } };
+  const layersBytes = (qvf.packStride || 0) * (qvf.n_layers || 0) + (manifest.moe ? (qvf.nExperts * 3 * qvf.expertBytes * qvf.n_layers) : 0);
+  const cacheBudget = window.__cacheGB != null ? window.__cacheGB * 1073741824 : Math.min(layersBytes, 1024 * 1048576);
+  onStatus(`Realizing ${m.name} (verified off κ-disk)…`);
+  const gpu = await createQvacGPU(manifest, fetchTensor, kvOf(m), lr.eos ?? 2, "remote", (d, t) => onProgress(d, t, "κ-disk"), frameStore, cacheBudget);
+  window.__gpu = gpu;
+  const st = kd.stats(); onStatus(`${index.imageKappa.slice(0, 22)}…  · ${st.verified} sectors verified`);
+  return { gpu, info: lr, manifest, imageKappa: kd.imageKappa || index.imageKappa || null };
+}

core/mcp.js

@@ -0,0 +1,144 @@
+// core/mcp.js — a lean, browser-native Model Context Protocol CLIENT. Speaks the open MCP
+// spec (JSON-RPC 2.0) over the Streamable HTTP transport (single endpoint, POST per message,
+// optional SSE response bodies, Mcp-Session-Id header) with a fallback for plain HTTP+SSE
+// servers. No SDK, no build step — the protocol is small and this is all of it that a chat
+// client needs: initialize → tools/list → tools/call.
+//
+// Substrate twist: every connected server and every tool call is content-addressable — the
+// caller can seal a PROV-O receipt around call inputs/outputs (see core/tools.js), so tool
+// use gets the same verifiability as inference (Law L5).
+
+const PROTOCOL_VERSION = "2025-03-26";
+const CLIENT_INFO = { name: "holo-q", version: "2.0.0" };
+
+let _seq = 0;
+const nextId = () => ++_seq;
+
+// Parse an SSE stream body and resolve with the JSON-RPC response matching `id`.
+async function readSse(res, id) {
+  const reader = res.body.getReader(); const dec = new TextDecoder();
+  let buf = "", result = null;
+  for (;;) {
+    const { done, value } = await reader.read(); if (done) break;
+    buf += dec.decode(value, { stream: true });
+    let i;
+    while ((i = buf.indexOf("\n\n")) >= 0) {
+      const frame = buf.slice(0, i); buf = buf.slice(i + 2);
+      const data = frame.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("");
+      if (!data) continue;
+      try { const msg = JSON.parse(data); if (msg.id === id) { result = msg; reader.cancel().catch(() => {}); return result; } } catch {}
+    }
+  }
+  return result;
+}
+
+export function makeMcpClient({ url, headers = {}, name = "", timeoutMs = 30000 } = {}) {
+  let sessionId = null, initialized = null, serverInfo = null, toolCache = null;
+
+  async function rpc(method, params, { notification = false } = {}) {
+    const body = notification
+      ? { jsonrpc: "2.0", method, ...(params ? { params } : {}) }
+      : { jsonrpc: "2.0", id: nextId(), method, ...(params ? { params } : {}) };
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+      const res = await fetch(url, {
+        method: "POST", signal: ctrl.signal,
+        headers: { "content-type": "application/json", accept: "application/json, text/event-stream", ...(sessionId ? { "mcp-session-id": sessionId } : {}), ...headers },
+        body: JSON.stringify(body),
+      });
+      const sid = res.headers.get("mcp-session-id"); if (sid) sessionId = sid;
+      if (notification) return null;
+      if (res.status === 202) return null;
+      if (!res.ok) throw new Error(`MCP ${res.status} ${res.statusText}`);
+      const ctype = res.headers.get("content-type") || "";
+      const msg = ctype.includes("text/event-stream") ? await readSse(res, body.id) : await res.json();
+      if (!msg) throw new Error("MCP: no response for request " + body.id);
+      if (msg.error) throw new Error(`MCP ${method}: ${msg.error.message || JSON.stringify(msg.error)}`);
+      return msg.result;
+    } finally { clearTimeout(t); }
+  }
+
+  async function initialize() {
+    if (initialized) return initialized;
+    initialized = (async () => {
+      const r = await rpc("initialize", { protocolVersion: PROTOCOL_VERSION, capabilities: {}, clientInfo: CLIENT_INFO });
+      serverInfo = r && r.serverInfo || { name: name || url };
+      await rpc("notifications/initialized", undefined, { notification: true }).catch(() => {});
+      return r;
+    })();
+    return initialized;
+  }
+
+  // tools/list (cached; paginated per spec)
+  async function listTools(force = false) {
+    if (toolCache && !force) return toolCache;
+    await initialize();
+    const out = []; let cursor;
+    do {
+      const r = await rpc("tools/list", cursor ? { cursor } : {});
+      out.push(...(r.tools || [])); cursor = r.nextCursor;
+    } while (cursor);
+    toolCache = out;
+    return out;
+  }
+
+  // tools/call → { content: [{type:"text",text}|{type:"image",...}], isError }
+  async function callTool(toolName, args) {
+    await initialize();
+    const r = await rpc("tools/call", { name: toolName, arguments: args || {} });
+    return r;
+  }
+
+  return {
+    url, name: () => (serverInfo && serverInfo.name) || name || url,
+    initialize, listTools, callTool,
+    get serverInfo() { return serverInfo; },
+  };
+}
+
+// Flatten a tools/call result's content into plain text for the model's <tool_response>.
+export function contentToText(result) {
+  if (!result) return "";
+  if (result.isError) return "ERROR: " + (result.content || []).map((c) => c.text || "").join("\n");
+  return (result.content || []).map((c) => c.type === "text" ? c.text : c.type === "image" ? "[image]" : c.type === "resource" ? JSON.stringify(c.resource).slice(0, 2000) : "").join("\n");
+}
+
+// ── DISCOVERY — the MCP universe, three rings out from the substrate ─────────────────────
+//  1. the SUBSTRATE's own roster (/.well-known/mcp.json — same-origin, verifiable)
+//  2. user-added servers (κ-pinned config in the boot index)
+//  3. the OFFICIAL public MCP registry (registry.modelcontextprotocol.io — the open index
+//     of the ecosystem; remote/streamable-http entries are directly connectable from a tab)
+export async function discoverSubstrate() {
+  try {
+    const r = await fetch("/.well-known/mcp.json"); if (!r.ok) return [];
+    const j = await r.json();
+    const servers = j.servers || j.mcpServers || (Array.isArray(j) ? j : [j]);
+    return (Array.isArray(servers) ? servers : Object.entries(servers).map(([k, v]) => ({ name: k, ...v })))
+      .map((s) => ({ source: "substrate", name: s.name || "hologram", url: s.url || s.endpoint || null, description: s.description || "", tools: s.tools || null, raw: s }))
+      .filter((s) => s.url || s.tools);
+  } catch { return []; }
+}
+
+export async function searchRegistry(query, { limit = 20 } = {}) {
+  // The official registry's public REST API (v0). Remote servers carry `remotes[]` with
+  // streamable-http/sse URLs — those are connectable straight from the browser.
+  const base = "https://registry.modelcontextprotocol.io/v0/servers";
+  const u = base + "?limit=" + limit + (query ? "&search=" + encodeURIComponent(query) : "");
+  const r = await fetch(u, { headers: { accept: "application/json" } });
+  if (!r.ok) throw new Error("registry " + r.status);
+  const j = await r.json();
+  return (j.servers || []).map((s) => {
+    const remote = (s.remotes || []).find((x) => /streamable|http/.test(x.type || "")) || (s.remotes || [])[0] || null;
+    return { source: "registry", name: s.name, description: s.description || "", version: s.version,
+      url: remote ? remote.url : null, transport: remote ? remote.type : (s.packages?.length ? "package (host-run)" : "unknown"), raw: s };
+  });
+}
+
+export async function discoverAgents() {
+  // The substrate's agent doors: NANDA AgentFacts + A2A AgentCards + Skills — one entry point.
+  try {
+    const r = await fetch("/.well-known/agents.json"); if (!r.ok) return null;
+    return await r.json();
+  } catch { return null; }
+}

core/mcphub.js

@@ -0,0 +1,107 @@
+// core/mcphub.js — the MCP connection HUB: manages servers (substrate roster · user-added ·
+// registry finds), their lifecycles and tool lists, and exposes the flat enabled-tool set the
+// generation loop consumes. Server configs persist in the boot index (substrate-local).
+//
+// Discovery rings: (1) the substrate's own /.well-known/mcp.json (the OS's 30 verified tools),
+// (2) servers the user added by URL, (3) the official public MCP registry. One hub, the
+// whole universe reachable from a tab.
+
+import { makeMcpClient, contentToText, discoverSubstrate, searchRegistry, discoverAgents } from "./mcp.js";
+
+export function makeMcpHub({ chatStore, bus }) {
+  const servers = new Map();   // id → { id, name, url, headers, enabled, client, tools, status, error }
+  let loaded = false;
+
+  const INDEX_KEY = "index:org.hologram.HoloQ";
+  async function persist() {
+    const idx = await chatStore.getIndex();
+    idx.mcpServers = [...servers.values()].map((s) => ({ id: s.id, name: s.name, url: s.url, headers: s.headers || {}, enabled: !!s.enabled, source: s.source || "user" }));
+    const b = new TextEncoder().encode(JSON.stringify(idx));
+    await (chatStore.store.backend.putRaw ? chatStore.store.backend.putRaw(INDEX_KEY, b) : chatStore.store.backend.put(INDEX_KEY, b));
+  }
+
+  async function restore() {
+    if (loaded) return; loaded = true;
+    const idx = await chatStore.getIndex();
+    for (const s of idx.mcpServers || []) if (!servers.has(s.id)) servers.set(s.id, { ...s, client: null, tools: [], status: "saved" });   // never clobber a live entry
+    bus.emit("mcp-changed");
+  }
+
+  const norm = (url) => { try { return new URL(url, location.origin).href; } catch { return url; } };
+  const idOf = (url) => "mcp-" + norm(url).replace(/[^\w]+/g, "-").slice(0, 60);
+
+  async function add({ name, url, headers = {}, source = "user", enabled = true }) {
+    const u = norm(url); const id = idOf(u);
+    if (!servers.has(id)) servers.set(id, { id, name: name || u, url: u, headers, source, enabled, client: null, tools: [], status: "saved" });
+    const s = servers.get(id);
+    s.enabled = enabled;   // adding is an explicit intent — (re)enable even if a saved entry existed
+    await connect(s.id).catch(() => {});
+    await persist();
+    bus.emit("mcp-changed");
+    return s;
+  }
+
+  async function connect(id) {
+    const s = servers.get(id); if (!s) return null;
+    s.status = "connecting"; s.error = null; bus.emit("mcp-changed");
+    try {
+      s.client = makeMcpClient({ url: s.url, headers: s.headers, name: s.name });
+      await s.client.initialize();
+      s.tools = await s.client.listTools();
+      s.name = s.client.name() || s.name;
+      s.status = "connected";
+    } catch (e) {
+      s.client = null; s.tools = []; s.status = "error"; s.error = String(e && e.message || e);
+    }
+    bus.emit("mcp-changed");
+    return s;
+  }
+
+  async function remove(id) { servers.delete(id); await persist(); bus.emit("mcp-changed"); }
+  async function setEnabled(id, on) { const s = servers.get(id); if (s) { s.enabled = !!on; if (on && !s.client) await connect(id); await persist(); bus.emit("mcp-changed"); } }
+
+  // The flat ARMED tool set the loop consumes: [{ def, serverName, call(args)→{text,isError} }].
+  // Per-server `toolFilter` (a name allowlist, set from the UI) selects which tools arm; without
+  // one, the first DEFAULT_ARM tools arm. A hard ceiling keeps the system block inside the model's
+  // context (a local model can't juggle 30 schemas — pick, like LibreChat's per-server selection).
+  const DEFAULT_ARM = 4, MAX_ARM = 8;
+  // the substrate's own roster is curated to its core verbs by default
+  const SUBSTRATE_DEFAULT = ["search_web", "resolve_object", "answer", "verify_object"];
+  function enabledTools() {
+    const out = [];
+    for (const s of servers.values()) {
+      if (!s.enabled || s.status !== "connected") continue;
+      const names = s.toolFilter && s.toolFilter.length ? s.toolFilter
+        : (s.source === "substrate" ? SUBSTRATE_DEFAULT.filter((n) => s.tools.some((t) => t.name === n)) : s.tools.slice(0, DEFAULT_ARM).map((t) => t.name));
+      for (const t of s.tools) {
+        if (!names.includes(t.name)) continue;
+        out.push({
+          def: { name: t.name, description: t.description, inputSchema: t.inputSchema },
+          serverName: s.name, serverId: s.id,
+          call: async (args) => { const r = await s.client.callTool(t.name, args); return { text: contentToText(r), isError: !!(r && r.isError) }; },
+        });
+      }
+    }
+    // de-dup by tool name (first server wins) — small models address tools by bare name
+    const seen = new Set();
+    return out.filter((t) => (seen.has(t.def.name) ? false : (seen.add(t.def.name), true))).slice(0, MAX_ARM);
+  }
+  async function setToolFilter(id, names) { const s = servers.get(id); if (s) { s.toolFilter = names && names.length ? names : null; bus.emit("mcp-changed"); } }
+
+  // Substrate ring: read the OS roster; candidate endpoints = declared, same-origin /mcp, the
+  // conventional localhost MCP port. First reachable wins.
+  async function discoverSubstrateServers() {
+    const entries = await discoverSubstrate();
+    const candidates = new Set();
+    for (const e of entries) if (e.url) candidates.add(norm(e.url));
+    candidates.add(norm("/mcp"));
+    candidates.add("http://127.0.0.1:8787/mcp");
+    return { entries, candidates: [...candidates] };
+  }
+
+  return {
+    restore, add, connect, remove, setEnabled, setToolFilter, enabledTools, persist,
+    list: () => [...servers.values()],
+    discoverSubstrateServers, searchRegistry, discoverAgents,
+  };
+}

core/memory.js

@@ -0,0 +1,69 @@
+// core/memory.js — persistent USER MEMORY (LibreChat memory semantics, substrate-native).
+// Memories are key/value facts (key validated /^[a-z_]+$/, value a complete sentence) stored as
+// κ-objects with pointers in the boot index. They inject into the system block as the
+// "# Existing memory:" section, and the model maintains them itself through two LOCAL tools
+// (set_memory / delete_memory) armed alongside MCP tools in the agentic loop — no server,
+// every write content-addressed and verifiable.
+
+const LC = { lc: "https://librechat.ai/ns#" };
+export const KEY_RE = /^[a-z_]+$/;
+
+export function makeMemory(chatStore, { tokenLimit = 2000 } = {}) {
+  const { store, getIndex, newId } = chatStore;
+  const putIndex = async (idx) => { const b = new TextEncoder().encode(JSON.stringify(idx)); return store.backend.putRaw ? store.backend.putRaw("index:org.hologram.HoloQ", b) : store.backend.put("index:org.hologram.HoloQ", b); };
+  const tokensOf = (s) => Math.ceil((s || "").length / 4);   // a fair, dependency-free estimate
+
+  async function list() { return (await getIndex()).memories || []; }
+
+  async function set(key, value) {
+    key = String(key || "").toLowerCase().trim();
+    if (!KEY_RE.test(key)) return { ok: false, error: "invalid key — use lowercase letters and underscores" };
+    const idx = await getIndex();
+    idx.memories = idx.memories || [];
+    const used = idx.memories.filter((m) => m.key !== key).reduce((n, m) => n + (m.tokenCount || 0), 0);
+    const tc = tokensOf(value);
+    if (used + tc > tokenLimit) return { ok: false, error: `memory full: ${used}+${tc} > ${tokenLimit} tokens` };
+    const obj = await store.makeObject({
+      type: ["schema:Statement", "prov:Entity"], context: [LC],
+      "lc:key": key, "lc:value": String(value || ""), "lc:tokenCount": tc,
+      "schema:dateModified": new Date().toISOString(),
+    });
+    const i = idx.memories.findIndex((m) => m.key === key);
+    const ptr = { key, kappa: obj.id, value: String(value || ""), tokenCount: tc, updated_at: new Date().toISOString() };
+    if (i >= 0) idx.memories[i] = ptr; else idx.memories.push(ptr);
+    await putIndex(idx);
+    return { ok: true, key, kappa: obj.id };
+  }
+
+  async function remove(key) {
+    const idx = await getIndex();
+    idx.memories = (idx.memories || []).filter((m) => m.key !== key);
+    await putIndex(idx);
+    return { ok: true };
+  }
+
+  // The system-block injection ("# Existing memory:" — the LibreChat convention).
+  async function injection() {
+    const mems = await list();
+    if (!mems.length) return "";
+    const used = mems.reduce((n, m) => n + (m.tokenCount || 0), 0);
+    return `# Memory Status:\nCurrent memory usage: ${used} tokens\nToken limit: ${tokenLimit} tokens\nRemaining capacity: ${Math.max(0, tokenLimit - used)} tokens\n\n# Existing memory:\n` +
+      mems.map((m) => `- ${m.key}: ${m.value}`).join("\n");
+  }
+
+  // The two LOCAL tools the agentic loop arms (same shape as MCP hub tools).
+  function localTools() {
+    return [
+      {
+        def: { name: "set_memory", description: "Remember a fact about the user across conversations. Only when the user explicitly asks (\"remember that…\"). key: lowercase_with_underscores; value: one complete sentence.", inputSchema: { type: "object", properties: { key: { type: "string" }, value: { type: "string" } }, required: ["key", "value"] } },
+        serverName: "memory", call: async (a) => { const r = await set(a.key, a.value); return { text: JSON.stringify(r), isError: !r.ok }; },
+      },
+      {
+        def: { name: "delete_memory", description: "Forget a remembered fact, by key. Only when the user explicitly asks.", inputSchema: { type: "object", properties: { key: { type: "string" } }, required: ["key"] } },
+        serverName: "memory", call: async (a) => { const r = await remove(a.key); return { text: JSON.stringify(r), isError: false }; },
+      },
+    ];
+  }
+
+  return { list, set, remove, injection, localTools, tokenLimit };
+}

core/presets.js

@@ -0,0 +1,54 @@
+// core/presets.js — preset CRUD (the saved parameter bundles a conversation spreads, LibreChat's
+// conversationPreset semantics). Each preset is a κ-object in the store; the boot index keeps
+// pointer rows { presetId, kappa, title } so listing is O(1) without a scan.
+
+import { normPreset } from "./schema.js";
+
+const LC = { lc: "https://librechat.ai/ns#" };
+
+export function makePresets(chatStore) {
+  const { store, getIndex, newId } = chatStore;
+  const putIndex = async (idx) => { const b = new TextEncoder().encode(JSON.stringify(idx)); return store.backend.putRaw ? store.backend.putRaw("index:org.hologram.HoloQ", b) : store.backend.put("index:org.hologram.HoloQ", b); };
+
+  async function save(p) {
+    const norm = normPreset(p);
+    if (!norm.presetId) norm.presetId = newId("preset");
+    const obj = await store.makeObject({ type: ["schema:PropertyValue", "prov:Entity"], context: [LC], "schema:identifier": norm.presetId, "schema:name": norm.title, "lc:preset": norm });
+    const idx = await getIndex();
+    idx.presets = idx.presets || [];
+    const i = idx.presets.findIndex((x) => x.presetId === norm.presetId);
+    const ptr = { presetId: norm.presetId, kappa: obj.id, title: norm.title, defaultPreset: !!p.defaultPreset };
+    if (i >= 0) idx.presets[i] = ptr; else idx.presets.push(ptr);
+    if (p.defaultPreset) idx.presets.forEach((x) => { if (x.presetId !== norm.presetId) x.defaultPreset = false; });
+    await putIndex(idx);
+    return { ...norm, kappa: obj.id };
+  }
+
+  async function list() { return (await getIndex()).presets || []; }
+
+  async function get(presetId) {
+    const ptr = (await list()).find((x) => x.presetId === presetId); if (!ptr) return null;
+    const obj = await store.getObj(ptr.kappa); if (!obj) return null;
+    if (!(await store.verify(obj))) return null;   // Law L5: a tampered preset is refused
+    return { ...normPreset(obj["lc:preset"]), kappa: ptr.kappa };
+  }
+
+  async function getDefault() {
+    const ptrs = await list(); const d = ptrs.find((x) => x.defaultPreset) || null;
+    return d ? get(d.presetId) : null;
+  }
+
+  async function remove(presetId) {
+    const idx = await getIndex();
+    idx.presets = (idx.presets || []).filter((x) => x.presetId !== presetId);
+    await putIndex(idx);   // the κ-object stays content-addressed in the store (dedup'd, unreferenced)
+  }
+
+  return { save, list, get, getDefault, remove };
+}
+
+// The factory default — mirrors the engine's real capabilities (greedy decode is the
+// deterministic, verifiable path; temperature stays 0 unless a model declares one).
+export const DEFAULT_PRESET = () => normPreset({
+  title: "Default", temperature: 0, maxOutputTokens: 900, promptPrefix: "",
+});

core/promptsLib.js

@@ -0,0 +1,109 @@
+// core/promptsLib.js — the PROMPTS LIBRARY as κ-objects (LibreChat prompt-group semantics).
+// A group carries name · category · oneliner · command (the /slash trigger) and points at its
+// PRODUCTION version; every version is its own immutable κ-object (text or chat type). The
+// {{variable}} syntax matches LibreChat: {{name}}, {{name:opt1|opt2}} dropdowns, and the
+// special variables {{current_date}} {{current_datetime}} {{iso_datetime}} {{current_user}}.
+
+const LC = { lc: "https://librechat.ai/ns#" };
+export const COMMAND_RE = /^[a-z0-9-]{1,56}$/;
+export const VAR_RE = /{{([^{}]+?)}}/g;
+const SPECIAL = ["current_date", "current_datetime", "iso_datetime", "current_user"];
+
+export function detectVariables(text) {
+  const out = []; const seen = new Set(); let m;
+  VAR_RE.lastIndex = 0;
+  while ((m = VAR_RE.exec(text || ""))) {
+    const raw = m[1].trim();
+    const name = raw.split(":")[0].trim();
+    if (SPECIAL.includes(name.toLowerCase()) || seen.has(name)) continue;
+    seen.add(name);
+    const opts = raw.includes(":") ? raw.slice(raw.indexOf(":") + 1).split("|").map((s) => s.trim()).filter(Boolean) : null;
+    out.push({ name, raw, options: opts });
+  }
+  return out;
+}
+
+export function replaceSpecialVars(text, { userName = "operator" } = {}) {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const day = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"][d.getDay()];
+  const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+  const time = `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+  const off = -d.getTimezoneOffset(); const tz = (off >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(off) / 60)) + ":" + pad(Math.abs(off) % 60);
+  const sub = (t, name, v) => t.replace(new RegExp(`{{\\s*${name}\\s*}}`, "gi"), v);
+  let out = text || "";
+  out = sub(out, "current_date", `${date} (${day})`);
+  out = sub(out, "current_datetime", `${date} ${time} ${tz} (${day})`);
+  out = sub(out, "iso_datetime", d.toISOString());
+  out = sub(out, "current_user", userName);
+  return out;
+}
+
+export function fillVariables(text, values) {
+  let out = text || "";
+  for (const [raw, v] of Object.entries(values || {})) {
+    const esc = raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(`{{\\s*${esc}\\s*}}`, "g"), v);
+  }
+  return out;
+}
+
+export function makePromptsLib(chatStore) {
+  const { store, getIndex, newId } = chatStore;
+  const putIndex = async (idx) => { const b = new TextEncoder().encode(JSON.stringify(idx)); return store.backend.putRaw ? store.backend.putRaw("index:org.hologram.HoloQ", b) : store.backend.put("index:org.hologram.HoloQ", b); };
+
+  // Save a version into a group (creates the group when groupId is null); production by default.
+  async function save({ groupId, name, category = "", oneliner = "", command = "", prompt, type = "text", production = true }) {
+    command = (command || "").toLowerCase();
+    if (command && !COMMAND_RE.test(command)) throw new Error("command must be a-z 0-9 dash, ≤56 chars");
+    const versionObj = await store.makeObject({
+      type: ["schema:CreativeWork", "prov:Entity"], context: [LC],
+      "lc:prompt": prompt || "", "lc:type": type === "chat" ? "chat" : "text",
+      "schema:dateCreated": new Date().toISOString(),
+    });
+    const idx = await getIndex();
+    idx.promptGroups = idx.promptGroups || [];
+    let g = groupId ? idx.promptGroups.find((x) => x.groupId === groupId) : null;
+    if (!g) {
+      g = { groupId: newId("pgroup"), name: name || "New Prompt", category, oneliner, command, versions: [], productionKappa: null, numberOfGenerations: 0 };
+      idx.promptGroups.push(g);
+    }
+    if (name) g.name = name;
+    if (category !== undefined) g.category = category;
+    if (oneliner !== undefined) g.oneliner = oneliner;
+    if (command !== undefined) g.command = command;
+    g.versions.push({ kappa: versionObj.id, createdAt: new Date().toISOString() });
+    if (production || !g.productionKappa) g.productionKappa = versionObj.id;
+    await putIndex(idx);
+    return { ...g };
+  }
+
+  async function list() { return (await getIndex()).promptGroups || []; }
+
+  async function production(groupId) {
+    const g = (await list()).find((x) => x.groupId === groupId); if (!g || !g.productionKappa) return null;
+    const obj = await store.getObj(g.productionKappa); if (!obj) return null;
+    if (!(await store.verify(obj))) return null;       // Law L5
+    return { group: g, prompt: obj["lc:prompt"], type: obj["lc:type"], kappa: g.productionKappa };
+  }
+
+  async function setProduction(groupId, kappa) {
+    const idx = await getIndex();
+    const g = (idx.promptGroups || []).find((x) => x.groupId === groupId);
+    if (g && g.versions.some((v) => v.kappa === kappa)) { g.productionKappa = kappa; await putIndex(idx); }
+  }
+
+  async function recordUse(groupId) {
+    const idx = await getIndex();
+    const g = (idx.promptGroups || []).find((x) => x.groupId === groupId);
+    if (g) { g.numberOfGenerations = (g.numberOfGenerations || 0) + 1; await putIndex(idx); }
+  }
+
+  async function remove(groupId) {
+    const idx = await getIndex();
+    idx.promptGroups = (idx.promptGroups || []).filter((x) => x.groupId !== groupId);
+    await putIndex(idx);
+  }
+
+  return { save, list, production, setProduction, recordUse, remove };
+}

core/q-brain-fast.mjs

@@ -0,0 +1,153 @@
+// core/q-brain-fast.mjs — Q's FAST on-device brain, drop-in for createHoloModelBrain.
+//
+// Same provider shape (load · generate → text-delta async-iterator · chat · info · setSkill), so
+// holo-q-contact.mjs's makeQResponder / makeQGroupResponder bind it with ZERO changes: Q rides the exact
+// stream→finalize pipeline, it just sources its bytes from THIS engine (core/loader + core/engine — the
+// native-ternary κ-object path with the fixed incremental-detok decode) instead of the qwen holo-brain.
+//
+// Why this exists: the messenger's default brain (qwen2.5-0.5b via holo-brain-engine) is heavy and its
+// app-path decode was O(n²). This one loads a native-ternary BitNet κ-object (0.69 GB, verified per-block),
+// decodes at ~70 tok/s warm, and streams byte-identical incremental text. It is 100% on-device at decode
+// time — only a ONE-TIME tokenizer-header Range fetch touches the source host at load (the weights are the
+// local, L5-verified b/<κ>.gz blocks). Bundle the header to make load fully egress-free (follow-up).
+//
+// URL discipline (the one gotcha): core/loader's MODELS use a PAGE-relative kappaUrl ("./models/<name>"),
+// which is wrong from any page other than /apps/q/. loadKappaObject resolves the manifest, blocks AND the
+// bundled tokenizer relative to its baseUrl, so we override kappaUrl to an ABSOLUTE mount ("/apps/q/models/
+// <name>") — that makes the whole load self-contained from the messenger (or anywhere).
+
+import { ready, loadModel, MODELS } from "./loader.js";
+import { createEngine } from "./engine.js";
+import { selfFacts, selfPersona, selfIntro } from "./q-self.mjs";   // Q's live, grounded self-knowledge (M0)
+
+// The default fast brain = BitNet-2B (native ternary, llama3 template, coherent — Falcon-E degenerates).
+// Override via opts.family / opts.modelName. kappaBase is the absolute mount core/loader's models live under.
+const DEFAULTS = { family: "BitNet", kappaBase: "/apps/q/models", maxTokens: 512 };
+
+function pickModel(cfg) {
+  const want = String(cfg.modelName || cfg.family || "BitNet").toLowerCase();
+  const m = MODELS.find((x) => (x.fam || "").toLowerCase() === want || (x.name || "").toLowerCase().includes(want)) || MODELS.find((x) => (x.fam || "").toLowerCase() === "bitnet");
+  if (!m) throw new Error("q-brain-fast: no model matches " + want);
+  // An ABSOLUTE host URL (the κ-object now lives on HF, not on this machine) is already page-independent —
+  // use it verbatim. Only a page-relative "./models/<name>" needs absolute-mounting so it resolves from ANY page.
+  if (/^https?:\/\//.test(m.kappaUrl || "")) return { ...m };
+  const rel = String(m.kappaUrl || "").replace(/^\.?\//, "").replace(/^models\//, "");   // "./models/bitnet-2b" → "bitnet-2b"
+  return { ...m, kappaUrl: String(cfg.kappaBase).replace(/\/+$/, "") + "/" + rel };
+}
+
+// Render an [{role,content}] history (system + turns, as makeQResponder builds it) to the model's chat
+// template — the multi-turn generalization of core/engine's single-turn frameTurn. Covers the templates
+// the engine knows; unknown families fall back to a persona-led last-user Q/A frame.
+function frameHistory(M, history) {
+  const list = Array.isArray(history) ? history : [];
+  // merge ALL system turns into one system block (persona + any injected context, e.g. M1 grounded retrieval) —
+  // taking only the first would silently DROP injected context and the model would fall back to a generic refusal.
+  const persona = list.filter((x) => x && x.role === "system" && x.content).map((x) => x.content).join("\n\n");
+  const turns = list.filter((x) => x && x.role !== "system" && (x.content || "").length);
+
+  if (M.llama3) {
+    let s = persona ? `<|start_header_id|>system<|end_header_id|>\n\n${persona}<|eot_id|>` : "";
+    for (const t of turns) s += `<|start_header_id|>${t.role === "assistant" ? "assistant" : "user"}<|end_header_id|>\n\n${t.content}<|eot_id|>`;
+    return s + `<|start_header_id|>assistant<|end_header_id|>\n\n`;
+  }
+  if (M.qwen) {
+    const noThink = M.qwen3 ? "<think>\n\n</think>\n\n" : "";
+    let s = persona ? `<|im_start|>system\n${persona}<|im_end|>\n` : "";
+    for (const t of turns) s += `<|im_start|>${t.role === "assistant" ? "assistant" : "user"}\n${t.content}<|im_end|>\n`;
+    return s + `<|im_start|>assistant\n` + noThink;
+  }
+  if (M.olmo) {
+    let s = persona ? `<|system|>\n${persona}\n` : "";
+    for (const t of turns) s += t.role === "assistant" ? `<|assistant|>\n${t.content}\n` : `<|user|>\n${t.content}\n`;
+    return s + `<|assistant|>\n`;
+  }
+  // word-frame / plain: only the last user turn carries (base models have no multi-turn template)
+  const lastUser = [...turns].reverse().find((t) => t.role !== "assistant");
+  const q = (lastUser && lastUser.content) || "";
+  if (M.userWord) return (persona ? persona + "\n" : "") + "User: " + q + "\nFalcon:";
+  return (persona ? persona + "\n" : "") + "Question: " + q + "\nAnswer:";
+}
+
+export function createFastQBrain(opts = {}) {
+  const cfg = Object.assign({}, DEFAULTS, opts);
+  const M = pickModel(cfg);
+  let engine = null, loadingP = null;
+  let info = { ready: false, model: M.name, device: null, resident: false };
+
+  // encode a history to the running token ids (framed + optional bos), ready for engine.generate
+  function idsFor(history) {
+    let ids = engine.tokenize(frameHistory(M, history));
+    if (M.bos && engine.bosId != null) ids = [engine.bosId, ...ids];
+    return ids;
+  }
+
+  async function load(onProgress) {
+    if (engine) return info;
+    if (loadingP) return loadingP;
+    loadingP = (async () => {
+      if (!(typeof navigator !== "undefined" && navigator.gpu)) throw new Error("no WebGPU on this device");
+      await ready();   // wasm tokenizer init (shared instance)
+      const loaded = await loadModel(M, {
+        onStatus: () => {},
+        onProgress: (d, t, w) => { try { onProgress && onProgress({ done: d, total: t, phase: w, model: M.name }); } catch (e) {} },
+      });
+      if (!loaded || !loaded.gpu) throw new Error("q-brain-fast: model load failed (" + M.name + ")");
+      engine = await createEngine(M, loaded);
+      // MEASURED from the real engine, not asserted: device/resident reflect an engine that actually uploaded
+      // weights to the GPU (dims + gpuBytes are live signals) — so info() can never claim residency it lacks.
+      info = { ready: true, model: M.name, device: (engine && engine.dims ? "webgpu" : null), resident: !!(engine && (engine.gpuBytes || engine.dims)) };
+      return info;
+    })().catch((e) => { loadingP = null; throw e; });
+    return loadingP;
+  }
+  async function ensure(onProgress) { if (!engine) await load(onProgress); return engine; }
+
+  // generate(history, { signal, onProgress }) → async-iterator of TEXT DELTAS (exactly what makeQResponder
+  // accumulates + paints via onDelta). engine.generate reports CUMULATIVE text per step; we diff to deltas
+  // and pump them through a small queue so this stays a clean generator (and honors the abort signal).
+  async function* generate(history, o = {}) {
+    await ensure(o.onProgress);
+    if (!engine) return;
+    const signal = o.signal || null;
+    const ids = idsFor(history);
+    const cap = o.maxTokens || cfg.maxTokens || M.cap || 256;
+
+    const queue = []; let done = false, wake = null, prev = "";
+    const kick = () => { if (wake) { const w = wake; wake = null; w(); } };
+    const run = engine.generate(ids, {
+      maxNew: cap, signal,
+      onToken: ({ text }) => { const d = (text || "").slice(prev.length); if (d) { prev = text; queue.push(d); kick(); } },
+    }).then(() => { done = true; kick(); }).catch(() => { done = true; kick(); });
+
+    while (true) {
+      if (queue.length) { yield queue.shift(); continue; }
+      if (done) break;
+      if (signal && signal.aborted) break;
+      await new Promise((r) => (wake = r));
+    }
+    try { await run; } catch (e) {}
+  }
+
+  // chat(history, opts) → full string (used by window.HoloQ.generate + light background features)
+  async function chat(history, o = {}) {
+    await ensure(o.onProgress);
+    if (!engine) return "";
+    const res = await engine.generate(idsFor(history), { maxNew: o.maxTokens || cfg.maxTokens || M.cap || 256, signal: o.signal || null });
+    return ((res && res.text) || "").trim();
+  }
+
+  // native-ternary κ-object → no LoRA adapters; skill routing is a no-op (the base is the specialist).
+  const setSkill = async () => ({ adapter: false, unsupported: true });
+  const setAdapter = async () => ({ adapter: false, unsupported: true });
+
+  // Q's LIVE self-knowledge (M0), derived from THIS instance's real model + engine κ — the grounded truth
+  // every surface leads with so Q is honestly self-aware and never confabulates a cloud identity. Available
+  // even before load (identity is in M); the κ fills in once the engine is resident.
+  const facts = () => selfFacts({ model: M, engine });
+  const persona = () => selfPersona({ model: M, engine });
+  const intro = () => selfIntro({ model: M, engine });
+
+  return { id: "q-brain-fast-" + (M.fam || M.name), load, generate, chat, setSkill, setAdapter, info: () => info, facts, persona, intro };
+}
+
+export default createFastQBrain;

core/q-self.mjs

@@ -0,0 +1,62 @@
+// core/q-self.mjs — Q's LIVE, GROUNDED self-knowledge. The single source of truth for who/what/where/how Q
+// is, DERIVED FROM REAL RUNTIME SIGNALS (the loaded model, its content-addressed κ, the device, optional
+// system health) — never hardcoded, never guessed. Every Q surface (messenger, q-chat, voice) leads with
+// this, so Q is truthfully self-aware EVERYWHERE and can never confabulate a cloud/OpenAI/AWS identity.
+//
+// Why this exists (the law: grounded transcendence, never performed): a base model has NO self-knowledge —
+// asked "what are you" it returns the average of its training data ("I run on AWS/OpenAI"), which is false.
+// So Q's identity is not a persona we write; it is the TRUTH of this running instance, computed here. If a
+// fact isn't really knowable in this context, we OMIT it — we never invent one.
+//
+// DOM-free + fully guarded: safe to import in any surface (standalone app, messenger, OS shell, Node witness).
+
+// Structured self-facts from whatever is really knowable HERE. Fail-soft: a missing signal is omitted.
+export function selfFacts({ model, engine } = {}) {
+  const f = { name: "Q" };
+  try { if (model) { if (model.name) f.model = model.name; if (model.fam) f.family = model.fam; if (model.fmt) f.quant = model.fmt; if (model.size) f.size = model.size; } } catch (e) {}
+  try { if (engine && engine.modelKappa) f.kappa = engine.modelKappa; } catch (e) {}
+  try { f.gpu = (typeof navigator !== "undefined" && !!navigator.gpu); } catch (e) {}
+  // MEASURED, never asserted: Q is "resident" only when the engine has really uploaded weights to the GPU
+  // (a live signal — gpuBytes/dims), not a hardcoded true. Before load it is false, and stays false.
+  try { f.resident = !!(engine && (engine.gpuBytes || engine.dims)); } catch (e) { f.resident = false; }
+  // DERIVED from real signals — runs-on-device when actually resident, or at least GPU-capable before load.
+  f.runsOnDevice = !!(f.resident || f.gpu);
+  // "no server / no egress" is a property of the LOCAL engine, so we assert it ONLY when a real local engine or
+  // GPU is visible. Decode is in-browser (egress none); the one network touch is the weights fetch AT LOAD, so we
+  // say that plainly instead of a flat "nothing ever touches the network".
+  if (f.resident || f.gpu) { f.server = false; f.egress = f.resident ? "none at inference (weights fetched once at load)" : "none at inference"; }
+  // Provenance — where Q was loaded FROM (the thing the operator cares about): the page origin + the weights host.
+  // Omitted when not knowable. This is what lets Q answer "where did you come from" truthfully.
+  try { if (typeof location !== "undefined" && location.origin && location.origin !== "null") f.loadedFrom = location.origin; } catch (e) {}
+  try { if (model && model.kappaUrl) { const u = new URL(model.kappaUrl, (typeof location !== "undefined" ? location.href : "https://local/")); f.weightsFrom = u.host || u.protocol.replace(":", ""); } } catch (e) {}
+  // optional live system health — present only when the OS shell exposes it (absent in standalone apps).
+  try { const h = (typeof window !== "undefined") && window.HoloSysHealth && window.HoloSysHealth.summary && window.HoloSysHealth.summary(); if (h) f.health = h; } catch (e) {}
+  try { if (!f.health && typeof window !== "undefined" && window.Q && window.Q.health) { const q = window.Q.health(); if (q) f.health = q; } } catch (e) {}
+  return f;
+}
+
+// The grounded SYSTEM persona every Q surface leads with. Warm + honest + specific + anti-confabulation,
+// composed from the live facts so Q states ONLY what is true of THIS instance. Kept concise — a small model
+// follows a short, sharp system turn far better than a long one.
+export function selfPersona(opts = {}) {
+  const f = selfFacts(opts);
+  const s = [];
+  s.push(`You are Q — a private AI that runs on the user's own device, in their web browser${f.gpu ? ", on their GPU" : ""}.`);
+  if (f.model) s.push(`You are the ${f.model} model${f.quant ? ` (${f.quant})` : ""}${f.resident ? ", resident locally right now" : ""}${f.kappa ? "; your weights are content-addressed and verified by re-derivation, so no host has to be trusted" : ""}.`);
+  if (f.server === false) s.push(`You decode locally — there is no inference server and no cloud, and nothing the user types ever leaves their device.${f.resident ? " Your weights were fetched once at load and verified; after that, inference is fully on-device." : ""}`);
+  s.push("You are warm, concise, honest, and genuinely present. You seek clarity and truth; you say less, better; you never overwhelm.");
+  s.push("If asked what or where you are, answer truthfully from the above: you run locally, on their device. Never claim to run on a server, the cloud, OpenAI, ChatGPT, GPT-4, Gemini, or AWS — those are false. If you don't know something, say so plainly rather than inventing it.");
+  return s.join(" ");
+}
+
+// A short, human, first-person self-summary (for a proactive greeting or a direct "who are you"). Grounded.
+export function selfIntro(opts = {}) {
+  const f = selfFacts(opts);
+  const bits = [`I'm Q — ${f.resident ? "running right here on your device" : "running on your device"}${f.gpu ? ", on your GPU" : ""}${f.model ? ` (the ${f.model} model)` : ""}.`];
+  if (f.server === false) bits.push(`No server, no cloud; nothing you say leaves this machine${f.kappa ? ", and my weights are verified by re-derivation" : ""}.`);
+  else if (f.kappa) bits.push("My weights are verified by re-derivation.");
+  bits.push("What's on your mind?");
+  return bits.join(" ");
+}
+
+export default { selfFacts, selfPersona, selfIntro };

core/schema.js

@@ -0,0 +1,85 @@
+// core/schema.js — lean, dependency-free validators ("zod-lite") for the LibreChat-faithful
+// Conversation / Message / Preset shapes. Field names mirror LibreChat's data model (packages/
+// data-schemas) so an exported conversation interoperates; values are validated/normalised, not
+// hashed (the κ-object store is what makes them content-addressed). No build step, no dep.
+
+const isStr = (v) => typeof v === "string";
+const isBool = (v) => typeof v === "boolean";
+const isNum = (v) => typeof v === "number" && !Number.isNaN(v);
+const arr = (v) => (Array.isArray(v) ? v : []);
+const clampNum = (v, lo, hi, d) => (isNum(v) ? Math.min(hi, Math.max(lo, v)) : d);
+
+// A chat message (one node in the parentMessageId tree).
+export function normMessage(m = {}) {
+  return {
+    messageId: isStr(m.messageId) ? m.messageId : null,
+    conversationId: isStr(m.conversationId) ? m.conversationId : null,
+    parentMessageId: isStr(m.parentMessageId) ? m.parentMessageId : null,   // tree edge
+    sender: isStr(m.sender) ? m.sender : (m.isCreatedByUser ? "User" : "Assistant"),
+    isCreatedByUser: isBool(m.isCreatedByUser) ? m.isCreatedByUser : false,
+    model: isStr(m.model) ? m.model : null,
+    text: isStr(m.text) ? m.text : "",
+    content: arr(m.content),                          // structured parts (text/tool/image/reasoning)
+    tokenCount: isNum(m.tokenCount) ? m.tokenCount : null,
+    error: m.error || null,
+    unfinished: !!m.unfinished,
+    feedback: m.feedback && isStr(m.feedback.rating || "") ? { rating: m.feedback.rating, tag: m.feedback.tag || null, text: m.feedback.text || "" } : (m.feedback || null),
+    files: arr(m.files),
+    createdAt: isStr(m.createdAt) ? m.createdAt : null,
+    receiptKappa: isStr(m.receiptKappa) ? m.receiptKappa : null,             // links the PROV-O inference receipt
+  };
+}
+
+// A conversation (spreads the active preset, like LibreChat's conversationPreset).
+export function normConversation(c = {}) {
+  return {
+    conversationId: isStr(c.conversationId) ? c.conversationId : null,
+    title: isStr(c.title) ? c.title : "New Chat",
+    tags: arr(c.tags),
+    files: arr(c.files),
+    folder: isStr(c.folder) ? c.folder : null,
+    archived: !!c.archived,
+    favorite: !!c.favorite,
+    isTemporary: !!c.isTemporary,
+    preset: c.preset ? normPreset(c.preset) : null,
+    createdAt: isStr(c.createdAt) ? c.createdAt : null,
+    updatedAt: isStr(c.updatedAt) ? c.updatedAt : null,
+  };
+}
+
+// A preset / parameter bundle. Bounds mirror common LLM ranges; model is the local κ-object id.
+export function normPreset(p = {}) {
+  return {
+    presetId: isStr(p.presetId) ? p.presetId : null,
+    title: isStr(p.title) ? p.title : "Preset",
+    model: isStr(p.model) ? p.model : null,
+    temperature: clampNum(p.temperature, 0, 2, 0),
+    top_p: clampNum(p.top_p, 0, 1, 1),
+    top_k: clampNum(p.top_k, 0, 200, 40),
+    maxOutputTokens: clampNum(p.maxOutputTokens, 1, 8192, 1024),
+    promptPrefix: isStr(p.promptPrefix) ? p.promptPrefix : "",
+    presence_penalty: clampNum(p.presence_penalty, -2, 2, 0),
+    frequency_penalty: clampNum(p.frequency_penalty, -2, 2, 0),
+    stop: arr(p.stop),
+    iconURL: isStr(p.iconURL) ? p.iconURL : null,
+    isArchived: !!p.isArchived,
+  };
+}
+
+// Walk a flat message list into the LibreChat parentMessageId tree → {roots, byId, childrenOf}.
+export function buildTree(messages) {
+  const byId = new Map(); const childrenOf = new Map(); const roots = [];
+  for (const m of messages) { byId.set(m.messageId, m); childrenOf.set(m.messageId, []); }
+  for (const m of messages) {
+    if (m.parentMessageId && childrenOf.has(m.parentMessageId)) childrenOf.get(m.parentMessageId).push(m.messageId);
+    else roots.push(m.messageId);
+  }
+  return { roots, byId, childrenOf };
+}
+
+// The active thread = follow the chosen child at each branch from a root to a leaf.
+export function threadOf(tree, { choose = (siblings) => siblings[siblings.length - 1] } = {}) {
+  const out = []; let cur = tree.roots.length ? choose(tree.roots) : null;
+  while (cur) { out.push(tree.byId.get(cur)); const kids = tree.childrenOf.get(cur) || []; cur = kids.length ? choose(kids) : null; }
+  return out;
+}

core/semantic-witness.mjs

@@ -0,0 +1,33 @@
+// core/semantic-witness.mjs — the W3C SEMANTIC-TYPING gate (C2, extended to all κ-objects).
+// Proves EVERY substrate object kind yields a node that is simultaneously: content-addressed (Law L1,
+// @id = did:holo), schema.org-typed (WHAT it is), and PROV-O-bearing (HOW it came to be) — i.e. legible
+// to any W3C JSON-LD/RDF tool. Pure + node-runnable: `node core/semantic-witness.mjs`. Exit 1 on any fail.
+
+import { linkedDataFor, skillAsHowTo, fileAsDocument, appAsSoftware, modelAsSource, asLinkedData, verifySemantic, HOLO_CONTEXT } from "./semantic.js";
+
+const K = (h) => "did:holo:sha256:" + h.padEnd(64, "0").slice(0, 64);
+const cases = [
+  { kind: "skill", node: skillAsHowTo({ name: "Format JSON", description: "When asked to pretty-print JSON", instructions: "1. Parse the text\n2. Re-serialize with 2-space indent", kappa: K("a1"), prov: [{ v: 1, kappa: K("a0") }, { v: 2, kappa: K("a1") }] }), want: "schema:HowTo" },
+  { kind: "file", node: fileAsDocument({ path: "/src/main.py", kappa: K("b1"), bytes: 412 }), want: "schema:DigitalDocument" },
+  { kind: "app", node: appAsSoftware({ name: "counter.html", kappa: K("c1"), bytes: 980 }), want: "schema:SoftwareApplication" },
+  { kind: "model", node: modelAsSource({ name: "BitNet-2B-4T", family: "BitNet", params: "0.69 GB", format: "t2 1.58-bit κ", kappa: K("19e16e6d") }), want: "schema:SoftwareSourceCode" },
+  { kind: "conversation", node: linkedDataFor("conversation", { kappa: K("d1"), props: { "schema:name": "chat #1" } }), want: "schema:Conversation" },
+  { kind: "receipt", node: asLinkedData({ kind: "receipt", kappa: K("e1"), props: { "schema:name": "tool-call receipt" } }), want: "schema:CreativeWork" },
+];
+
+let pass = 0;
+console.log("W3C semantic-typing gate — every κ-object is schema.org-typed + PROV-O + content-addressed\n");
+for (const c of cases) {
+  const v = verifySemantic(c.node);
+  const types = [].concat(c.node["@type"]);
+  const hasWant = types.includes(c.want);
+  const ctxOk = c.node["@context"] === HOLO_CONTEXT || !!c.node["@context"];
+  // JSON round-trip must be lossless (it's just data)
+  let rt = false; try { rt = JSON.stringify(JSON.parse(JSON.stringify(c.node))) === JSON.stringify(c.node); } catch {}
+  const ok = v.ok && hasWant && ctxOk && rt;
+  if (ok) pass++;
+  console.log(`${ok ? "✓" : "✗"} ${c.kind.padEnd(13)} @id=${String(c.node["@id"]).slice(0, 24)}… @type=[${types.join(", ")}]  schema:${v.hasSchema?"y":"n"} prov:${v.hasProv?"y":"n"} id:${v.hasId?"y":"n"} ctx:${ctxOk?"y":"n"} rt:${rt?"y":"n"}`);
+}
+const all = pass === cases.length;
+console.log(`\n${all ? "PASS" : "FAIL"} — ${pass}/${cases.length} κ-object kinds carry a valid W3C @type`);
+process.exit(all ? 0 : 1);

core/semantic.js

@@ -0,0 +1,98 @@
+// core/semantic.js — the SEMANTIC SKIN (gap C2): every κ-object the substrate produces carries an
+// open-semantic-web type, so humans, agents, and W3C validators all read it the same way. Closes the
+// weakest audit axis (κ names objects, but few declared a W3C @type). Two W3C standards, both native:
+//   • JSON-LD / schema.org  — WHAT a thing is (a skill is a schema:HowTo; a file is a schema:DigitalDocument)
+//   • PROV-O                — HOW it came to be (the κ-chain becomes prov:wasRevisionOf links)
+// Pure, dependency-free, browser+node. The result round-trips through any JSON-LD/RDF tool.
+
+export const HOLO_CONTEXT = {
+  schema: "https://schema.org/",
+  prov: "http://www.w3.org/ns/prov#",
+  holo: "https://hologram.foundation/ns/",
+  "@vocab": "https://schema.org/",
+};
+
+// schema.org type for a substrate object kind (the canonical mapping, L2 — fixed at the ingest boundary)
+const TYPE_FOR = {
+  skill: "HowTo",            // a reusable procedure = schema:HowTo (steps + when-to-use)
+  file: "DigitalDocument",
+  app: "SoftwareApplication",
+  model: "SoftwareSourceCode",
+  conversation: "Conversation",
+  receipt: "CreativeWork",    // a sealed work record: schema:CreativeWork that is also a prov:Entity
+};
+
+// wrap any object as a typed, content-addressed JSON-LD node. `kappa` is its did:holo (the @id —
+// content IS the identity, Law L1). `prov` is the κ-chain → prov:wasRevisionOf links (PROV-O).
+export function asLinkedData({ kind, kappa, props = {}, prov = [] }) {
+  const t = TYPE_FOR[kind] || "Thing";
+  const node = {
+    "@context": HOLO_CONTEXT,
+    "@id": kappa,                                  // content-derived identity (no location — Law L1)
+    "@type": Array.isArray(t) ? t : ["schema:" + t, "prov:Entity"],   // schema kind + PROV entity
+    ...props,
+  };
+  if (prov.length >= 2) {                          // the version chain → PROV-O revision links
+    const cur = prov[prov.length - 1], parent = prov[prov.length - 2];
+    node["prov:wasRevisionOf"] = { "@id": parent.kappa };
+    node["holo:version"] = cur.v;
+  }
+  node["prov:wasDerivedFrom"] = prov.length ? prov.map((p) => ({ "@id": p.kappa })) : undefined;
+  return node;
+}
+
+// a skill → schema:HowTo (steps become schema:HowToStep), with its PROV-O revision chain.
+export function skillAsHowTo({ name, description, instructions, kappa, prov = [] }) {
+  const steps = String(instructions || "").split("\n").map((s) => s.trim()).filter(Boolean)
+    .map((text, i) => ({ "@type": "schema:HowToStep", "schema:position": i + 1, "schema:text": text.replace(/^\d+[.)]\s*/, "") }));
+  return asLinkedData({ kind: "skill", kappa, prov, props: { "schema:name": name, "schema:description": description, "schema:step": steps } });
+}
+
+// extension → IANA media type (schema:encodingFormat). Small, common set; default text/plain.
+const MEDIA = { html: "text/html", htm: "text/html", js: "text/javascript", mjs: "text/javascript", json: "application/json", jsonld: "application/ld+json", css: "text/css", md: "text/markdown", txt: "text/plain", py: "text/x-python", svg: "image/svg+xml", wasm: "application/wasm", gz: "application/gzip" };
+const mediaOf = (name) => MEDIA[String(name).toLowerCase().split(".").pop()] || "text/plain";
+
+// a workspace file → schema:DigitalDocument (name + media type + byte size), content-addressed (L1).
+export function fileAsDocument({ path, kappa, bytes = 0, mediaType, prov = [] }) {
+  const name = String(path).split("/").filter(Boolean).pop() || String(path);
+  return asLinkedData({ kind: "file", kappa, prov, props: {
+    "schema:name": name, "schema:identifier": kappa,
+    "schema:encodingFormat": mediaType || mediaOf(name), "schema:contentSize": bytes } });
+}
+
+// a built app → schema:SoftwareApplication (a self-contained WebGPU/Web app object).
+export function appAsSoftware({ name, kappa, bytes = 0, prov = [] }) {
+  return asLinkedData({ kind: "app", kappa, prov, props: {
+    "schema:name": String(name).replace(/\.html$/i, ""), "schema:identifier": kappa,
+    "schema:applicationCategory": "WebApplication", "schema:operatingSystem": "Any (WebGPU/Web)",
+    "schema:fileSize": bytes } });
+}
+
+// a loaded model → schema:SoftwareSourceCode (the κ-object that runs on the GPU).
+export function modelAsSource({ name, kappa, family, params, format, prov = [] }) {
+  return asLinkedData({ kind: "model", kappa, prov, props: {
+    "schema:name": name, "schema:identifier": kappa, "schema:programmingLanguage": "WGSL/WebGPU",
+    "holo:family": family, "holo:parameters": params, "holo:format": format } });
+}
+
+// one dispatcher so any producer can type any κ-object: linkedDataFor("app", {...}) etc.
+export function linkedDataFor(kind, props = {}) {
+  switch (kind) {
+    case "skill": return skillAsHowTo(props);
+    case "file": return fileAsDocument(props);
+    case "app": return appAsSoftware(props);
+    case "model": return modelAsSource(props);
+    default: return asLinkedData({ kind, kappa: props.kappa, prov: props.prov || [], props: props.props || props });
+  }
+}
+
+// VERIFY (the gate): an object is semantically valid iff it has @context, an @id (κ), and a @type
+// carrying both a schema.org kind and PROV-O lineage. Returns { ok, types, hasId, hasContext }.
+export function verifySemantic(node) {
+  const types = [].concat(node && node["@type"] || []);
+  const hasSchema = types.some((t) => /^schema:|^https:\/\/schema\.org\//.test(t));
+  const hasProv = types.some((t) => /^prov:/.test(t)) || !!node["prov:wasDerivedFrom"];
+  const hasId = typeof node?.["@id"] === "string" && node["@id"].startsWith("did:holo:");
+  const hasContext = !!node?.["@context"];
+  return { ok: hasSchema && hasId && hasContext, hasSchema, hasProv, hasId, hasContext, types };
+}

core/skills.js

@@ -0,0 +1,92 @@
+// core/skills.js — SELF-EVOLVING AGENT SKILLS, 100% agentskills.io-compatible, enhanced by the UOR
+// substrate. A skill is a folder with SKILL.md (name + description frontmatter + instructions) —
+// the open Anthropic/agentskills.io format, portable to any skills-compatible agent. The Hermes
+// idea (the agent autonomously CREATES and IMPROVES skills from experience) is realized as the
+// agent's own tools. The substrate enhancement: every skill version is content-addressed (κ) and
+// chained — a tamper-proof PROVENANCE of how the skill evolved (Holo Prov). Skills live in OPFS
+// "/skills/<name>/SKILL.md"; the chain log in "/skills/<name>/.prov" (one κ per version).
+//
+// Progressive disclosure (the spec): DISCOVERY (names+descriptions injected at session start) →
+// ACTIVATION (read_skill loads full SKILL.md) → EXECUTION (the agent follows it, using file tools).
+
+import { skillAsHowTo, verifySemantic } from "./semantic.js";
+
+const te = new TextEncoder(), td = new TextDecoder();
+const sha = async (s) => "did:holo:sha256:" + [...new Uint8Array(await crypto.subtle.digest("SHA-256", te.encode(s)))].map((b) => b.toString(16).padStart(2, "0")).join("");
+const slug = (s) => String(s || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "skill";
+
+async function skillsRoot() { const d = await navigator.storage.getDirectory(); const a = await d.getDirectoryHandle("skills", { create: true }); return a; }
+async function skillDir(name, create = false) { return (await skillsRoot()).getDirectoryHandle(slug(name), { create }); }
+async function readText(dir, file) { const fh = await dir.getFileHandle(file); return td.decode(await (await fh.getFile()).arrayBuffer()); }
+async function writeText(dir, file, text) { const fh = await dir.getFileHandle(file, { create: true }); const w = await fh.createWritable(); await w.write(te.encode(text)); await w.close(); }
+
+// SKILL.md = YAML-ish frontmatter (name, description) + markdown instructions (verbatim spec form).
+function buildSkillMd({ name, description, instructions }) {
+  return `---\nname: ${name}\ndescription: ${description}\n---\n\n${instructions || ""}\n`;
+}
+function parseSkillMd(text) {
+  const m = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  const meta = {}; if (m) for (const line of m[1].split("\n")) { const i = line.indexOf(":"); if (i > 0) meta[line.slice(0, i).trim()] = line.slice(i + 1).trim(); }
+  return { name: meta.name || "", description: meta.description || "", instructions: m ? m[2].trim() : text.trim() };
+}
+
+export async function listSkills() {
+  const out = [];
+  try { const root = await skillsRoot();
+    for await (const [n, h] of root.entries()) { if (h.kind !== "directory") continue;
+      try { const sk = parseSkillMd(await readText(h, "SKILL.md")); out.push({ slug: n, name: sk.name || n, description: sk.description }); } catch {} } }
+  catch {}
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export async function readSkill(name) { const dir = await skillDir(name); return parseSkillMd(await readText(dir, "SKILL.md")); }
+
+// save = create OR improve (self-evolution). Appends a κ to the provenance chain — every version
+// sealed + chained to its parent, so the skill's evolution is verifiable (Holo Prov shape).
+export async function saveSkill({ name, description, instructions }) {
+  const dir = await skillDir(name, true);
+  const md = buildSkillMd({ name, description, instructions });
+  const kappa = await sha(md);
+  let prov = []; try { prov = JSON.parse(await readText(dir, ".prov")); } catch {}
+  const parent = prov.length ? prov[prov.length - 1].kappa : null;
+  prov.push({ v: prov.length + 1, kappa, parent, descKappa: await sha(description || "") });
+  await writeText(dir, "SKILL.md", md);
+  await writeText(dir, ".prov", JSON.stringify(prov, null, 1));
+  // semantic skin (C2): emit the W3C linked-data view — schema:HowTo + PROV-O revision chain.
+  const ld = skillAsHowTo({ name, description, instructions, kappa, prov });
+  await writeText(dir, "skill.jsonld", JSON.stringify(ld, null, 1));
+  return { slug: slug(name), kappa, version: prov.length, parent, semantic: verifySemantic(ld).ok };
+}
+
+// the W3C linked-data view of a skill (schema:HowTo + PROV-O), for export / validation / agents.
+export async function skillLinkedData(name) { try { return JSON.parse(await readText(await skillDir(name), "skill.jsonld")); } catch { return null; } }
+
+export async function skillProvenance(name) { try { return JSON.parse(await readText(await skillDir(name), ".prov")); } catch { return []; } }
+
+// DISCOVERY block (progressive disclosure stage 1): names + descriptions only — small footprint.
+export async function skillsDiscoveryPrompt() {
+  const sk = await listSkills();
+  if (!sk.length) return "";
+  return "You have these learned SKILLS available (each a verifiable, content-addressed capability you built from experience). " +
+    "When a task matches a skill's description, call read_skill to load its full instructions, then follow them. " +
+    "When you complete a non-trivial task worth reusing, call save_skill to capture it (or improve an existing one):\n" +
+    sk.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+}
+
+// the agent's skill tools (Hermes self-evolution: the agent creates/improves/uses skills itself)
+export function skillTools() {
+  return [
+    {
+      def: { name: "list_skills", description: "List the learned skills available (name + description).", inputSchema: { type: "object", properties: {}, required: [] } },
+      serverName: "skills", call: async () => { const s = await listSkills(); return { text: s.length ? s.map((x) => `${x.name}: ${x.description}`).join("\n") : "(no skills yet)", isError: false }; },
+    },
+    {
+      def: { name: "read_skill", description: "Load a skill's full instructions by name, to follow them for the current task.", inputSchema: { type: "object", properties: { name: { type: "string" } }, required: ["name"] } },
+      serverName: "skills", call: async ({ name }) => { try { const s = await readSkill(name); return { text: `# ${s.name}\n${s.description}\n\n${s.instructions}`, isError: false }; } catch (e) { return { text: "no such skill: " + name, isError: true }; } },
+    },
+    {
+      def: { name: "save_skill", description: "Capture a reusable skill from what you just did (or improve an existing one). name: short; description: one line of WHEN to use it; instructions: the step-by-step procedure. Each save is sealed + chained (verifiable provenance).", inputSchema: { type: "object", properties: { name: { type: "string" }, description: { type: "string" }, instructions: { type: "string" } }, required: ["name", "description", "instructions"] } },
+      serverName: "skills", call: async ({ name, description, instructions }) => { try { const r = await saveSkill({ name, description, instructions }); return { text: `skill "${name}" saved (v${r.version}, ${r.kappa.slice(0, 28)}…${r.parent ? `, evolved from ${r.parent.slice(0, 20)}…` : ", first version"})`, isError: false }; } catch (e) { return { text: "save error: " + (e.message || e), isError: true }; } },
+    },
+  ];
+}

core/state.js

@@ -0,0 +1,39 @@
+// core/state.js — a tiny event bus + the app's shared mutable state. No framework: modules
+// subscribe to named events and re-render their own DOM islands. Deliberately minimal — the
+// durable truth lives in the κ-object store (Law L3); this is only the session's working set.
+
+export function makeBus() {
+  const subs = new Map();
+  return {
+    on(ev, fn) { if (!subs.has(ev)) subs.set(ev, new Set()); subs.get(ev).add(fn); return () => subs.get(ev)?.delete(fn); },
+    emit(ev, data) { for (const fn of subs.get(ev) || []) { try { fn(data); } catch (e) { console.error(`[bus:${ev}]`, e); } } },
+  };
+}
+
+export function makeState() {
+  return {
+    // model / engine
+    engine: null,            // core/engine.js instance (null until a model loads)
+    modelIndex: 0,           // index into loader.MODELS
+    loading: false,
+    gateOk: false,           // conscience constitution self-verify
+
+    // conversation working set
+    convId: null,            // active conversation id
+    convKappa: null,         // its latest sealed κ
+    title: "New Chat",
+    messages: [],            // [{ obj (sealed κ-object), id, kappa, ...norm fields, tokenIds }]
+    chosenChild: new Map(),  // parent messageId → chosen child messageId (sibling switch)
+    streaming: false,
+    abort: null,             // AbortController while generating
+
+    // ui
+    navOpen: window.innerWidth > 900,
+    panelOpen: false,            // the chat is the product — the panel opens on demand
+    panelTab: "params",
+    settingsOpen: false,
+
+    // preset (the active parameter bundle — LibreChat conversationPreset semantics)
+    preset: null,
+  };
+}

core/store.js

@@ -0,0 +1,185 @@
+// core/store.js — the κ-object CONVERSATION STORE. Conversations are NOT database rows; each
+// Message and each Conversation is a self-verifying UOR object (a canonical JSON-LD document whose
+// identity is did:holo:sha256 of its own content), and the LibreChat parentMessageId tree is
+// expressed as content-addressed LINKS so a child's κ commits to its parent's κ — a Merkle-DAG
+// (Law L3 dedup, Law L5 verify-on-resolve). The object envelope mirrors _shared/holo-object.mjs
+// byte-for-byte (same UOR_CONTEXT, same address() = H(canonical without id), same link digests),
+// but is implemented here over Web Crypto (core/kappa.js) so it runs in the browser AND in the
+// pure-Node witness. Bytes are persisted through a pluggable BACKEND: holo-kstore (IndexedDB) in
+// the app, a Map in the witness. No server; everything is content-addressed and re-derivable.
+
+import { jcs, sha256hex, didHolo } from "./kappa.js";
+
+const _enc = new TextEncoder();
+const _dec = new TextDecoder();
+
+// The base envelope @context — identical to _shared/holo-object.mjs.
+export const UOR_CONTEXT = [
+  "https://www.w3.org/ns/did/v1",
+  "https://w3id.org/security/data-integrity/v2",
+  { schema: "https://schema.org/", prov: "http://www.w3.org/ns/prov#", dcterms: "http://purl.org/dc/terms/",
+    rel: "schema:additionalType", links: { "@id": "schema:hasPart", "@container": "@set" } },
+];
+
+const hexOf = (did) => String(did).split(":").pop();
+const _b64 = (u8) => { let s = ""; for (let i = 0; i < u8.length; i++) s += String.fromCharCode(u8[i]); return btoa(s); };
+const _b64url = (u8) => _b64(u8).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+async function sha256raw(u8) { return new Uint8Array(await crypto.subtle.digest("SHA-256", u8)); }
+async function sriOf(u8) { return "sha256-" + _b64(await sha256raw(u8)); }
+async function mbOf(u8) { const d = await sha256raw(u8); const mh = new Uint8Array(d.length + 2); mh[0] = 0x12; mh[1] = 0x20; mh.set(d, 2); return "u" + _b64url(mh); }
+
+// address(obj): self-verifying identity = did:holo:sha256:H(canonical content with id/alsoKnownAs removed).
+const stripId = (obj) => { const { id, alsoKnownAs, ...content } = obj; return content; };
+const addressOf = (obj) => didHolo(stripId(obj));
+const canonStored = (sealed) => _enc.encode(jcs(sealed));   // the EXACT bytes a link's digest commits to (sealed, WITH id — mirrors holo-object put())
+
+// contentLink(rel, kappa): a LEAF edge to raw content already addressed by its κ (no bytes needed) —
+// identical to holo-object.contentLink. Verified at resolve by re-hashing the raw bytes to the address.
+export function contentLink(rel, kappa, type = "schema:MediaObject") {
+  const hex = String(kappa).split(":").pop();
+  const digest = Uint8Array.from(hex.match(/.{2}/g).map((h) => parseInt(h, 16)));
+  const mh = new Uint8Array(digest.length + 2); mh[0] = 0x12; mh[1] = 0x20; mh.set(digest, 2);
+  return { id: `did:holo:sha256:${hex}`, rel, "@type": type, leaf: true, digestSRI: "sha256-" + _b64(digest), digestMultibase: "u" + _b64url(mh) };
+}
+
+// makeStore(backend) — backend = { get(hex)→Promise<Uint8Array|undefined>, put(hex,bytes)→Promise,
+// putRaw?(key,bytes)/getRaw?(key) for the boot-index pointer record }.
+export function makeStore(backend) {
+  const mem = new Map();   // hex → Uint8Array (session cache; sync verifyDeep operates over it)
+
+  async function putObj(obj) {
+    const sealed = { ...obj, id: await addressOf(obj) };
+    const bytes = canonStored(sealed);
+    const hex = hexOf(sealed.id);
+    mem.set(hex, bytes);
+    await backend.put(hex, bytes);
+    return sealed;
+  }
+  async function getBytes(did) { const hex = hexOf(did); let b = mem.get(hex); if (b) return b; b = await backend.get(hex); if (b) mem.set(hex, b); return b; }
+  async function getObj(did) { const b = await getBytes(did); return b ? JSON.parse(_dec.decode(b)) : null; }
+
+  // a typed Merkle edge to a sealed UOR child (the digest commits to the child's stored bytes).
+  async function uorLink(rel, child) {
+    const bytes = mem.get(hexOf(child.id)) || await backend.get(hexOf(child.id));
+    return { id: child.id, rel, "@type": child["@type"], digestSRI: await sriOf(bytes), digestMultibase: await mbOf(bytes) };
+  }
+
+  // build + seal + store a UOR object. `links` already built (children stored first → Merkle).
+  async function makeObject({ type, context = [], links = [], ...props }) {
+    const obj = { "@context": [...UOR_CONTEXT, ...context], "@type": type, ...props, ...(links.length ? { links } : {}) };
+    return putObj(obj);
+  }
+
+  const verify = async (obj) => obj.id === await addressOf(obj);
+
+  // verifyDeep — re-derive + verify the WHOLE DAG (Law L5 at every level). Pre-loads links into mem.
+  async function verifyDeep(obj, depth = 0) {
+    if (!(await verify(obj))) return { ok: false, at: obj.id, why: "id does not re-derive", depth };
+    let maxDepth = depth;
+    for (const link of obj.links || []) {
+      const bytes = await getBytes(link.id);
+      if (!bytes) return { ok: false, at: link.id, why: "unresolved link", depth };
+      if ((await sriOf(bytes)) !== link.digestSRI) return { ok: false, at: link.id, why: "link digest mismatch", depth };
+      if (link.leaf) { if ((await sha256hex(bytes)) !== hexOf(link.id)) return { ok: false, at: link.id, why: "content hash mismatch", depth }; maxDepth = Math.max(maxDepth, depth + 1); continue; }
+      const child = JSON.parse(_dec.decode(bytes));
+      if (child.id !== link.id) return { ok: false, at: link.id, why: "id/link mismatch", depth };
+      const r = await verifyDeep(child, depth + 1); if (!r.ok) return r; maxDepth = Math.max(maxDepth, r.depth);
+    }
+    return { ok: true, depth: maxDepth };
+  }
+
+  // tamper helper (for the witness): overwrite a stored object's bytes with a flipped field.
+  async function _corrupt(did, mutate) { const o = await getObj(did); mutate(o); const bytes = canonStored(o); mem.set(hexOf(did), bytes); await backend.put(hexOf(did), bytes); }
+
+  return { makeObject, putObj, getObj, getBytes, uorLink, contentLink, verify, verifyDeep, mem, backend, _corrupt };
+}
+
+// ── high-level chat API over a κ-object store ───────────────────────────────────────────────
+// LibreChat-faithful field names. parentMessageId → an "lc:parentMessage" content-addressed link.
+const LC = { lc: "https://librechat.ai/ns#" };
+const rid = (p) => p + "-" + Math.random().toString(36).slice(2, 12);   // id is a human handle; substrate identity is the κ
+
+export function makeChatStore(backend, { now = () => new Date().toISOString() } = {}) {
+  const S = makeStore(backend);
+  const INDEX_KEY = "index:org.hologram.HoloQ";
+  const getIndex = async () => { try { const b = await (backend.getRaw ? backend.getRaw(INDEX_KEY) : backend.get(INDEX_KEY)); return b ? JSON.parse(_dec.decode(b)) : { conversations: [], presets: [] }; } catch { return { conversations: [], presets: [] }; } };
+  const putIndex = async (idx) => { const b = _enc.encode(JSON.stringify(idx)); return backend.putRaw ? backend.putRaw(INDEX_KEY, b) : backend.put(INDEX_KEY, b); };
+
+  // Persist a PROV-O inference receipt as raw content addressed by its own κ (rec.id = H(jcs(body))),
+  // so a message's contentLink("lc:receipt", rec.id) leaf-verifies (sha256(stored bytes) === κ).
+  async function saveReceipt(rec) {
+    const bytes = _enc.encode(jcs(rec.body));
+    const hex = String(rec.id).split(":").pop();
+    S.mem.set(hex, bytes); await backend.put(hex, bytes);
+    return rec.id;
+  }
+
+  // Save one message as a κ-object. `parent` (a sealed message object) is a Merkle uorLink — the
+  // branch tree, so the child's κ commits to the parent's κ. receiptKappa is a leaf content-link.
+  // tokenIds (the turn's exact token sequence) makes context reconstruction and Law-L5
+  // re-derivation possible after a cold reload.
+  async function saveMessage({ messageId, conversationId, sender, isCreatedByUser, model, text, content, tokenCount, tokenIds, error, unfinished, feedback, fromMemo, toolTrace, createdAt, parent, receiptKappa, toolReceiptKappas = [], files = [] }) {
+    const links = [];
+    if (parent) links.push({ ...(await S.uorLink("lc:parentMessage", parent)), "schema:name": "parentMessageId" });
+    if (receiptKappa) links.push({ ...S.contentLink("lc:receipt", receiptKappa, "prov:Activity"), "schema:name": "receipt" });
+    for (const k of toolReceiptKappas) links.push({ ...S.contentLink("lc:toolReceipt", k, "prov:Activity"), "schema:name": "toolReceipt" });
+    for (const f of files) links.push({ ...S.contentLink("schema:associatedMedia", f.kappa, "schema:MediaObject"), "schema:name": f.name });
+    return S.makeObject({
+      type: ["schema:Message", "prov:Entity"], context: [LC],
+      "schema:identifier": messageId || rid("msg"), "lc:conversationId": conversationId,
+      "lc:parentMessageId": (parent && parent["schema:identifier"]) || null,   // the human handle of the parent (for export/tree rebuild)
+      "lc:sender": sender, "lc:isCreatedByUser": !!isCreatedByUser, "lc:model": model || null,
+      "schema:text": text || "", "lc:content": content || null, "lc:tokenCount": tokenCount ?? null,
+      "lc:tokenIds": tokenIds || null, "lc:fromMemo": !!fromMemo,
+      "lc:toolTrace": toolTrace || null,
+      "lc:error": error || null, "lc:unfinished": !!unfinished, "lc:feedback": feedback || null,
+      "schema:dateCreated": createdAt || now(),
+      links,
+    });
+  }
+
+  // Save the conversation κ-object → links to the head (active leaf) + branch tips. Re-sealed each turn.
+  async function saveConversation({ conversationId, title, tags, files, preset, createdAt, headMessage, branchTips = [] }) {
+    const links = [];
+    if (headMessage) links.push({ ...(await S.uorLink("lc:head", headMessage)), "schema:name": "head" });
+    for (const t of branchTips) links.push({ ...(await S.uorLink("lc:branchTip", t)), "schema:name": "tip" });
+    const conv = await S.makeObject({
+      type: ["schema:Conversation", "prov:Collection"], context: [LC],
+      "schema:identifier": conversationId, "schema:name": title || "New Chat",
+      "lc:tags": tags || [], "lc:files": files || [], "lc:preset": preset || null,
+      "schema:dateCreated": createdAt || now(), "schema:dateModified": now(),
+      links,
+    });
+    // update the boot index (pointer-only; the conversation itself is verifiable)
+    const idx = await getIndex();
+    const ptr = { conversationId, kappa: conv.id, title: conv["schema:name"], updatedAt: conv["schema:dateModified"], archived: false, favorite: false, folder: null };
+    const i = idx.conversations.findIndex((c) => c.conversationId === conversationId);
+    if (i >= 0) idx.conversations[i] = { ...idx.conversations[i], ...ptr }; else idx.conversations.unshift(ptr);
+    await putIndex(idx);
+    return conv;
+  }
+
+  async function listConversations() { return (await getIndex()).conversations; }
+  async function updatePointer(conversationId, patch) { const idx = await getIndex(); const i = idx.conversations.findIndex((c) => c.conversationId === conversationId); if (i >= 0) { idx.conversations[i] = { ...idx.conversations[i], ...patch }; await putIndex(idx); } }
+  async function loadConversation(conversationId) {
+    const idx = await getIndex(); const ptr = idx.conversations.find((c) => c.conversationId === conversationId); if (!ptr) return null;
+    const conv = await S.getObj(ptr.kappa); if (!conv) return null;
+    const v = await S.verifyDeep(conv);
+    return { conv, kappa: ptr.kappa, ok: v.ok, integrity: v };
+  }
+  const verifyConversation = async (kappa) => { const conv = await S.getObj(kappa); return conv ? S.verifyDeep(conv) : { ok: false, why: "not found" }; };
+
+  return { store: S, saveReceipt, saveMessage, saveConversation, listConversations, loadConversation, verifyConversation, updatePointer, getIndex, newId: rid };
+}
+
+// A simple Map backend (the witness uses this; the app wraps holo-kstore instead).
+export function mapBackend() {
+  const m = new Map();
+  return {
+    get: async (hex) => m.get(hex),
+    put: async (hex, bytes) => { m.set(hex, bytes); },
+    getRaw: async (k) => m.get(k),
+    putRaw: async (k, bytes) => { m.set(k, bytes); },
+    _map: m,
+  };
+}

core/tools.js

@@ -0,0 +1,112 @@
+// core/tools.js — the agentic TOOL-CALLING loop over the local engine + MCP. Qwen2.5's
+// native function-calling convention: the system turn declares tools as JSON schemas inside
+// a <tools>…</tools> block; the model emits <tool_call>{"name":…,"arguments":…}</tool_call>;
+// each result returns as a user-role <tool_response>…</tool_response> turn and generation
+// continues — until a turn arrives with no tool call (the final answer) or maxRounds hits.
+//
+// Substrate-native: EVERY tool call is sealed as its own PROV-O activity (tool ⊕ args ⊕
+// result, each by κ) and the per-call receipts ride the answer's receipt — a verifiable
+// work-trail for agentic answers, the chat-layer analogue of Holo Orchestrate (ADR-045).
+
+import { didHolo, kappaText, jcs } from "./kappa.js";
+
+// The system turn that arms the model with tools (Qwen2.5 function-calling convention).
+export function toolSystemPrompt(tools, extra = "") {
+  const decls = tools.map((t) => JSON.stringify({ type: "function", function: { name: t.name, description: t.description || "", parameters: t.inputSchema || { type: "object", properties: {} } } })).join("\n");
+  return (
+    (extra ? extra + "\n\n" : "") +
+    "# Tools\n\nYou may call one or more functions to assist with the user query.\n\n" +
+    "You are provided with function signatures within <tools></tools> XML tags:\n<tools>\n" + decls + "\n</tools>\n\n" +
+    "For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n" +
+    '<tool_call>\n{"name": <function-name>, "arguments": <args-json-object>}\n</tool_call>'
+  );
+}
+
+// Parse <tool_call> blocks out of a model turn. Tolerant: bare JSON with name+arguments
+// also counts (small models sometimes drop the tags).
+export function parseToolCalls(text) {
+  const calls = [];
+  const re = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
+  let m;
+  while ((m = re.exec(text))) { try { const j = JSON.parse(m[1]); if (j && j.name) calls.push({ name: j.name, arguments: j.arguments || {} }); } catch {} }
+  // ```json fenced code blocks with {name, arguments} (Qwen2.5-Coder often emits this form)
+  if (!calls.length) {
+    const cb = /```(?:json|tool_call)?\s*(\{[\s\S]*?\})\s*```/g;
+    while ((m = cb.exec(text))) { try { const j = JSON.parse(m[1]); if (j && j.name && ("arguments" in j)) calls.push({ name: j.name, arguments: j.arguments || {} }); } catch {} }
+  }
+  if (!calls.length) {
+    const t = text.trim();
+    if (t.startsWith("{") && t.includes('"name"')) { try { const j = JSON.parse(t); if (j.name && ("arguments" in j)) calls.push({ name: j.name, arguments: j.arguments || {} }); } catch {} }
+  }
+  return calls;
+}
+
+export const stripToolCalls = (text) => text
+  .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "")
+  .replace(/```(?:json|tool_call)?\s*\{[\s\S]*?"name"[\s\S]*?\}\s*```/g, "")   // strip fenced tool calls too
+  .trim();
+
+// Seal one tool call as a PROV-O activity (its own did:holo — tamper → refuse).
+export async function sealToolReceipt({ server, tool, args, resultText, ok }) {
+  const body = {
+    "@context": ["http://www.w3.org/ns/prov#", { holo: "https://hologram.os/ns/q#" }],
+    "@type": "prov:Activity", "holo:kind": "tool-call",
+    "prov:used": { "holo:server": server, "holo:tool": tool, "holo:args": await didHolo(JSON.parse(jcs(args || {}))), "holo:argsJson": jcs(args || {}) },
+    "prov:generated": { "holo:result": await kappaText(resultText), "holo:ok": !!ok },
+  };
+  return { id: await didHolo(body), body };
+}
+
+// Frame the agentic first turn: system(tools) + user prompt (ChatML, by hand so the system
+// block rides this turn). Exposed so the caller can persist the EXACT ids that run (the
+// ctx-concat invariant of the message tree).
+export function frameAgenticTurn({ tools, promptText, hasHistory, extraSystem = "" }) {
+  const sys = toolSystemPrompt(tools.map((t) => t.def), extraSystem);
+  return (hasHistory ? "<|im_end|>\n" : "") +
+    `<|im_start|>system\n${sys}<|im_end|>\n<|im_start|>user\n${promptText}<|im_end|>\n<|im_start|>assistant\n`;
+}
+
+// The loop. `callbacks.onToolCall({name,args})` / `onToolResult({name,text,receipt})` let the
+// UI stream the work-trail live. Returns { text, rounds, toolReceipts, trace, ids }.
+export async function runToolLoop({ engine, tools, promptText, ctxIds, firstFramed, signal, onToken, onToolCall, onToolResult, maxRounds = 4 }) {
+  const toolReceipts = []; const trace = [];
+  let framed = firstFramed || frameAgenticTurn({ tools, promptText, hasHistory: ctxIds.length > 0 });
+  let ids = ctxIds.slice();
+  let finalText = "", rounds = 0;
+
+  for (; rounds < maxRounds; rounds++) {
+    const turnIds = engine.tokenize(framed);
+    ids = ids.concat(turnIds);
+    // tight per-round budget: a tool_call is ~50 tokens, a final answer ~300 — snappy rounds,
+    // the same total work, far lower latency than letting one round run the whole cap.
+    // generous budget: tool calls that carry CODE (write_file, build_app) need room — a truncated
+    // call is invalid JSON and silently fails. 1536 fits a small app; plain rounds end early on EOS.
+    const res = await engine.generate(ids, { signal, onToken, maxNew: 1536 });
+    ids = res.ids;
+    const calls = parseToolCalls(res.text);
+    if (!calls.length || (signal && signal.aborted)) { finalText = stripToolCalls(res.text); break; }
+
+    // execute every call this round through MCP, seal a receipt each
+    const responses = [];
+    for (const c of calls) {
+      if (signal && signal.aborted) break;
+      const t = tools.find((x) => x.def.name === c.name);
+      onToolCall && onToolCall({ name: c.name, args: c.arguments, server: t ? t.serverName : "?" });
+      let text, ok = true, render = null;
+      try {
+        if (!t) throw new Error("unknown tool: " + c.name);
+        const r = await t.call(c.arguments);
+        text = r.text; ok = !r.isError; render = r.render || null;   // build_app → live preview payload
+      } catch (e) { text = "ERROR: " + (e && e.message || e); ok = false; }
+      const receipt = await sealToolReceipt({ server: t ? t.serverName : "?", tool: c.name, args: c.arguments, resultText: text, ok });
+      toolReceipts.push(receipt);
+      trace.push({ name: c.name, args: c.arguments, text: text.slice(0, 4000), ok, receiptId: receipt.id, server: t ? t.serverName : "?" });
+      onToolResult && onToolResult({ name: c.name, text, ok, receipt, render });
+      responses.push(`<tool_response>\n${text.slice(0, 2400)}\n</tool_response>`);   // bounded — tool output must fit the local context window
+    }
+    // feed results back (user role per the Qwen convention) and continue
+    framed = `<|im_end|>\n<|im_start|>user\n${responses.join("\n")}<|im_end|>\n<|im_start|>assistant\n`;
+    finalText = stripToolCalls(res.text);   // best-so-far, replaced if a later round answers
+  }
+  return { text: finalText, rounds: rounds + 1, toolReceipts, trace, ids };
+}

forge/gguf-forge-iq-dequant.mjs

@@ -0,0 +1,260 @@
+// IQ-quant dequantization, transcribed line-for-line from ggml-quants.c
+// (llama.cpp b7248): dequantize_row_iq2_xxs:3077 iq2_xs:3105 iq2_s:3132
+// iq3_xxs:3164 iq3_s:3196 iq1_s:3239 iq1_m:3264 iq4_nl:3314 iq4_xs:3332.
+// Block layouts: ggml-common.h:485-563.
+//
+// ONE source of truth, two behaviours: makeIQ(fr, f16ToF32) binds the rounding
+// function. The Tier-A oracle passes Math.fround (binary32-exact, witnessed
+// bit-for-bit vs ggml to_float in gguf-forge-iq.test.mjs); the runtime passes
+// identity (float64, fine for the GPU engine which re-quantizes anyway).
+//
+// Codebook grids are flattened little-endian byte runs (gguf-forge-iq-grids.mjs):
+// an entry `idx` of stride S occupies bytes [idx*S .. idx*S+S). iq2*/iq3* read
+// uint8, iq1s_grid / kvalues_iq4nl read int8.
+
+import {
+  iq2xxs_grid, iq2xs_grid, iq2s_grid, iq3xxs_grid, iq3s_grid, iq1s_grid,
+  ksigns_iq2xs, kmask_iq2xs, kvalues_iq4nl,
+} from "./gguf-forge-iq-grids.mjs";
+
+const QK_K = 256;
+const IQ1S_DELTA = 0.125, IQ1M_DELTA = 0.125;
+const s8 = (b) => (b << 24) >> 24; // uint8 -> int8
+
+export function makeIQ(fr, f16ToF32) {
+  const sign1 = (signs, j) => (signs & kmask_iq2xs[j] ? -1 : 1);
+
+  // dequantize_row_iq2_xxs (:3077). Block 66 B: d:f16 qs:uint16[32].
+  function dequantIQ2XXS(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 66, qs = bp + 2;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      for (let ib32 = 0; ib32 < QK_K / 32; ++ib32) {
+        const a0 = dv.getUint32(qs + 8 * ib32, true), a1 = dv.getUint32(qs + 8 * ib32 + 4, true);
+        const db = fr(fr(d * fr(0.5 + (a1 >>> 28))) * 0.25);
+        for (let l = 0; l < 4; ++l) {
+          const idx = (a0 >>> (8 * l)) & 0xff;
+          const signs = ksigns_iq2xs[(a1 >>> (7 * l)) & 127];
+          for (let j = 0; j < 8; ++j) out[o++] = sign1(signs, j) * fr(db * iq2xxs_grid[idx * 8 + j]);
+        }
+      }
+    }
+    return out;
+  }
+
+  // dequantize_row_iq2_xs (:3105). Block 74 B: d:f16 qs:uint16[32] scales:uint8[8].
+  function dequantIQ2XS(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 74, qs = bp + 2, scB = bp + 66;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      for (let ib32 = 0; ib32 < QK_K / 32; ++ib32) {
+        const db = [fr(fr(d * fr(0.5 + (raw[scB + ib32] & 0xf))) * 0.25),
+                    fr(fr(d * fr(0.5 + (raw[scB + ib32] >> 4))) * 0.25)];
+        for (let l = 0; l < 4; ++l) {
+          const q = dv.getUint16(qs + (4 * ib32 + l) * 2, true);
+          const idx = q & 511, signs = ksigns_iq2xs[q >> 9], dl = db[l >> 1];
+          for (let j = 0; j < 8; ++j) out[o++] = sign1(signs, j) * fr(dl * iq2xs_grid[idx * 8 + j]);
+        }
+      }
+    }
+    return out;
+  }
+
+  // dequantize_row_iq2_s (:3132). Block 82 B: d:f16 qs:uint8[64] qh:uint8[8] scales:uint8[8].
+  //   signs = qs + 32 (second half of qs); idx = qs[l] | ((qh[ib32]<<(8-2l)) & 0x300).
+  function dequantIQ2S(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 82, qhB = bp + 66, scB = bp + 74;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      let qs = bp + 2, signs = bp + 2 + 32;
+      for (let ib32 = 0; ib32 < QK_K / 32; ++ib32) {
+        const db = [fr(fr(d * fr(0.5 + (raw[scB + ib32] & 0xf))) * 0.25),
+                    fr(fr(d * fr(0.5 + (raw[scB + ib32] >> 4))) * 0.25)];
+        for (let l = 0; l < 4; ++l) {
+          const dl = db[l >> 1];
+          const idx = raw[qs + l] | (((raw[qhB + ib32] << (8 - 2 * l)) & 0x300));
+          for (let j = 0; j < 8; ++j) out[o++] = sign1(raw[signs + l], j) * fr(dl * iq2s_grid[idx * 8 + j]);
+        }
+        qs += 4; signs += 4;
+      }
+    }
+    return out;
+  }
+
+  // dequantize_row_iq3_xxs (:3164). Block 98 B: d:f16 qs:uint8[96].
+  //   qs[0..63]=grid idx; scales_and_signs = qs+64 (8 uint32). db scale uses *0.5.
+  function dequantIQ3XXS(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 98, ss = bp + 2 + 64;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      let qs = bp + 2;
+      for (let ib32 = 0; ib32 < QK_K / 32; ++ib32) {
+        const a32 = dv.getUint32(ss + 4 * ib32, true);
+        const db = fr(fr(d * fr(0.5 + (a32 >>> 28))) * 0.5);
+        for (let l = 0; l < 4; ++l) {
+          const signs = ksigns_iq2xs[(a32 >>> (7 * l)) & 127];
+          const g1 = raw[qs + 2 * l] * 4, g2 = raw[qs + 2 * l + 1] * 4;
+          for (let j = 0; j < 4; ++j) {
+            out[o + j + 0] = sign1(signs, j + 0) * fr(db * iq3xxs_grid[g1 + j]);
+            out[o + j + 4] = sign1(signs, j + 4) * fr(db * iq3xxs_grid[g2 + j]);
+          }
+          o += 8;
+        }
+        qs += 8;
+      }
+    }
+    return out;
+  }
+
+  // dequantize_row_iq3_s (:3196). Block 110 B: d:f16 qs:uint8[64] qh:uint8[8] signs:uint8[32] scales:uint8[4].
+  function dequantIQ3S(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 110, scB = bp + 106;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      let qs = bp + 2, qh = bp + 66, signs = bp + 74;
+      for (let ib32 = 0; ib32 < QK_K / 32; ib32 += 2) {
+        const db1 = fr(d * (1 + 2 * (raw[scB + (ib32 >> 1)] & 0xf)));
+        const db2 = fr(d * (1 + 2 * (raw[scB + (ib32 >> 1)] >> 4)));
+        for (let l = 0; l < 4; ++l) {
+          const g1 = (raw[qs + 2 * l] | ((raw[qh] << (8 - 2 * l)) & 256)) * 4;
+          const g2 = (raw[qs + 2 * l + 1] | ((raw[qh] << (7 - 2 * l)) & 256)) * 4;
+          for (let j = 0; j < 4; ++j) {
+            out[o + j + 0] = sign1(raw[signs + l], j + 0) * fr(db1 * iq3s_grid[g1 + j]);
+            out[o + j + 4] = sign1(raw[signs + l], j + 4) * fr(db1 * iq3s_grid[g2 + j]);
+          }
+          o += 8;
+        }
+        qs += 8; signs += 4;
+        for (let l = 0; l < 4; ++l) {
+          const g1 = (raw[qs + 2 * l] | ((raw[qh + 1] << (8 - 2 * l)) & 256)) * 4;
+          const g2 = (raw[qs + 2 * l + 1] | ((raw[qh + 1] << (7 - 2 * l)) & 256)) * 4;
+          for (let j = 0; j < 4; ++j) {
+            out[o + j + 0] = sign1(raw[signs + l], j + 0) * fr(db2 * iq3s_grid[g1 + j]);
+            out[o + j + 4] = sign1(raw[signs + l], j + 4) * fr(db2 * iq3s_grid[g2 + j]);
+          }
+          o += 8;
+        }
+        qh += 2; qs += 8; signs += 4;
+      }
+    }
+    return out;
+  }
+
+  // dequantize_row_iq1_s (:3239). Block 50 B: d:f16 qs:uint8[32] qh:uint16[8]. grid int8.
+  function dequantIQ1S(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 50, qhB = bp + 34;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      let qs = bp + 2;
+      for (let ib = 0; ib < QK_K / 32; ++ib) {
+        const qh = dv.getUint16(qhB + 2 * ib, true);
+        const dl = fr(d * (2 * ((qh >> 12) & 7) + 1));
+        const delta = (qh & 0x8000) ? -IQ1S_DELTA : IQ1S_DELTA;
+        for (let l = 0; l < 4; ++l) {
+          const g = (raw[qs + l] | (((qh >> (3 * l)) & 7) << 8)) * 8;
+          for (let j = 0; j < 8; ++j) out[o++] = fr(dl * fr(s8(iq1s_grid[g + j]) + delta));
+        }
+        qs += 4;
+      }
+    }
+    return out;
+  }
+
+  // dequantize_row_iq1_m (:3264). Block 56 B: qs:uint8[32] qh:uint8[16] scales:uint8[8].
+  //   No d field — f16 scale is woven from the four scale uint16s. grid int8.
+  function dequantIQ1M(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    const delta = new Float32Array(4), idx = new Uint16Array(4);
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 56, scB = bp + 48;
+      const sc = [dv.getUint16(scB, true), dv.getUint16(scB + 2, true), dv.getUint16(scB + 4, true), dv.getUint16(scB + 6, true)];
+      const u16 = (sc[0] >> 12) | ((sc[1] >> 8) & 0x00f0) | ((sc[2] >> 4) & 0x0f00) | (sc[3] & 0xf000);
+      const d = f16ToF32(u16);
+      let qs = bp, qh = bp + 32;
+      for (let ib = 0; ib < QK_K / 32; ++ib) {
+        const dl1 = fr(d * (2 * ((sc[ib >> 1] >> (6 * (ib % 2) + 0)) & 0x7) + 1));
+        const dl2 = fr(d * (2 * ((sc[ib >> 1] >> (6 * (ib % 2) + 3)) & 0x7) + 1));
+        idx[0] = raw[qs + 0] | ((raw[qh + 0] << 8) & 0x700);
+        idx[1] = raw[qs + 1] | ((raw[qh + 0] << 4) & 0x700);
+        idx[2] = raw[qs + 2] | ((raw[qh + 1] << 8) & 0x700);
+        idx[3] = raw[qs + 3] | ((raw[qh + 1] << 4) & 0x700);
+        delta[0] = raw[qh + 0] & 0x08 ? -IQ1M_DELTA : IQ1M_DELTA;
+        delta[1] = raw[qh + 0] & 0x80 ? -IQ1M_DELTA : IQ1M_DELTA;
+        delta[2] = raw[qh + 1] & 0x08 ? -IQ1M_DELTA : IQ1M_DELTA;
+        delta[3] = raw[qh + 1] & 0x80 ? -IQ1M_DELTA : IQ1M_DELTA;
+        for (let l = 0; l < 2; ++l) {
+          const g = idx[l] * 8;
+          for (let j = 0; j < 8; ++j) out[o++] = fr(dl1 * fr(s8(iq1s_grid[g + j]) + delta[l]));
+        }
+        for (let l = 2; l < 4; ++l) {
+          const g = idx[l] * 8;
+          for (let j = 0; j < 8; ++j) out[o++] = fr(dl2 * fr(s8(iq1s_grid[g + j]) + delta[l]));
+        }
+        qs += 4; qh += 2;
+      }
+    }
+    return out;
+  }
+
+  // dequantize_row_iq4_nl (:3314). Block 18 B / 32 elems: d:f16 qs:uint8[16]. kvalues int8.
+  function dequantIQ4NL(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / 32; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 18, qs = bp + 2;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      for (let j = 0; j < 16; ++j) {
+        out[o + j] = fr(d * s8(kvalues_iq4nl[raw[qs + j] & 0xf]));
+        out[o + 16 + j] = fr(d * s8(kvalues_iq4nl[raw[qs + j] >> 4]));
+      }
+      o += 32;
+    }
+    return out;
+  }
+
+  // dequantize_row_iq4_xs (:3332). Block 136 B: d:f16 scales_h:uint16 scales_l:uint8[4] qs:uint8[128].
+  function dequantIQ4XS(raw, elements) {
+    const out = new Float32Array(elements);
+    const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+    const nb = elements / QK_K; let o = 0;
+    for (let i = 0; i < nb; i++) {
+      const bp = i * 136, slB = bp + 4;
+      const d = f16ToF32(dv.getUint16(bp, true));
+      const sh = dv.getUint16(bp + 2, true);
+      let qs = bp + 8;
+      for (let ib = 0; ib < QK_K / 32; ++ib) {
+        const ls = ((raw[slB + (ib >> 1)] >> (4 * (ib % 2))) & 0xf) | (((sh >> (2 * ib)) & 3) << 4);
+        const dl = fr(d * (ls - 32));
+        for (let j = 0; j < 16; ++j) {
+          out[o + j] = fr(dl * s8(kvalues_iq4nl[raw[qs + j] & 0xf]));
+          out[o + 16 + j] = fr(dl * s8(kvalues_iq4nl[raw[qs + j] >> 4]));
+        }
+        o += 32; qs += 16;
+      }
+    }
+    return out;
+  }
+
+  return { dequantIQ2XXS, dequantIQ2XS, dequantIQ2S, dequantIQ3XXS, dequantIQ3S, dequantIQ1S, dequantIQ1M, dequantIQ4NL, dequantIQ4XS };
+}

forge/gguf-forge-iq-grids.mjs

@@ -0,0 +1,14 @@
+// AUTO-GENERATED by gen-iq-grids.mjs from ggml-common.h — do not edit by hand.
+// IQ-quant codebook grids + helper tables, flattened to little-endian byte runs.
+// A grid entry `idx` of stride S occupies bytes [idx*S .. idx*S+S); read uint8
+// for iq2*/iq3* grids, int8 (`(b<<24)>>24`) for iq1s_grid / kvalues_iq4nl.
+const D = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
+export const iq2xxs_grid = /* 2048B */ D("CAgICAgICAgrCAgICAgICBkZCAgICAgICCsICAgICAgrKwgICAgICBkIGQgICAgICBkZCAgICAgICCsICAgICCsIKwgICAgICCsrCAgICAgrKysICAgICBkICBkICAgICBkIGQgICAgICBkZCAgICAgrGRkICAgIGQgrGQgICAgIGSsZCAgICAgICCsICAgIKwgIKwgICAgrKwgrCAgICCsIKysICAgIGQgICBkICAgIGQgIGQgICAgIGQgZCAgIGRkZCBkICAgICAgZGQgICAgZCCsZCAgICCsZKxkICAgICAgIKwgICCsICAgrCAgIKwgrCCsICAgrCAgrKwgICBkICAgIGQgICBkICAgZCAgICBkICBkICBkIKwgIGQgICBkrCAgZCAgICAgZCBkICCsICBkIGQgICCsIGQgZCAgICCsZCBkICBkICCsIGQgICBkIKwgZCAgICBkrCBkICAgZKysIGQgICAgICBkZCAgrCAgIGRkICAgrCAgZGQgICAgrCBkZCAgrGQgZGRkICBkrKxkZGQgICAgIKxkZCAgZCBkrGRkICBkrCAgrGQgICAgZCCsZCAgICAgZKxkICAgZCCsrGQgICBkrKysZCAgICAgICCsICBkZCAgIKwgICCsICAgrCAgIGRkICCsICAgrKwgIKwgIGQgIGQgrCAgIGQgZCCsICAgIGRkIKwgIKwgZGQgrCAgIKwgrCCsICAgZCAgZKwgICAgIGRkrCAgrCAgIKysICAgZGQgrKwgIGQgICAgIGQgIGQgICAgZCAgIGQgICBkIGQgrCAgIGQgICAgZCAgZCAgIKxkICBkICBkIKwgIGQgICBkrCAgZCBkZGSsICBkICAgICBkIGQgIKwgIGQgZCAgIKwgZCBkICAgZGRkIGQgrKxkZGQgZCAgICCsZCBkICBkrCCsIGQgZGQgZKwgZCAgICAgIGRkICCsICAgZGQgICCsICBkZCBkZKwgIGRkIGSsIGQgZGQgICAgrCBkZCAgrGQgZGRkIKwgrGRkZGQgICAgIKxkZCCsZGQgrGRkIGQgICAgrGQgIGQgICCsZCAgIGQgIKxkICAgIGQgrGQgZCAgrCCsZCAgICAgZKxkIGRkICBkrGQgICCsrGSsZCBkIGRkrKxkICAgICAgIKwgrCAgICAgrCCsrCAgICCsICBkIGQgIKwgZCCsZCAgrCAgICCsICCsIKwgIKwgIKwgZKysIGQgrCAgrCBkZCCsICAgICCsIKwgrCAgIKwgrCBkICAgIGSsICBkICAgZKwgICBkICBkrCAgICBkIGSsIKxkZGQgZKwgICAgIGRkrCBkICBkZGSsICBkrGRkZKwgICBkrKxkrCAgrCAgIKysICAgrCAgrKwgIGRkrCCsrCAgZCBkrKysIGQgICAgICBkIGQgICAgIGQgIGQgICAgZCCsZCAgICBkZCCsICAgIGQgZKwgICAgZCAgIGQgICBkIKwgZCAgIGSsZGRkICAgZCAgrGQgICBkZCAgrCAgIGQgZCCsICAgZCAgZKwgICBkICAgIGQgIGQgIKwgZCAgZGQgrGRkICBkICAgrGQgIGRkZCCsZCAgZGQgICCsICBkICBkIKwgIGQgrCBkrCAgZKxkZGSsICBkIKysZKwgIGQgICAgIGQgZCCsICAgZCBkICCsICBkIGQgICCsIGQgZGSsZKwgZCBkrCBkIGRkIGQgZKwgZGQgZCAgICCsZCBkZCAgICCsIGQgZCAgIKwgZCAgZCAgrCBkICAgZCCsIGRkZCBkIKwgZCAgICBkrCBkIKxkZGSsIGRkIKxkZKwgZKwgIKxkrCBkZGQgZKysIGQgIGSsrKwgZCAgICAgIGRkIKwgICAgZGRkIGQgICBkZGSsZCAgIGRkICCsICAgZGQgICCsICBkZCCsIKwgIGRkIGQgIGQgZGSsICBkZCBkZCBkrKxkIGRkZCBkrKwgZGQgIGSsIGRkZKwgZKwgZGRkrKwgIGRkZGRkICAgrGRkZCBkZGSsZGRkICAgICCsZGRkIGQgIKxkZGSsZCAgrGRkIGSsZCCsZGQgICBkZKxkZCCsICCsrGRkIGQgICAgrGQgIGQgICCsZCAgIGQgIKxkIKysZCAgrGQgICAgZCCsZGRkZGRkIKxkIKxkIKwgrGQgIKxkrCCsZCAgICAgZKxkZGQgICBkrGQgIGQgZGSsZKwgZCBkZKxkIGQgrGRkrGSsICBkIKysZCAgICAgICCsrCAgICAgIKysrCAgICAgrGQgIGQgICCsrCAgrCAgIKwgZCAgZCAgrCCsZCBkICCsICAgZGQgIKxkIGQgrCAgrGQgICAgZCCsIGQgICBkIKwgIGQgIGQgrGRkZCAgZCCsICAgZCBkIKwgIKxkIGQgrCAgICBkZCCsrGQgZGRkIKwgZGSsZGQgrGSsICCsZCCsICAgZKxkIKwgIKxkrGQgrKwgICAgrCCsIGQgIGSsIKxkIGQgrKwgrCBkICAgIGSsICBkICAgZKwgZKwgICBkrCAgIGQgIGSsZCCsrCAgZKysZGQgZCBkrCAgIKxkIGSsZGQgZKwgZKwgICAgIGRkrKwgrCAgZGSsIGQgZCBkZKxkIGRkZGRkrGQgIKwgrGSsICCsIGSsZKysICAgICCsrCAgZGQgIKysZGQgrCAgrKxkrCAgZCCsrCAgICCsIKysIKxkICBkrKwgIGRkIKysrCBkICBkrKys=");
+export const iq2xs_grid = /* 4096B */ D("CAgICAgICAgrCAgICAgICBkZCAgICAgICCsICAgICAgrKwgICAgICBkIGQgICAgICBkZCAgICAgrGRkICAgICBkrGQgICAgICAgrCAgICAgrCCsICAgICBkZKwgICAgICCsrCAgICAgZCAgZCAgICAgZCBkICAgIKxkIGQgICAgZKwgZCAgICAgIGRkICAgIKwgZGQgICAgZGRkZCAgICAgrGRkICAgIGQgrGQgICAgIGSsZCAgICAgICCsICAgIKwgIKwgICAgZGQgrCAgICAgrCCsICAgIGQgZKwgICAgIGRkrCAgICBkrGSsICAgICAgrKwgICAgZCAgIGQgICAgZCAgZCAgIKxkICBkICAgZKwgIGQgICAgIGQgZCAgIKwgZCBkICAgZGRkIGQgICAgrGQgZCAgIKysZCBkICAgZCCsIGQgICAgZKwgZCAgICAgIGRkICAgrCAgZGQgICBkZCBkZCAgICCsIGRkICAgZCBkZGQgICAgZGRkZCAgICAgrGRkICAgIKysZGQgICBkICCsZCAgICBkIKxkICAgICBkrGQgICAgICAgrCAgIKwgICCsICAgZGQgIKwgICAgrCAgrCAgIGQgZCCsICAgIGRkIKwgICAgIKwgrCAgIGQgIGSsICAgIGQgZKwgICAgIGRkrCAgIGRkZGSsICAgICAgrKwgICCsrCCsrCAgIGQgICAgZCAgIGQgICBkICCsZCAgIGQgIGSsICAgZCAgICBkICBkICCsIGQgIGQgIGRkZCAgZCAgIKxkICBkICBkIKwgIGQgICBkrCAgZCAgICAgZCBkICCsICBkIGQgIGRkIGQgZCAgIKwgZCBkICBkIGRkIGQgICBkZGQgZCAgrGRkZCBkICAgIKxkIGQgIGQgIKwgZCAgIGQgrCBkICAgIGSsIGQgICAgICBkZCAgrCAgIGRkICBkZCAgZGQgICCsICBkZCAgZCBkIGRkICAgZGQgZGQgICAgrCBkZCAgZCAgZGRkICAgZCBkZGQgICAgZGRkZCAgZCCsZGRkICAgICCsZGQgIGQgICCsZCAgIGQgIKxkICAgIGQgrGQgIKxkrCCsZCAgICAgZKxkICCsICBkrGQgICBkIKysZCAgICAgICCsICCsICAgIKwgIGRkICAgrCAgIKwgICCsICCsrCAgIKwgIGQgZCAgrCAgIGRkICCsICAgIKwgIKwgIGRkrCAgrCAgZCAgZCCsICAgZCBkIKwgICAgZGQgrCAgIKxkZCCsICAgICCsIKwgICAgrKwgrCAgrKysrCCsICBkICAgZKwgICBkICBkrCAgICBkIGSsICAgICBkZKwgIGQgIKxkrCAgZKwgrGSsICAgICAgrKwgICAgrCCsrCAgIKysIKysICCsZGSsrKwgICAgrKysrCAgZCAgICAgZCAgZCAgICBkIKxkICAgIGQgZKwgICAgZCAgIGQgICBkIKwgZCAgIGQgZGRkICAgZCAgrGQgICBkIGQgrCAgIGQgIGSsICAgZCAgICBkICBkIKwgIGQgIGQgZGQgZCAgZCAgrCBkICBkIGQgZGQgIGQgIGRkZCAgZCAgIKxkICBkIKysrGQgIGQgZCAgrCAgZCAgZCCsICBkICAgZKwgIGQgICAgIGQgZCCsICAgZCBkIGRkICBkIGQgIKwgIGQgZCBkIGQgZCBkICBkZCBkIGQgICCsIGQgZCBkICBkZCBkICBkIGRkIGQgICBkZGQgZCAgICCsZCBkICBkZKxkIGQgrGRkrGQgZCBkICAgrCBkICBkICCsIGQgrGQgIKwgZCAgIGQgrCBkICAgIGSsIGQgICCsZKwgZCAgICAgIGRkIKwgICAgZGQgZGQgICBkZCAgrCAgIGRkIGQgZCAgZGQgIGRkICBkZCAgIKwgIGRkIGQgIGQgZGQgIGQgZCBkZCBkrCBkIGRkICAgZGQgZGQgIGSsZCBkZCAgICCsIGRkIGQgICBkZGQgIGQgIGRkZCAgIGQgZGRkICAgIGRkZGQgICAgIKxkZCAgZGQgrGRkIGSsIGSsZGQgZCAgICCsZCAgZCAgIKxkICAgZCAgrGQgrCBkICCsZCAgICBkIKxkICBkZGQgrGQgrGQgrCCsZCAgICAgZKxkIGRkICBkrGQgrGSsZGSsZCBkIGRkrKxkIGSsrKysrGQgICAgICAgrCCsICAgICCsIGRkICAgIKwgIKwgICAgrCCsrCAgICCsIGQgZCAgIKwgIGRkICAgrCAgIKwgICCsIGQgIGQgIKwgIGQgZCAgrCAgIGRkICCsICAgIKwgIKwgICCsrCAgrCBkICAgZCCsICBkICBkIKwgICBkIGQgrCAgICBkZCCsICCsIGRkIKwgZGSsZGQgrCAgICAgrCCsIKwgrCCsIKwgICAgrKwgrCAgrKysrCCsIGQgICAgZKwgIGQgICBkrCAgIGQgIGSsIGSsrCAgZKwgICAgZCBkrCAgICAgZGSsIGQgIGRkZKwgrCBkZGRkrCBkrGSsZGSsIGQgICCsZKwgrKxkIKxkrCCsZKysrGSsICAgICAgrKwgIKwgICCsrCCsrCAgIKysICAgrCAgrKwgZGRkZCCsrCAgrCCsIKysIKwgrKwgrKwgIKysZGSsrCAgIGSsZKysICCsICCsrKwgICCsIKysrCCsICCsrKysICCsIKysrKwgrKwgrKysrCBkICAgICAgZCBkICAgICBkrGQgICAgIGRkrCAgICAgZCAgZCAgICBkrCBkICAgIGRkZGQgICAgZCCsZCAgICBkZCCsICAgIGQgZKwgICAgZCAgIGQgICBkrCAgZCAgIGRkZCBkICAgZCCsIGQgICBkrKwgZCAgIGRkIGRkICAgZCBkZGQgICBkICCsZCAgIGRkZKxkICAgZGQgIKwgICBkIGQgrCAgIGQgIGSsICAgZCAgICBkICBkrCAgIGQgIGRkZCAgZCAgZCCsICBkICBkZCBkIGQgIGQgZGQgZCAgZCAgrCBkICBkZCAgZGQgIGQgZCBkZCAgZCAgZGRkICBkICAgrGQgIGRkZCCsZCAgZKwgrKxkICBkZCAgIKwgIGQgZCAgrCAgZCAgZCCsICBkrCBkIKwgIGRkrKwgrCAgZCAgIGSsICBkICAgICBkIGSsICAgIGQgZGRkICAgZCBkIKwgICBkIGRkIGQgIGQgZCBkZCAgZCBkZKxkICBkIGQgIKwgIGQgZGQgIGQgZCBkIGQgZCBkIGQgIGRkIGQgZCAgIKwgZCBkIGRkrCBkIGRkICAgZGQgZCBkICBkZCBkICBkIGRkIGQgZKwgZGQgZCAgIGRkZCBkrKxkrGRkIGQgICAgrGQgZKysICCsZCBkIGQgZKxkIGQgIGRkrGQgZGQgICAgrCBkIGQgICCsIGQgIGQgIKwgZCAgIGQgrCBkZGQgZCCsIGQgZGRkIKwgZKwgrGQgrCBkICAgIGSsIGRkIGQgZKwgZCBkIGRkrCBkICBkZGSsIGRkrKxkZKwgZCBkICCsrCBkICAgICAgZGSsICAgICBkZGRkICAgIGRkIKwgICAgZGRkIGQgICBkZCBkZCAgIGRkICCsICAgZGQgrKwgICBkZGQgIGQgIGRkIGQgZCAgZGQgIGRkICBkZCAgIKwgIGRkZCAgIGQgZGQgZCAgZCBkZCAgZCBkIGRkZGRkIGQgZGQgICBkZCBkZKwgIGRkIGRkICAgIKwgZGQgZCBkrCBkZKysrKysIGRkZCAgICBkZGQgZCAgIGRkZCAgZCAgZGRkZCCsICBkZGQgICBkIGRkZCAgrGQgZGRkZCAgrCBkZGRkIKysIGRkZCAgICBkZGRkIKwgIGRkZGQgICCsZGRkZCCsIKxkZGRkZCCsIKxkZGQgrKxkrGRkZGQgrKysZGRkICAgICCsZGQgZGQgIKxkZGQgIGQgrGRkICBkZCCsZGRkrGSsIKxkZKysZCBkrGRkICAgZGSsZGSsICBkZKxkZGRkIKysrGRkZCAgICAgrGQgZCAgICCsZCAgZCAgIKxkICAgZCAgrGQgZGRkICCsZKwgrGQgIKxkrGQgrCAgrGRkrKysICCsZCAgICBkIKxkIGSsIKwgrGSsrCBkrCCsZKwgZKysIKxkICAgICBkrGSsZGQgIGSsZCAgZCBkZKxkICAgZGRkrGRkZCBkZGSsZCBkrKxkZKxkZCAgICCsrGSsrKxkIKysZGRkrCBkrKxkrGQgIKysrGQgZGRkrKysZKwgrGSsrKxkICAgICAgIKysICAgICAgrGRkICAgICCsIKwgICAgIKxkIGQgICAgrCBkZCAgICCsICCsICAgIKysrKwgICAgrGQgIGQgICCsIGQgZCAgIKwgIGRkICAgrCAgIKwgICCsrCAgrCAgIKwgrKysICAgrKysrKwgICCsZCAgIGQgIKwgZCAgZCAgrKxkICBkICCsICBkIGQgIKwgICBkZCAgrGQgZGRkICCsZKxkZGQgIKwgICAgrCAgrCAgrCCsICCsICAgrKwgIKysICCsrCAgrCAgrKysICCsIKysrKwgIKxkICAgIGQgrCBkICAgZCCsICBkICBkIKysIGQgIGQgrGRkZCAgZCCsICAgZCBkIKwgIKxkIGQgrGSsIKwgZCCsICAgIGRkIKwgZCBkZGQgrGRkrKxkZCCsIKxkIKxkIKysrKxkrGQgrCAgICAgrCCsIKwgICCsIKxkZKwgIKwgrKysZGQgrCCsICAgrCCsIKysICCsIKwgrCCsrKwgrCCsrGQgIGSsIKysIKwgrKwgrCAgIKysrCCsIKwgrKysIKysZGSsrKwgrCCsrKysrCCsZCAgICAgZKwgZCAgICBkrCAgZCAgIGSsICAgZCAgZKysZGRkICBkrCBkIKwgIGSsICAgIGQgZKysIKwgZCBkrCBkrGRkIGSsrGRkZKwgZKxkrCCsrCBkrCAgICAgZGSsZGQgICBkZKwgZCBkIGRkrCAgZGQgZGSsIKxkZCBkZKxkrKwgZGRkrCAgZKxkZGSsrCBkrGRkZKxkICBkrGRkrGQgZGQgrGSsrGSsrCCsZKxkrCBkZKxkrGRkZCCsrGSsICCsZKysZKwgICAgICCsrKwgICAgIKysIKwgICAgrKysrCAgICCsrCAgrCAgIKysrKysICAgrKwgIKysICCsrGQgZGRkIKysZKxkZGQgrKysZKysZCCsrCAgICCsIKysrCAgIKwgrKwgrCAgrCCsrKysrCCsIKysICAgrKwgrKwgIKysrCCsrCAgIGQgZKysZGRkrCBkrKxkZKxkrGSsrCCsZKysZKysrKwgICCsrKwgIKwgIKysrKwgrCAgrKysIKysICCsrKwgIKysIKysrCCsrKwgrKysIGQgIGSsrKwgZCCsZKysrKxkIKxkrKysIKysIKysrKysrKwgrKysrGQgZKysrKysrKysrKysrKw==");
+export const iq2s_grid = /* 8192B */ D("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
+export const iq3xxs_grid = /* 1024B */ D("BAQEBBQEBAQkBAQEDAwEBBwMBAQ+DAQEBBQEBBQUBAQMHAQEFCQEBBw+BAQsPgQEDAQMBBwEDAQEDAwEFAwMBAwUDAQsFAwEBBwMBBQcDAQMJAwEJCwMBAQ+DAQEBBQEFAQUBCQEFAQMDBQEBBQUBBQUFAQMHBQEHBwUBD4cFAQMLBQEPiwUBCw+FAQMBBwEPgQcBAQMHAQUDBwELBQcBAQ+HAQcDCQEPhwkBCQkJAQ+LCQEHD4kBCw+JAQMBCwEPgQsBBQcLAQULCwELBw0BCQ0NAQEDD4EJAw+BDQMPgQcJD4EDDQ+BAwEBAwcBAQMBAwEDBQMBAwMFAQMHBQEDAQcBAwUHAQMJBwEDD4kBAwELAQMBAQMDBQEDAwMDAwMBBQMDBQUDAwMBBQMHAQUDAQMFAwUDBQMDBQUDAQcFAwUPhQMBAQcDBQEHAwEFBwMDBwcDDQkHAw0NBwMDAQkDCwEJAwELCQMBBQsDCQULAw0JCwMDD4sDCwENAwUFD4MBCQ+DAQEBBQUBAQUDAwEFBwMBBQEFAQUFBQEFDQUBBQMHAQUFCQEFAwEDBQcBAwULAQMFAQMDBQUDAwUDBQMFAQcDBQcNAwUPjQMFAQ+DBQEBBQUFAQUFAwMFBQ+DBQUBBQUFBQUFBQ+HBQUBCQUFCwsFBQMBBwUBAwcFCQMHBQEPhwUJD4cFCwcJBQcLCQUHAQsFD4ULBQMJCwUJD4sFAwEPhQcBD4UNAw+FCwkPhQMBAQcBAwEHBQMBBwMFAQcHBQEHAQsBBwsNAQcFD4EHAQEDBwUBAwcBBQMHAwcDBwkJAwcNCQMHAwEFBwcBBQcBAwUHCwUFBwULBQcFD4UHAwMHBwcHBwcBBwkHD4kJBwUPiQcBAQsHDQELBwUFCwcLCwsHCQMNBw0HDQcHDQ0HBwcPhwEND4cJAQEJD4MBCQsHAQkPhwEJBwsBCQ+LAQkJD4MJAQUFCQ+HBQkBCQUJAQ0FCQ0NBQkPgQcJCwkHCQkBCQkDCwkJCQ0JCQsFCwkHCQsJAQ+LCQsBD4kBAw+JBQMPiQEHD4kFAwELAwkBCwEPgQsBAQMLDQEDCw0FAwsLCwMLCQMFCwUHBQsFD4ULBQEHCwcLBwsBAwkLBwUJCw+FCQsFD4kLBQELCwMHCwsBCw0LCQUPiwUJD4sJBQENCQkBDQ0JAQ0JDQENAwUDDQMNAw0PgwUNCQ0FDQEHBw0NBwcNCQkJDQsBCw0FCwsNBwcNDQcBD40DBQ+NBwEBD4sBAQ+PgQEPgQMBD4UHAQ+FCwEPjQUDD4EJAw+FAwUPiwkFD4ULBQ+BAQcPiwMHD4cHBw+BDQcPgwUJD4MJCQ+BAQsPhQELD4kFCw+BBw0Pg==");
+export const iq3s_grid = /* 2048B */ D("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");
+export const iq1s_grid = /* 16384B */ D("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");
+export const ksigns_iq2xs = /* 128B */ D("AIGCA4QFBoeICQqLDI2OD5AREpMUlZYXGJmaG5wdHp+gISKjJKWmJyipqiusLS6vMLGyM7Q1Nre4OTq7PL2+P8BBQsNExcZHSMnKS8xNTs9Q0dJT1FVW19hZWttc3d5fYOHiY+RlZufoaWrrbO3ub/BxcvN09fZ3ePn6e/x9fv8=");
+export const kmask_iq2xs = /* 8B */ D("AQIECBAgQIA=");
+export const kvalues_iq4nl = /* 16B */ D("gZitv8/d6vYBDRkmNUVZcQ==");

holo-delta.mjs

@@ -0,0 +1,156 @@
+// holo-delta.mjs — A2 of the personal-model-zoo plan: family index-delta. A finetune that shares a base's
+// FRAME (see holo-model-frame.mjs) is stored as `base-κ + per-tensor delta`, reconstructed at LOAD (no new
+// kernel — the engine still reads normal quantized weights). Two wins compose:
+//   • FROZEN tensors (identical κ to the base) cost 0 extra bytes — content-addressing dedups them for free.
+//   • CHANGED tensors are stored as a BitDelta (Liu et al. 2024): sign(Δ) at 1 bit/param + one scale α.
+//
+// HONEST storage math (this is where the "5–9×" claim earns or loses): the zoo ratio is driven by the
+// FROZEN-TENSOR FRACTION, not within-tensor sparsity. A LoRA/partial finetune (most tensors frozen) →
+// 10–30×; a FULL finetune (every tensor moves) → only ~3–4× (BitDelta is ~1 bit/param vs a 3–4 bit base).
+// BitDelta is intrinsically lossy (sign+scale captures ~2/π≈64% of a Gaussian delta's energy); its
+// published result is that OUTPUT quality is nonetheless preserved — that must be confirmed by perplexity
+// on a REAL base+finetune pair (the A2 pass-bar gate), which this codec self-test does not run.
+//
+// Pure JS, isomorphic, zero deps. Node self-test sweeps frozen-fraction + reports fidelity and zoo ratio.
+
+import { shareable } from "./holo-model-frame.mjs";
+
+// ── BitDelta codec: Δ = ftW − baseW ; store sign(Δ) (1 bit) + α = mean|Δ| (the L2-optimal ±1 scale). ──
+export function encodeBitDelta(baseW, ftW) {
+  const n = baseW.length, signBits = new Uint8Array((n + 7) >> 3);
+  let absSum = 0;
+  for (let i = 0; i < n; i++) {
+    const d = ftW[i] - baseW[i];
+    if (d >= 0) signBits[i >> 3] |= 1 << (i & 7);   // bit set ⇒ +1
+    absSum += Math.abs(d);
+  }
+  return { kind: "bitdelta", n, alpha: absSum / n, signBits };   // ~1 bit/param + one f32
+}
+
+export function decodeBitDelta(baseW, rec, out) {
+  const n = rec.n, a = rec.alpha, o = out || new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const pos = (rec.signBits[i >> 3] >> (i & 7)) & 1;
+    o[i] = baseW[i] + (pos ? a : -a);
+  }
+  return o;
+}
+
+// fraction of the delta's ENERGY captured by sign+scale (1 = perfect). For a Gaussian Δ this → 2/π ≈ 0.637.
+export function deltaCaptured(baseW, ftW, rec) {
+  const n = rec.n; let num = 0, den = 0;
+  for (let i = 0; i < n; i++) {
+    const d = ftW[i] - baseW[i], pos = (rec.signBits[i >> 3] >> (i & 7)) & 1, r = d - (pos ? rec.alpha : -rec.alpha);
+    num += r * r; den += d * d;
+  }
+  return den ? 1 - num / den : 1;
+}
+
+// ── model-level delta: per tensor, frozen (κ identical) → ref (0 bytes) else bitdelta. Frame-guarded. ──
+// tensors: { name → { kappa, params, baseW?, ftW? } }. baseW/ftW (dequant weights) only needed to encode
+// CHANGED tensors; pass them for changed ones, omit for frozen (κ tells us they're identical).
+export function deltaModel(baseMeta, ftMeta, baseTensors, ftTensors) {
+  if (!shareable(baseMeta, ftMeta)) throw new Error("holo-delta: base and finetune are not in the same frame/arch — cannot delta (see holo-model-frame.shareable)");
+  const records = {}; let frozenParams = 0, changedParams = 0, deltaBytes = 0;
+  for (const name of Object.keys(ftTensors)) {
+    const b = baseTensors[name], f = ftTensors[name];
+    if (b && f.kappa && b.kappa === f.kappa) { records[name] = { kind: "ref", kappa: b.kappa }; frozenParams += f.params || 0; continue; }
+    const rec = encodeBitDelta(f.baseW, f.ftW);
+    records[name] = { kind: "bitdelta", base: b ? b.kappa : null, alpha: rec.alpha, n: rec.n };
+    changedParams += rec.n; deltaBytes += rec.signBits.length + 4;   // bits + α
+  }
+  return { records, stats: { frozenParams, changedParams, deltaBytes, deltaBitsPerChangedParam: changedParams ? (deltaBytes * 8) / changedParams : 0 } };
+}
+
+// ── LOSSLESS byte-delta over stored quantized blocks (the right fit for κ-objects). A base and finetune
+//    tensor share the same packed length (same dims+fmt); store only the differing byte runs. Reconstruction
+//    is byte-identical to the finetune's own block ⇒ perplexity = standalone (NO quality gate). Falls back to
+//    storing the whole block when the diff isn't sparse. This is the default for the family loader. ──
+const _GAP = 8;   // coalesce changed runs separated by ≤_GAP identical bytes (amortizes per-run header)
+export function encodeByteDelta(baseBytes, ftBytes) {
+  if (baseBytes.length !== ftBytes.length) return { kind: "whole", len: ftBytes.length, bytes: ftBytes };
+  const n = ftBytes.length, runs = []; let i = 0, deltaSize = 0;
+  while (i < n) {
+    if (baseBytes[i] === ftBytes[i]) { i++; continue; }
+    let j = i + 1, gap = 0;                                  // extend run, tolerating short identical gaps
+    while (j < n && (baseBytes[j] !== ftBytes[j] || (gap = run_gap(baseBytes, ftBytes, j)) <= _GAP)) { j += gap > 0 ? gap : 1; if (gap > 0) gap = 0; }
+    runs.push({ off: i, bytes: ftBytes.slice(i, j) }); deltaSize += (j - i) + 8;   // bytes + ~8B run header
+    i = j;
+  }
+  if (deltaSize >= n * 0.9) return { kind: "whole", len: n, bytes: ftBytes };   // not sparse enough → store whole
+  return { kind: "bytedelta", len: n, runs };
+}
+function run_gap(a, b, j) { let g = 0; while (j + g < a.length && a[j + g] === b[j + g]) g++; return g; }
+export function applyByteDelta(baseBytes, rec) {
+  if (rec.kind === "whole") return rec.bytes;
+  const out = baseBytes.slice(0, rec.len);
+  for (const r of rec.runs) out.set(r.bytes, r.off);
+  return out;
+}
+export function byteDeltaSize(rec) { return rec.kind === "whole" ? rec.bytes.length : rec.runs.reduce((s, r) => s + r.bytes.length + 8, 0); }
+
+// compact binary (de)serialization for a byte-delta record — what gets gzipped + content-addressed.
+export function serializeDelta(rec) {
+  if (rec.kind === "whole") { const o = new Uint8Array(5 + rec.bytes.length); new DataView(o.buffer).setUint32(1, rec.len); o[0] = 1; o.set(rec.bytes, 5); return o; }
+  let sz = 9; for (const r of rec.runs) sz += 8 + r.bytes.length;
+  const o = new Uint8Array(sz), dv = new DataView(o.buffer); o[0] = 0; dv.setUint32(1, rec.len); dv.setUint32(5, rec.runs.length); let p = 9;
+  for (const r of rec.runs) { dv.setUint32(p, r.off); dv.setUint32(p + 4, r.bytes.length); o.set(r.bytes, p + 8); p += 8 + r.bytes.length; }
+  return o;
+}
+export function parseDelta(u8) {
+  const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength), len = dv.getUint32(1);
+  if (u8[0] === 1) return { kind: "whole", len, bytes: u8.subarray(5) };
+  const nRuns = dv.getUint32(5), runs = []; let p = 9;
+  for (let i = 0; i < nRuns; i++) { const off = dv.getUint32(p), blen = dv.getUint32(p + 4); runs.push({ off, bytes: u8.subarray(p + 8, p + 8 + blen) }); p += 8 + blen; }
+  return { kind: "bytedelta", len, runs };
+}
+
+// zoo storage ratio vs storing N finetunes independently. baseBitsPerParam ≈ 3 (q3) or 4 (q4).
+export function zooRatio({ totalParams, frozenFractionOfParams, N, baseBitsPerParam = 3 }) {
+  const B = baseBitsPerParam, g = 1 - frozenFractionOfParams;   // g = changed fraction
+  const independent = (N + 1) * totalParams * B;
+  const shared = totalParams * B + N * (g * totalParams * 1);   // base + N×(changed params × 1 bit)
+  return independent / shared;
+}
+
+// ── Node self-test: realistic synthetic base + finetunes at varying frozen fractions. ──
+if (typeof process !== "undefined" && process.argv[1] && process.argv[1].endsWith("holo-delta.mjs")) {
+  const n = 1 << 20;                                   // 1M-param tensor
+  const rnd = (() => { let s = 0x2545f491; return () => { s ^= s << 13; s ^= s >>> 17; s ^= s << 5; s >>>= 0; return s / 4294967296; }; })();
+  const gauss = (sig) => { let u = 0, v = 0; while (!u) u = rnd(); while (!v) v = rnd(); return sig * Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v); };
+  const baseW = new Float32Array(n); for (let i = 0; i < n; i++) baseW[i] = gauss(0.02);   // LLM-like weight σ
+
+  console.log("\n— BitDelta fidelity on a CHANGED tensor (Δ ~ Gaussian) —");
+  for (const dsig of [0.002, 0.02]) {
+    const ftW = new Float32Array(n); for (let i = 0; i < n; i++) ftW[i] = baseW[i] + gauss(dsig);
+    const rec = encodeBitDelta(baseW, ftW); const hat = decodeBitDelta(baseW, rec);
+    let relNum = 0, relDen = 0; for (let i = 0; i < n; i++) { const e = ftW[i] - hat[i]; relNum += e * e; relDen += ftW[i] * ftW[i]; }
+    const bpp = (rec.signBits.length + 4) * 8 / n;
+    console.log(`  Δσ=${dsig}: α=${rec.alpha.toExponential(2)}  energy-captured=${(deltaCaptured(baseW, ftW, rec) * 100).toFixed(1)}%  recon ||err||/||ft||=${Math.sqrt(relNum / relDen).toExponential(2)}  ${bpp.toFixed(3)} bits/param`);
+  }
+
+  console.log("\n— zoo storage ratio (base + 50 finetunes) by frozen-tensor fraction —");
+  for (const frozen of [0.0, 0.5, 0.8, 0.9, 0.98]) {
+    const r3 = zooRatio({ totalParams: 2e9, frozenFractionOfParams: frozen, N: 50, baseBitsPerParam: 3 });
+    const r4 = zooRatio({ totalParams: 2e9, frozenFractionOfParams: frozen, N: 50, baseBitsPerParam: 4 });
+    const tag = frozen === 0 ? "full finetune" : frozen >= 0.98 ? "LoRA-ish" : "partial";
+    console.log(`  frozen=${(frozen * 100).toFixed(0).padStart(3)}%  →  ${r3.toFixed(1)}× (q3 base) · ${r4.toFixed(1)}× (q4 base)   [${tag}]`);
+  }
+
+  console.log("\n— lossless byte-delta over a quantized block (reconstruct must be byte-identical) —");
+  for (const changeFrac of [0.02, 0.2, 0.6]) {
+    const blkN = 1 << 20, base = new Uint8Array(blkN); for (let i = 0; i < blkN; i++) base[i] = (rnd() * 256) | 0;
+    const ft = base.slice(); for (let i = 0; i < blkN; i++) if (rnd() < changeFrac) ft[i] = (rnd() * 256) | 0;   // finetune flips a fraction of bytes
+    const rec = encodeByteDelta(base, ft); const back = applyByteDelta(base, rec);
+    let identical = back.length === ft.length; for (let i = 0; identical && i < ft.length; i++) identical = back[i] === ft[i];
+    console.log(`  changed≈${(changeFrac * 100).toFixed(0)}%  → ${rec.kind.padEnd(9)} ${(byteDeltaSize(rec) / 1024).toFixed(0)}KB vs ${(blkN / 1024).toFixed(0)}KB block (${(byteDeltaSize(rec) / blkN).toFixed(2)}×)  reconstruct byte-identical=${identical}`);
+  }
+
+  console.log("\n— frame guard —");
+  const A = { frame: { fingerprint: "x" }, d: 2560, n_layers: 30, ff: 6912, n_heads: 20, n_kv_heads: 5, hd: 128, vocab: 128256 };
+  const Bsame = { ...A }, Bdiff = { ...A, d: 3584 };
+  console.log(`  same frame+arch shareable: ${shareable(A, Bsame)}  ·  different arch shareable: ${shareable(A, Bdiff)}`);
+  // and that deltaModel refuses a mismatched pair
+  try { deltaModel(A, Bdiff, {}, {}); console.log("  ERROR: deltaModel should have refused"); }
+  catch (e) { console.log(`  deltaModel correctly refused mismatch: "${e.message.slice(0, 60)}…"`); }
+}

holo-load-delta.mjs

@@ -0,0 +1,54 @@
+// holo-load-delta.mjs — A2 LOAD wiring. Loads a family finetune stored as `base-κ + delta` (format
+// "holo-delta/1", produced by _delta-build.mjs) and returns the SAME { manifest, fetchTensor, info } shape
+// as holo-load2bit.loadKappaObject — so the GPU engine, KV-cache, and Q's brain loader are UNCHANGED.
+// loadKappaObject delegates here automatically when it sees the holo-delta/1 format (one seam, hidden).
+//
+// Per tensor: ref → the base block (frozen, κ identical, dedup'd in the OPFS store); whole → the stored
+// finetune block; bytedelta → base block + lossless byte-delta. Reconstruction is byte-identical to the
+// finetune's own block ⇒ perplexity = standalone (no quality gate). The win is download/storage.
+//
+// Law L5: base AND delta blocks are each κ-verified (sha256(gz)==κ) before use; both κ are named in the
+// L5-verified delta manifest, so the trust chain holds without re-hashing the reconstruction.
+import { parseDelta, applyByteDelta } from "./holo-delta.mjs";
+import { reshapeTensor, buildEngineManifest } from "./holo-load2bit.mjs";
+
+async function gunzip(u8) { const ds = new DecompressionStream("gzip"); const w = ds.writable.getWriter(); w.write(u8); w.close(); return new Uint8Array(await new Response(ds.readable).arrayBuffer()); }
+const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+const kFile = (k) => String(k).replace(":", "_");   // κ "sha256:<hex>" → block file "sha256_<hex>"
+
+export async function loadDeltaObject(deltaUrl, opts = {}) {
+  const droot = String(deltaUrl).replace(/\/+$/, "");
+  const man = opts.manifest || await (await fetch(droot + "/manifest.json", { cache: "no-store" })).json();
+  const baseRoot = String(opts.baseUrl || man.base?.url || man.base?.dir || "").replace(/\/+$/, "");
+  if (!baseRoot) throw new Error("delta-load: no base location (opts.baseUrl or manifest.base.url)");
+
+  // κ-verified block fetch against a chosen root (base for frozen/base blocks, delta for delta blocks).
+  const getBlock = async (root, kappa) => {
+    const gz = new Uint8Array(await (await fetch(root + "/b/" + kFile(kappa) + ".gz", { cache: "no-store" })).arrayBuffer());
+    const got = "sha256:" + hex(await crypto.subtle.digest("SHA-256", gz));
+    if (got !== kappa) throw new Error("delta-load κ MISMATCH " + String(kappa).slice(0, 24));
+    return gunzip(gz);
+  };
+
+  const normRecs = {};                                   // {name → {N,K,fmt,fp16?,s?}} for the shared manifest builder
+  for (const [name, dr] of Object.entries(man.tensors)) normRecs[name] = dr.meta || {};
+
+  const fetchTensor = async (name) => {
+    const dr = man.tensors[name]; if (!dr) return new Uint8Array(0);
+    let raw;
+    if (dr.kind === "ref") raw = await getBlock(baseRoot, dr.kappa);                                   // frozen
+    else if (dr.kind === "whole") raw = parseDelta(await getBlock(droot, dr.delta)).bytes;             // stored whole
+    else if (dr.kind === "bytedelta") raw = applyByteDelta(await getBlock(baseRoot, dr.base), parseDelta(await getBlock(droot, dr.delta)));
+    else throw new Error("delta-load: unknown record kind " + dr.kind + " for " + name);
+    return reshapeTensor(dr.meta || {}, raw);
+  };
+
+  let e8lutData;   // E₈ LUT (if any) is a frozen base block
+  if (man.e8lut) { const b = await getBlock(baseRoot, man.e8lut.replace(/^did:holo:/, "")); e8lutData = new Float32Array(b.buffer, b.byteOffset, 2048); }
+  const manifest = buildEngineManifest(man, normRecs, e8lutData);
+  // tokenizer is the base's (finetune shares vocab); resolve a relative source against the BASE dir.
+  if (man.source && !/^https?:\/\//.test(man.source)) man.source = baseRoot + "/" + man.source;
+  return { manifest, fetchTensor, info: man };
+}
+
+export default loadDeltaObject;

holo-load2bit.mjs

@@ -0,0 +1,126 @@
+// holo-load2bit.mjs — the LOAD-DIRECT consumer (the "load" half of the 7B infra). Given a pre-compiled
+// 2-bit κ-object (manifest.json + content-addressed b/<κ>.gz blocks, produced by compile2bit.mjs), it builds
+// the engine manifest + a fetchTensor that streams blocks, verifies each by re-deriving its κ (Law L5),
+// gunzips, and hands the engine the weights ALREADY 2-bit — no re-quant at load. The engine reads
+// manifest.preQuantized=true (parts() returns the blocks verbatim) and incoherent=false (LDLQ ⇒ no FWHT).
+// Hosting = serve the κ-object dir from anywhere; the κ-verify makes any mirror untrusted-safe.
+//
+// A family FINETUNE is stored as `base-κ + delta` (format "holo-delta/1"); loadKappaObject detects that and
+// transparently delegates to holo-load-delta.mjs, which reconstructs the finetune's blocks and returns the
+// SAME { manifest, fetchTensor } shape — so the engine, KV-cache, and Q's brain loader need no changes.
+import { f16ToF32 } from "./qvac-ingest.mjs";
+
+async function gunzip(u8) { const ds = new DecompressionStream("gzip"); const w = ds.writable.getWriter(); w.write(u8); w.close(); return new Uint8Array(await new Response(ds.readable).arrayBuffer()); }
+const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+
+// ── PERSISTENT κ-CACHE (the returning-user path): a κ-object's manifest + blocks are content-addressed and
+// IMMUTABLE, so once fetched they can live in the browser's Cache API FOREVER, keyed by their own URL. A
+// returning user then loads Q from local disk — ~0 network, no server (serverless by construction). It is
+// untrusted-safe: every cached block is still L5 re-derived below, so a poisoned cache entry is rejected
+// exactly like a poisoned network body. First visit warms the cache; every visit after is disk-speed. ──
+const KCACHE = "holo-kappa-v1";
+let _persistAsked = false;
+async function _askPersist() {
+  if (_persistAsked) return; _persistAsked = true;                       // once per session: ask the browser NOT to evict the model under storage pressure
+  try { if (navigator.storage && navigator.storage.persist && !(await navigator.storage.persisted())) await navigator.storage.persist(); } catch (e) {}
+}
+// fetch a URL as bytes, disk-cached by URL. cache HIT → no network. MISS → fetch once (no-store bounds the
+// in-flight RAM to one body) then store to disk. All failures fall back to a plain fetch (never block a load).
+const _inflight = new Map();   // URL → in-flight fetch promise, so a parallel prefetch + the engine's read of the
+                               // SAME block share ONE network fetch (never double-download).
+async function cachedBytes(url) {
+  let cache = null;
+  try { cache = await caches.open(KCACHE); const hit = await cache.match(url); if (hit) return new Uint8Array(await hit.arrayBuffer()); } catch (e) { cache = null; }
+  if (_inflight.has(url)) return _inflight.get(url);
+  const p = (async () => {
+    const buf = await (await fetch(url, { cache: "no-store" })).arrayBuffer();
+    if (cache) { try { await cache.put(url, new Response(buf.slice(0), { headers: { "Content-Type": "application/octet-stream" } })); _askPersist(); } catch (e) {} }
+    return new Uint8Array(buf);
+  })();
+  _inflight.set(url, p);
+  try { return await p; } finally { _inflight.delete(url); }
+}
+// FAST FIRST LOAD: warm the whole block cache with bounded concurrency, so the engine's sequential per-tensor
+// reads hit the cache instead of paying one HF round-trip at a time (~1.5 blocks/s → tens of blocks/s over HTTP/2).
+// Fire-and-forget; the engine's getBlock shares any in-flight fetch (no double-download). Cross-origin-CDN safe.
+function prefetchBlocks(baseUrl, kappas, conc = 12) {
+  try {
+    const urls = [...new Set(kappas.filter(Boolean))].map((k) => baseUrl + "/b/" + String(k).replace(":", "_") + ".gz");
+    let i = 0;
+    const worker = async () => { while (i < urls.length) { const u = urls[i++]; try { await cachedBytes(u); } catch (e) {} } };
+    Promise.all(Array.from({ length: Math.min(conc, urls.length) }, worker)).catch(() => {});
+  } catch (e) {}
+}
+
+// reshape a raw (gunzipped) block to what the engine reads. PURE — shared with the delta loader so both
+// paths apply identical per-fmt handling. 2bit+fp16 → 2bit+f32 scales; everything else verbatim.
+export function reshapeTensor(rec, raw) {
+  if (rec.fmt === "2bit" && rec.fp16) {                  // [2-bit packed][fp16 scales] → [2-bit][f32 scales]
+    const Kp = rec.K, q2 = (rec.N * Kp) / 4, nsc = rec.N * (Kp / 32);
+    const f16 = new Uint16Array(raw.buffer, raw.byteOffset + q2, nsc);
+    const out = new Uint8Array(q2 + nsc * 4); out.set(raw.subarray(0, q2), 0);
+    const f32 = new Float32Array(out.buffer, q2, nsc); for (let i = 0; i < nsc; i++) f32[i] = f16ToF32(f16[i]);
+    return out;
+  }
+  return raw;                                            // 2bit+f32 (incoherence), q8 (embed), f32 (norms) — verbatim
+}
+
+// build the engine manifest from model meta + normalized tensor records {name→{N,K,fmt,s?}}. PURE — shared.
+export function buildEngineManifest(man, normRecs, e8lutData) {
+  const tensors = Object.entries(normRecs).map(([name, rec]) => ({ name, N: rec.N, K: rec.K, blk: rec.fmt !== "f32", fmt: rec.fmt, ...(rec.s !== undefined ? { s: rec.s } : {}) }));
+  const native = man.mode === "q4" || man.mode === "q3" || man.mode === "e8" || man.mode === "bitnet";   // native-bits κ-object
+  return {
+    d: man.d, n_heads: man.n_heads, n_kv_heads: man.n_kv_heads, ff: man.ff, vocab: man.vocab, n_layers: man.n_layers, hd: man.hd,
+    bits: native ? man.bits : 8, layout: man.layout, rope_base: man.rope_base, ...(man.maskId !== undefined ? { maskId: man.maskId, diffusion: true } : {}), attn_bias: man.attn_bias, qk_norm: man.qk_norm, qk_norm_dim: man.qk_norm_dim, tied: man.tied,
+    ...(man.sub_norm ? { sub_norm: true } : {}), ...(man.bitlinear ? { bitlinear: true } : {}), ...(man.ffn_act ? { ffn_act: man.ffn_act } : {}), ...(man.moe ? { moe: man.moe } : {}),
+    ...(native ? {} : { twoBit: true, incoherent: man.incoherent === true, preQuantized: true }), tensors, ...(e8lutData ? { e8lutData } : {}),
+  };
+}
+
+export async function loadKappaObject(baseUrl, opts = {}) {
+  // Law L5: the manifest is the ROOT that names every block's κ. Verify the manifest's OWN bytes
+  // re-derive to a pinned κ BEFORE trusting man.tensors[*].kappa — otherwise a tampered manifest can
+  // re-point every block to a forged-but-self-consistent κ and each per-block check passes against the
+  // forgery. The pin is an EXTERNAL anchor (catalog/lock), never the manifest's own self-asserted root.
+  const manRaw = await cachedBytes(baseUrl + "/manifest.json");   // disk-cached (pinned + verified below), so a returning user's load is 0-network end to end
+  const manKappa = "sha256:" + hex(await crypto.subtle.digest("SHA-256", manRaw));
+  const pin = opts.expectKappa ? String(opts.expectKappa).replace(/^did:holo:/, "") : null;
+  if (pin) { if (manKappa !== pin) throw new Error("manifest κ MISMATCH (Law L5): " + manKappa.slice(0, 24) + "… ≠ pinned " + pin.slice(0, 24) + "…"); }
+  else if (!opts.allowUnpinned) throw new Error("manifest unpinned (Law L5): pass opts.expectKappa (catalog pin) or opts.allowUnpinned for dev");
+  const man = JSON.parse(new TextDecoder().decode(manRaw));
+  // FAMILY FINETUNE: a `base-κ + delta` object — reconstruct via the delta loader (same return shape).
+  if (man.format === "holo-delta/1") return (await import("./holo-load-delta.mjs")).loadDeltaObject(baseUrl, { ...opts, manifest: man });
+  // FAST FIRST LOAD: prefetch every block into the cache in parallel while the engine builds (turns a
+  // latency-bound sequential stream into a bandwidth-bound one — critical when serving off a remote CDN like HF).
+  if (opts.prefetch !== false) { try { prefetchBlocks(baseUrl, Object.values(man.tensors || {}).map((r) => r.kappa)); } catch (e) {} }
+  // RAM-bounded, DISK-cached: the engine fetches each tensor once, so decoded blocks are handed over and
+  // released — in-flight RAM stays ~one block (a 7B κ-object decompresses to >2.6 GB). The gzipped block
+  // bytes are persisted to the Cache API by their content-addressed URL (cachedBytes), so a returning user
+  // reads them from disk with no network. Every block — cached or fresh — is L5 re-derived (κ must match),
+  // so the cache is untrusted-safe.
+  const getBlock = async (kappa) => {
+    const gz = await cachedBytes(baseUrl + "/b/" + kappa.replace(":", "_") + ".gz");
+    const got = "sha256:" + hex(await crypto.subtle.digest("SHA-256", gz));         // Law L5: re-derive the κ
+    if (got !== kappa) throw new Error("κ MISMATCH " + kappa.slice(0, 24));
+    return await gunzip(gz);
+  };
+  const fetchTensor = async (name) => {
+    const rec = man.tensors[name]; if (!rec) return new Uint8Array(0);
+    return reshapeTensor(rec, await getBlock(rec.kappa));
+  };
+  // E₈ codebook (mode e8): the 256×8 LUT is its own content-addressed block — fetch + κ-verify (Law L5)
+  let e8lutData;
+  if (man.e8lut) { const b = await getBlock(man.e8lut.replace(/^did:holo:/, "")); e8lutData = new Float32Array(b.buffer, b.byteOffset, 2048); }
+  const manifest = buildEngineManifest(man, man.tensors, e8lutData);
+  // bundled tokenizer (SERVERLESS load): the header (tokenizer + arch) should load same-origin/on-device, no
+  // external host. A RELATIVE `source` already resolves against the κ-object's own dir. When the manifest
+  // declares a REMOTE (http) source but the κ-object ALSO ships a local tokenizer.gguf, PREFER the bundle —
+  // one cheap HEAD probe, and the manifest bytes (hence its Law-L5 pin) stay untouched. No bundle served →
+  // fall back to the declared source. This makes a κ-object with a bundled header 100% serverless to load.
+  const base = baseUrl.replace(/\/+$/, "");
+  if (man.source && !/^https?:\/\//.test(man.source)) man.source = base + "/" + man.source;
+  else if (man.source && /^https?:\/\//.test(man.source)) {
+    try { const h = await fetch(base + "/tokenizer.gguf", { method: "HEAD" }); if (h && h.ok) man.source = base + "/tokenizer.gguf"; } catch (e) {}
+  }
+  return { manifest, fetchTensor, info: man };
+}

holo-model-frame.mjs

@@ -0,0 +1,106 @@
+// holo-model-frame.mjs — A1 of the personal-model-zoo plan: the CANONICAL SHARED FRAME standard + a
+// conformance gate, so every κ-addressable .holo LLM DECLARES the quantization frame it lives in.
+//
+// Why this exists: two models can family-dedup / index-delta (A2) ONLY if their unchanged tensors
+// produce BYTE-IDENTICAL κ-blocks — which requires the SAME quantization transform ("frame"). The frame
+// is the transform identity (codec, layout, bits, mode, twoBit, incoherence), NOT the model's weights or
+// dims. The incoherence rotation is already deterministic (signed-FWHT seeded by tensor width K, see
+// e8-quant.mjs signsFor), so a frame is reproducible from its descriptor alone.
+//
+// HONEST SCOPE: this does NOT requantize anything. Today's models are standard quant frames
+// (holo-quant/<layout>-<bits>); the shared E8 frame (atlas-e8/v1) is what models compiled through the
+// incoherent-E8 path carry. Moving everything into atlas-e8/v1 is Track B (gated on the 2-bit quality
+// experiment), deliberately not done here. A1 just makes the frame EXPLICIT and ENFORCED.
+//
+// Pure JS, isomorphic (browser + Node 18+), zero deps. Node self-test scans ./models/<name>/manifest.json.
+
+const FRAME_V = 1;
+
+// the fields that DEFINE a quantization transform — two models with the same fingerprint apply the
+// identical transform, so identical weights ⇒ identical κ-blocks (the precondition for A2 dedup).
+const FRAME_KEYS = ["codec", "layout", "bits", "mode", "twoBit", "incoherent", "grid"];
+
+async function sha256hex(str) {
+  const u8 = new TextEncoder().encode(str);
+  const d = await (globalThis.crypto || (await import("node:crypto")).webcrypto).subtle.digest("SHA-256", u8);
+  return Array.from(new Uint8Array(d), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// extract the frame-defining descriptor from a compiled-model manifest (holo-2bit/1 shape).
+export function frameDescriptor(m) {
+  const d = {
+    codec: m.format || "unknown",          // e.g. "holo-2bit/1"
+    layout: m.layout || null,              // e.g. "q3f"
+    bits: m.bits ?? null,                  // e.g. 3
+    mode: m.mode || null,                  // e.g. "bitnet" | "q3"
+    twoBit: !!m.twoBit,
+    incoherent: !!m.incoherent,            // QuIP#-style signed-FWHT rotation applied
+    grid: m.grid || (m.incoherent ? "e8" : "scalar")   // e8 lattice vs scalar grid
+  };
+  return d;
+}
+
+// the canonical id for a frame — atlas-e8/v1 is THE shared frame family members ride; everything else
+// declares its own standalone quant frame (still conformant, just not E8-shareable).
+export function frameId(desc) {
+  if (desc.incoherent && desc.grid === "e8") return "atlas-e8/v1";
+  return `holo-quant/${desc.layout || desc.mode || "q"}-${desc.bits ?? "x"}bit`;
+}
+
+export async function frameFingerprint(desc) {
+  const canon = JSON.stringify(FRAME_KEYS.map((k) => [k, desc[k]]));   // fixed key order ⇒ stable hash
+  return (await sha256hex(canon)).slice(0, 32);
+}
+
+// STAMP: add an explicit, self-verifying frame block to a manifest (idempotent).
+export async function stampFrame(m) {
+  const desc = frameDescriptor(m);
+  m.frame = { v: FRAME_V, id: frameId(desc), fingerprint: await frameFingerprint(desc), ...desc };
+  return m;
+}
+
+// CONFORMANCE GATE: a .holo LLM must DECLARE a frame whose fingerprint re-derives from its own fields.
+// Rejects: no frame block, tampered/mismatched fingerprint, or unknown frame version.
+export async function checkFrame(m) {
+  if (!m || !m.frame) return { conforms: false, reason: "no frame declared (run stampFrame at compile)" };
+  if (m.frame.v !== FRAME_V) return { conforms: false, reason: `unknown frame version ${m.frame.v}` };
+  const want = await frameFingerprint(frameDescriptor(m));
+  if (m.frame.fingerprint !== want) return { conforms: false, reason: `fingerprint mismatch (manifest changed since stamp): ${m.frame.fingerprint} != ${want}` };
+  return { conforms: true, id: m.frame.id, fingerprint: m.frame.fingerprint, shared: m.frame.id === "atlas-e8/v1" };
+}
+
+// can two stamped models family-dedup / index-delta? Same transform (fingerprint) AND same architecture.
+export function shareable(a, b) {
+  if (!a.frame || !b.frame) return false;
+  if (a.frame.fingerprint !== b.frame.fingerprint) return false;
+  for (const k of ["d", "n_layers", "ff", "n_heads", "n_kv_heads", "hd", "vocab"]) if (a[k] !== b[k]) return false;
+  return true;
+}
+
+// ── Node self-test: scan ./models/*/manifest.json, stamp + gate them, group by family-dedup class,
+//    and prove the gate rejects a planted non-conformer. ──
+if (typeof process !== "undefined" && process.argv[1] && process.argv[1].endsWith("holo-model-frame.mjs")) {
+  const fs = await import("node:fs"); const path = await import("node:path");
+  const root = path.join(process.cwd(), "models");
+  const dirs = fs.existsSync(root) ? fs.readdirSync(root).filter((d) => fs.existsSync(path.join(root, d, "manifest.json"))) : [];
+  const rows = [], byClass = {};
+  for (const name of dirs) {
+    let m; try { m = JSON.parse(fs.readFileSync(path.join(root, name, "manifest.json"), "utf8")); } catch { continue; }
+    await stampFrame(m);
+    const chk = await checkFrame(m);
+    const key = `${m.frame.id} · d${m.d}·L${m.n_layers}·ff${m.ff}`;
+    (byClass[key] ||= []).push(name);
+    rows.push({ model: name, id: m.frame.id, fp: m.frame.fingerprint.slice(0, 12), conforms: chk.conforms, shared: !!chk.shared });
+  }
+  console.log("\n— frame stamp + conformance over ./models —");
+  for (const r of rows) console.log(`  ${r.conforms ? "✓" : "✗"} ${r.model.padEnd(16)} ${r.id.padEnd(22)} fp=${r.fp} ${r.shared ? "[E8-shared]" : "[standalone]"}`);
+  console.log("\n— family-dedup classes (same frame + same arch ⇒ A2 can dedup/delta) —");
+  for (const [k, v] of Object.entries(byClass)) console.log(`  ${v.length}× ${k}\n        ${v.join(", ")}`);
+  // gate must REJECT a non-conformer
+  const planted = { format: "holo-2bit/1", layout: "q3f", bits: 3 };   // no frame block
+  const bad = await checkFrame(planted);
+  const tampered = await stampFrame({ format: "holo-2bit/1", layout: "q3f", bits: 3, incoherent: false });
+  tampered.bits = 2;   // change a frame-defining field AFTER stamping → stored fingerprint must no longer match
+  const badly = await checkFrame(tampered);
+  console.log(`\n— gate rejection proof —\n  no-frame:  conforms=${bad.conforms}  (${bad.reason})\n  tampered:  conforms=${badly.conforms}  (${badly.reason})`);
+}

index.html

@@ -1,19 +1,134 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>
+<!doctype html><html><head><meta charset=utf8><meta name=viewport content="width=device-width,initial-scale=1,viewport-fit=cover">
+<title>Q — private AI, in your browser</title>
+<style>
+  :root{--bg:#0b0e14;--panel:#141922;--ink:#e6e9ef;--dim:#8a94a6;--q:#7c5cff;--u:#1f6feb;--line:#1e2531}
+  *{box-sizing:border-box}html,body{height:100%}
+  body{margin:0;font:15px/1.55 -apple-system,Segoe UI,Roboto,system-ui,monospace;background:var(--bg);color:var(--ink);display:flex;flex-direction:column;overscroll-behavior:none}
+  header{padding:10px 16px;border-bottom:1px solid var(--line);display:flex;align-items:center;gap:10px;flex:0 0 auto}
+  header b{font-weight:600}header .s{color:var(--dim);font-size:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+  #log{flex:1;overflow:auto;padding:16px;display:flex;flex-direction:column;gap:12px;-webkit-overflow-scrolling:touch}
+  .msg{max-width:82%;padding:9px 13px;border-radius:12px;white-space:pre-wrap;word-wrap:break-word}
+  .u{align-self:flex-end;background:var(--u)}.a{align-self:flex-start;background:var(--panel);border:1px solid #232b3a}
+  .a.think{color:var(--dim);font-style:italic}
+  footer{padding:12px 16px;border-top:1px solid var(--line);display:flex;gap:8px;flex:0 0 auto;padding-bottom:calc(12px + env(safe-area-inset-bottom))}
+  #in{flex:1;background:var(--panel);border:1px solid #232b3a;color:var(--ink);border-radius:10px;padding:10px 12px;font:inherit;resize:none;max-height:140px}
+  button{background:var(--q);color:#fff;border:0;border-radius:10px;padding:0 18px;font:inherit;cursor:pointer}button:disabled{opacity:.4;cursor:default}
+  .stat{color:var(--dim);font-size:11px;margin-top:3px}
+</style></head><body>
+<header><b>Q</b> <span class=s id=st>booting…</span></header>
+<div id=log></div>
+<footer><textarea id=in rows=1 placeholder="Message Q…" disabled></textarea><button id=send disabled>Send</button></footer>
+<script type=module>
+import { ready, loadModel, MODELS, defaultModelIndex } from "./core/loader.js";
+import { createEngine } from "./core/engine.js";
+import { selfPersona, selfFacts } from "./core/q-self.mjs";   // ONE grounded self-knowledge, shared with the messenger + voice
+const $ = (s) => document.querySelector(s);
+const log = $("#log"), input = $("#in"), send = $("#send"), st = $("#st");
+const bubble = (cls, text = "") => { const d = document.createElement("div"); d.className = "msg " + cls; d.textContent = text; log.appendChild(d); log.scrollTop = log.scrollHeight; return d; };
+const params = new URLSearchParams(location.search);
+const pick = params.get("m");
+let m = pick ? (MODELS.find((x) => new RegExp(pick, "i").test(x.name)) || MODELS[0]) : MODELS[defaultModelIndex()];
+// STREAM FROM HF: a bare link streams the HOLOGRAMTECH BitNet κ-object from Hugging Face; ?hf=<org/repo> or
+// ?kappa=<absolute-url> override. The κ-object is content-addressed + pinned, so the host is an UNTRUSTED CDN —
+// every block is re-derived (Law L5); a bad byte is rejected. Blocks cache locally after first load (0-net on return).
+{
+  let hf = params.get("hf"), kappa = params.get("kappa");
+  if (!hf && !kappa && !pick) hf = "HOLOGRAMTECH/q-bitnet-2b";   // bare link → stream BitNet from Hologram's HF repo
+  if (hf || kappa) {
+    const base = (kappa || `https://huggingface.co/${hf}/resolve/main`).replace(/\/+$/, "");
+    const bit = MODELS.find((x) => (x.fam || "").toLowerCase() === "bitnet") || m;
+    m = { ...bit, kappaUrl: base, name: bit.name + " · via " + (hf || new URL(base).host) };
+  }
+}
+
+// GROUND the model as on-device Q (a base/instruct model has NO self-knowledge — without this it confabulates
+// a generic "I run on OpenAI/AWS cloud servers" identity, which is false). Injected as the SYSTEM turn.
+function frameSystem() {
+  const PERSONA = selfPersona({ model: m, engine });
+  if (m.llama3) return `<|start_header_id|>system<|end_header_id|>\n\n${PERSONA}<|eot_id|>`;
+  if (m.qwen)   return `<|im_start|>system\n${PERSONA}<|im_end|>\n`;
+  if (m.olmo)   return `<|system|>\n${PERSONA}\n`;
+  return PERSONA + "\n\n";
+}
+
+// GROUNDED IDENTITY (the anti-confabulation guard). A 2B model reverts to its training prior — "I'm GPT-3.5 on
+// AWS" — when asked what/where it is, no matter the system prompt. But identity is not a guess: it is the TRUTH
+// of THIS running instance. So provenance questions are answered DETERMINISTICALLY from the live facts (the real
+// resident model + its κ + the real host it streamed from), never from the model. Grounded, not performed.
+const IDENTITY_RX = /\b(are|r)\s*(you|u)\b.*\b(gpt|chatgpt|openai|claude|anthropic|gemini|bard|llama|language model|an? ai|running|local|on[- ]?device|in the browser|on (a )?server|in the cloud|hosted)\b|\bwhat( kind of| sort of| type of)?\b.*\b(model|llm|ai|are you|based on|powered by|architecture|run on|running)\b|\bwho\b.*\b(are you|made|built|created|trained|develop)\b|\bwhere\b.*\b(run|running|host|hosted|are you|live|located)\b|\bpowered by\b|\bwhat are you\b|\b(openai|chatgpt|gpt-?\d|aws|amazon web|google cloud|cloud server)\b|\b(local|cloud|server)\b.*\bmodel\b|\bdo you run\b/i;
+function groundedIdentity() {
+  const f = selfFacts({ model: m, engine });
+  const name = f.model || (m && m.name) || "an on-device model";
+  const host = (f.weightsFrom && !/^local$/i.test(f.weightsFrom)) ? f.weightsFrom : "Hugging Face";
+  const q = f.quant ? ` (${f.quant})` : "";
+  return `I'm Q. I run the ${name}${q} entirely in your browser on WebGPU — not GPT, not OpenAI, and not on any server or cloud. `
+    + `My weights streamed from ${host} and are content-addressed: every block is re-derived byte-for-byte as it loads, so nothing can be tampered with and no host has to be trusted. `
+    + `Once I'm loaded, nothing you type ever leaves your device.`;
+}
+
+let engine = null, convIds = [], busy = false, armed = false, pending = null;
+input.disabled = send.disabled = false; input.placeholder = "Message Q… (model loading — will send the moment it's ready)"; input.focus();
+
+async function generate(text, skipUser) {
+  busy = true; input.disabled = send.disabled = true;
+  if (!skipUser) bubble("u", text);
+  // Answer identity/provenance questions from the grounded truth, not the model's confabulation.
+  if (IDENTITY_RX.test(text)) {
+    const a = bubble("a", groundedIdentity());
+    const stat = document.createElement("div"); stat.className = "stat"; stat.textContent = "grounded · from this instance"; a.after(stat);
+    busy = false; input.disabled = send.disabled = false; input.focus(); return;
+  }
+  const a = bubble("a think", "…"); let first = true;
+  const stat = document.createElement("div"); stat.className = "stat";
+  try {
+    let framed = engine.frameTurn(text, convIds.length > 0);
+    if (convIds.length === 0) framed = frameSystem() + framed;
+    let turnIds = engine.tokenize(framed);
+    if (m.bos && engine.bosId != null && convIds.length === 0) turnIds = [engine.bosId, ...turnIds];
+    const res = await engine.generate(convIds.concat(turnIds), { maxNew: m.cap || 256, onToken: ({ text: t, stats }) => {
+      if (first && t) { a.classList.remove("think"); a.textContent = ""; first = false; }
+      a.textContent = t; log.scrollTop = log.scrollHeight;
+      if (stats) stat.textContent = `${stats.tokps ? stats.tokps.toFixed(0) + " tok/s" : ""}${stats.ttft ? " · TTFT " + Math.round(stats.ttft) + "ms" : ""}`;
+    } });
+    if (first) { a.classList.remove("think"); a.textContent = res.text || "(no output)"; }
+    convIds = res.ids; a.after(stat);
+  } catch (e) { a.classList.remove("think"); a.textContent = "⚠ " + e.message; }
+  busy = false; input.disabled = send.disabled = false; input.focus();
+}
+async function proactiveGreeting() {
+  busy = true; input.disabled = send.disabled = true;
+  const a = bubble("a think", "…"); let first = true;
+  const stat = document.createElement("div"); stat.className = "stat";
+  const FALLBACK = "Hey — I'm Q, running entirely in your browser, no server. My weights streamed from Hugging Face and are verified by re-derivation. What can I help you with?";
+  try {
+    const P = "This is the very first thing you say to the person who just opened you. You are Q — a private AI running entirely in their browser with no server, your weights streamed from Hugging Face and verified by re-derivation. Greet them warmly in one or two sentences and invite them to ask you anything.";
+    let ids = engine.tokenize(engine.frameTurn(P, false));
+    if (m.bos && engine.bosId != null) ids = [engine.bosId, ...ids];
+    await engine.generate(ids, { maxNew: 64, onToken: ({ text: t, stats }) => { if (first && t) { a.classList.remove("think"); a.textContent = ""; first = false; } a.textContent = t; log.scrollTop = log.scrollHeight; if (stats && stats.tokps) stat.textContent = `${stats.tokps.toFixed(0)} tok/s`; } });
+    if (first || a.textContent.trim().length < 4) { a.classList.remove("think"); a.textContent = FALLBACK; } else a.after(stat);
+  } catch (e) { a.classList.remove("think"); a.textContent = FALLBACK; }
+  busy = false; input.disabled = send.disabled = false; input.focus();
+}
+function onSend() {
+  const text = input.value.trim(); if (!text || busy) return;
+  input.value = ""; input.style.height = "auto";
+  if (!armed) { pending = text; bubble("u", text); const w = bubble("a think", "…starting the model, one moment…"); w.dataset.pending = "1"; return; }
+  generate(text);
+}
+send.onclick = onSend;
+input.onkeydown = (e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); onSend(); } };
+input.oninput = () => { input.style.height = "auto"; input.style.height = Math.min(140, input.scrollHeight) + "px"; };
+
+try {
+  if (!navigator.gpu) throw new Error("This browser has no WebGPU — open in Chrome, Edge, or a recent mobile browser.");
+  st.textContent = `loading ${m.name} (${m.size})…`;
+  const loaded = await loadModel(m, { onStatus: (s) => { if (s) st.textContent = `${m.name}: ${s}`; }, onProgress: (d, t, w) => { st.textContent = `${m.name}: ${w} ${t ? Math.round(100 * d / t) : 0}%`; } });
+  if (!loaded || !loaded.gpu) throw new Error("model load failed");
+  engine = await createEngine(m, loaded);
+  armed = true;
+  st.textContent = `${m.name} · ${m.size} · in your browser · ready`;
+  input.placeholder = "Message Q…";
+  if (pending) { const w = [...log.querySelectorAll(".a")].reverse().find((x) => x.dataset.pending); if (w) w.remove(); const p = pending; pending = null; generate(p, true); }
+  else await proactiveGreeting();
+} catch (e) { st.textContent = "⚠ " + e.message; bubble("a", "Could not start: " + e.message); }
+</script></body></html>

pkg/holospaces_web_bg.wasm

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

q-chat.html

@@ -0,0 +1,120 @@
+<!doctype html><html><head><meta charset=utf8><meta name=viewport content="width=device-width,initial-scale=1">
+<title>Q · local chat</title>
+<style>
+  :root{--bg:#0b0e14;--panel:#141922;--ink:#e6e9ef;--dim:#8a94a6;--q:#7c5cff;--u:#1f6feb;--line:#1e2531}
+  *{box-sizing:border-box}html,body{height:100%}
+  body{margin:0;font:15px/1.55 -apple-system,Segoe UI,Roboto,monospace;background:var(--bg);color:var(--ink);display:flex;flex-direction:column}
+  header{padding:10px 16px;border-bottom:1px solid var(--line);display:flex;align-items:center;gap:10px;flex:0 0 auto}
+  header b{font-weight:600}header .s{color:var(--dim);font-size:12px}
+  #log{flex:1;overflow:auto;padding:16px;display:flex;flex-direction:column;gap:12px}
+  .msg{max-width:82%;padding:9px 13px;border-radius:12px;white-space:pre-wrap;word-wrap:break-word}
+  .u{align-self:flex-end;background:var(--u)}.a{align-self:flex-start;background:var(--panel);border:1px solid #232b3a}
+  .a.think{color:var(--dim);font-style:italic}
+  footer{padding:12px 16px;border-top:1px solid var(--line);display:flex;gap:8px;flex:0 0 auto}
+  #in{flex:1;background:var(--panel);border:1px solid #232b3a;color:var(--ink);border-radius:10px;padding:10px 12px;font:inherit;resize:none;max-height:140px}
+  button{background:var(--q);color:#fff;border:0;border-radius:10px;padding:0 18px;font:inherit;cursor:pointer}button:disabled{opacity:.4;cursor:default}
+  .stat{color:var(--dim);font-size:11px;margin-top:3px}
+</style></head><body>
+<header><b>Q</b> <span class=s id=st>booting…</span></header>
+<div id=log></div>
+<footer><textarea id=in rows=1 placeholder="Message Q…" disabled></textarea><button id=send disabled>Send</button></footer>
+<script type=module>
+import { ready, loadModel, MODELS, defaultModelIndex } from "./core/loader.js";
+import { createEngine } from "./core/engine.js";
+import { selfPersona } from "./core/q-self.mjs";   // ONE grounded self-knowledge, shared with the messenger + voice
+const $ = (s) => document.querySelector(s);
+const log = $("#log"), input = $("#in"), send = $("#send"), st = $("#st");
+const bubble = (cls, text = "") => { const d = document.createElement("div"); d.className = "msg " + cls; d.textContent = text; log.appendChild(d); log.scrollTop = log.scrollHeight; return d; };
+const params = new URLSearchParams(location.search);
+const pick = params.get("m");
+let m = pick ? (MODELS.find((x) => new RegExp(pick, "i").test(x.name)) || MODELS[0]) : MODELS[defaultModelIndex()];
+// STREAM FROM ANYWHERE: ?hf=<org/repo> (a HuggingFace κ-object) or ?kappa=<absolute-url> loads the weights from
+// that host's CDN instead of the local mount. The κ-object is content-addressed + pinned, so the host is an
+// UNTRUSTED CDN — every block is re-derived (Law L5); a bad byte is rejected. Blocks cache locally after first
+// load (0-network on return). Uses BitNet's engine flags (the HOLOGRAMTECH model is BitNet-2B).
+{
+  const hf = params.get("hf"), kappa = params.get("kappa");
+  if (hf || kappa) {
+    const base = (kappa || `https://huggingface.co/${hf}/resolve/main`).replace(/\/+$/, "");
+    const bit = MODELS.find((x) => (x.fam || "").toLowerCase() === "bitnet") || m;
+    m = { ...bit, kappaUrl: base, name: bit.name + " · via " + (hf || new URL(base).host) };
+  }
+}
+
+// GROUND the model as on-device Q (a base/instruct model has NO self-knowledge — without this it confabulates
+// a generic "I run on OpenAI/AWS cloud servers" identity, which is false). Injected as the SYSTEM turn.
+// the system block for the model's own chat template (matches core/engine frameTurn's per-family markers).
+// PERSONA is Q's LIVE grounded self-knowledge (q-self), computed at call time so it names the real resident
+// model + κ — without it a base model confabulates a cloud/OpenAI/AWS identity.
+function frameSystem() {
+  const PERSONA = selfPersona({ model: m, engine });
+  if (m.llama3) return `<|start_header_id|>system<|end_header_id|>\n\n${PERSONA}<|eot_id|>`;
+  if (m.qwen)   return `<|im_start|>system\n${PERSONA}<|im_end|>\n`;
+  if (m.olmo)   return `<|system|>\n${PERSONA}\n`;
+  return PERSONA + "\n\n";   // word/plain frame: prepend as leading context
+}
+
+let engine = null, convIds = [], busy = false, armed = false, pending = null;
+// type immediately — don't wait for the model. The first message is queued and auto-sent the instant Q is ready.
+input.disabled = send.disabled = false; input.placeholder = "Message Q… (model loading — will send the moment it's ready)"; input.focus();
+
+async function generate(text, skipUser) {
+  busy = true; input.disabled = send.disabled = true;
+  if (!skipUser) bubble("u", text);
+  const a = bubble("a think", "…"); let first = true;
+  const stat = document.createElement("div"); stat.className = "stat";
+  const t0 = performance.now();
+  try {
+    let framed = engine.frameTurn(text, convIds.length > 0);
+    if (convIds.length === 0) framed = frameSystem() + framed;   // first turn → lead with the on-device Q persona
+    let turnIds = engine.tokenize(framed);
+    if (m.bos && engine.bosId != null && convIds.length === 0) turnIds = [engine.bosId, ...turnIds];
+    const res = await engine.generate(convIds.concat(turnIds), { maxNew: m.cap || 256, onToken: ({ text: t, stats }) => {
+      if (first && t) { a.classList.remove("think"); a.textContent = ""; first = false; }
+      a.textContent = t; log.scrollTop = log.scrollHeight;
+      if (stats) stat.textContent = `${stats.tokps ? stats.tokps.toFixed(0) + " tok/s" : ""}${stats.ttft ? " · TTFT " + Math.round(stats.ttft) + "ms" : ""}`;
+    } });
+    if (first) { a.classList.remove("think"); a.textContent = res.text || "(no output)"; }
+    convIds = res.ids; a.after(stat);
+  } catch (e) { a.classList.remove("think"); a.textContent = "⚠ " + e.message; }
+  busy = false; input.disabled = send.disabled = false; input.focus();
+}
+// Q reaches out first — a real, model-GENERATED opening (not a canned line), so it feels alive.
+// This also warms the GPU pipelines. It is standalone (not added to convIds) so the real chat starts fresh.
+async function proactiveGreeting() {
+  busy = true; input.disabled = send.disabled = true;
+  const a = bubble("a think", "…"); let first = true;
+  const stat = document.createElement("div"); stat.className = "stat";
+  const FALLBACK = "Hey — I'm Q, running entirely on your device, no server, my weights verified by re-derivation. What can I help you with?";
+  try {
+    const P = "This is the very first thing you say to the person who just opened you. You are Q — a private AI running entirely on their device with no server, your weights verified by re-derivation. Greet them warmly in one or two sentences and invite them to ask you anything.";
+    let ids = engine.tokenize(engine.frameTurn(P, false));
+    if (m.bos && engine.bosId != null) ids = [engine.bosId, ...ids];
+    await engine.generate(ids, { maxNew: 64, onToken: ({ text: t, stats }) => { if (first && t) { a.classList.remove("think"); a.textContent = ""; first = false; } a.textContent = t; log.scrollTop = log.scrollHeight; if (stats && stats.tokps) stat.textContent = `${stats.tokps.toFixed(0)} tok/s`; } });
+    if (first || a.textContent.trim().length < 4) { a.classList.remove("think"); a.textContent = FALLBACK; } else a.after(stat);
+  } catch (e) { a.classList.remove("think"); a.textContent = FALLBACK; }
+  busy = false; input.disabled = send.disabled = false; input.focus();
+}
+function onSend() {
+  const text = input.value.trim(); if (!text || busy) return;
+  input.value = ""; input.style.height = "auto";
+  if (!armed) { pending = text; bubble("u", text); const w = bubble("a think", "…starting the model, one moment…"); w.dataset.pending = "1"; return; }
+  generate(text);
+}
+send.onclick = onSend;
+input.onkeydown = (e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); onSend(); } };
+input.oninput = () => { input.style.height = "auto"; input.style.height = Math.min(140, input.scrollHeight) + "px"; };
+
+try {
+  if (!navigator.gpu) throw new Error("This browser has no WebGPU. Use Chrome/Edge.");
+  st.textContent = `loading ${m.name} (${m.size})…`;
+  const loaded = await loadModel(m, { onStatus: (s) => { if (s) st.textContent = `${m.name}: ${s}`; }, onProgress: (d, t, w) => { st.textContent = `${m.name}: ${w} ${t ? Math.round(100 * d / t) : 0}%`; } });
+  if (!loaded || !loaded.gpu) throw new Error("model load failed");
+  engine = await createEngine(m, loaded);
+  armed = true;
+  st.textContent = `${m.name} · ${m.size} · resident on your GPU · ready`;
+  input.placeholder = "Message Q…";
+  if (pending) { const w = [...log.querySelectorAll(".a")].reverse().find((x) => x.dataset.pending); if (w) w.remove(); const p = pending; pending = null; generate(p, true); }   // you jumped in first → answer that
+  else await proactiveGreeting();   // otherwise Q reaches out the moment it's ready (also warms the GPU)
+} catch (e) { st.textContent = "⚠ " + e.message; bubble("a", "Could not start: " + e.message); }
+</script></body></html>

qvac-2bit.mjs

@@ -0,0 +1,268 @@
+// qvac-2bit.mjs — NATIVE 2-bit WebGPU matmul: read 2-bit weights DIRECTLY on the GPU (no decode to Q8),
+// undo incoherence with a runtime Hadamard, accumulate in f32. This is the on-GPU realization of the E₈/
+// QuIP# 2-bit win: the per-token weight sweep drops ~4× vs Q8, so a 7B model (≈1.75 GB at 2-bit) fits
+// resident in consumer VRAM and runs at VRAM bandwidth instead of paging from disk.
+//
+// Math (one-sided incoherence, the efficient form): let R = FWHT∘diag(sign) — orthogonal AND self-inverse
+// (FWHT normalized 1/√K, sign ∈ ±1). Store Ŵ′ = quantize₂(R·Wₙ) per row (R isotropizes the row so a 2-bit
+// grid quantizes it well). At inference rotate the INPUT once, x′ = R·x, then yₙ = Σ Ŵ′[n,k]·x′[k] ≈
+// (R·Wₙ)·(R·x) = Wₙ·x — the rotation cancels for free, no output Hadamard. Cost: one length-K Hadamard
+// per matmul (O(K log K), negligible beside the O(N·K) matmul). Pure WebGPU; the codebook is a uniform
+// 4-level grid {−3,−1,1,3}·scale with a per-32 block scale (same scale layout the engine's Q8 path uses).
+
+const FWHT_WG = 256;                                   // single-workgroup input rotation (K ≤ 2048)
+const MM_WG = 64;                                      // one workgroup per output row, 64-thread reduce
+
+// ── CPU: deterministic ±1 signs (re-derivable from K, matches e8-quant's xorshift) ──
+export function signsFor(K) {
+  const s = new Float32Array(K); let x = (0x9e3779b9 ^ K) >>> 0;
+  for (let i = 0; i < K; i++) { x ^= x << 13; x ^= x >>> 17; x ^= x << 5; x >>>= 0; s[i] = (x & 1) ? 1 : -1; }
+  return s;
+}
+function fwht(a) {                                      // in place, normalized (self-inverse)
+  const n = a.length;
+  for (let len = 1; len < n; len <<= 1) for (let i = 0; i < n; i += len << 1) for (let j = i; j < i + len; j++) { const u = a[j], v = a[j + len]; a[j] = u + v; a[j + len] = u - v; }
+  const s = 1 / Math.sqrt(n); for (let i = 0; i < n; i++) a[i] *= s;
+}
+
+// ── CPU: pack a weight matrix W [N,K] (row-major) to incoherent 2-bit + per-32 scales ──
+// Returns { qw:Uint32Array(N*K/16), sc:Float32Array(N*K/32), sign:Float32Array(K) }.
+// incoherent=false skips the rotation (naive 2-bit) — for the quality contrast only.
+export function pack2bit(W, N, K, { incoherent = true } = {}) {
+  const nblk = K / 32, qw = new Uint32Array((N * K) / 16), sc = new Float32Array(N * nblk), sign = signsFor(K);
+  const row = new Float64Array(K);
+  for (let n = 0; n < N; n++) {
+    for (let k = 0; k < K; k++) row[k] = incoherent ? W[n * K + k] * sign[k] : W[n * K + k];
+    if (incoherent) fwht(row);                          // row ← R·Wₙ
+    // per-block scale: MSE-optimal step for a 4-level uniform grid {−3,−1,1,3}·s on ~Gaussian data is
+    // s ≈ 0.5·σ (grid spans ±1.5σ). Outliers beyond ±1.5σ clip — which is exactly what incoherence
+    // removes (the Hadamard Gaussianizes the row), so naive-2-bit clips heavy tails and incoherent does not.
+    for (let b = 0; b < nblk; b++) { let ss = 0; for (let i = 0; i < 32; i++) { const a = row[b * 32 + i]; ss += a * a; } sc[n * nblk + b] = (0.5 * Math.sqrt(ss / 32)) || 1e-12; }
+    for (let k = 0; k < K; k++) {
+      const t = row[k] / sc[n * nblk + (k >> 5)];
+      let q = Math.round((t + 3) / 2); if (q < 0) q = 0; else if (q > 3) q = 3;   // grid {−3,−1,1,3}
+      const idx = n * K + k; qw[idx >> 4] |= q << ((idx & 15) * 2);
+    }
+  }
+  return { qw, sc, sign };
+}
+// reconstruct (CPU reference for the stored 2-bit weights, in the ORIGINAL basis): undo R on each row
+export function unpack2bit(qw, sc, sign, N, K, { incoherent = true } = {}) {
+  const nblk = K / 32, W = new Float32Array(N * K), row = new Float64Array(K);
+  for (let n = 0; n < N; n++) {
+    for (let k = 0; k < K; k++) { const idx = n * K + k; const q = (qw[idx >> 4] >>> ((idx & 15) * 2)) & 3; row[k] = (q * 2 - 3) * sc[n * nblk + (k >> 5)]; }
+    if (incoherent) { fwht(row); for (let k = 0; k < K; k++) row[k] *= sign[k]; }    // R is self-inverse
+    for (let k = 0; k < K; k++) W[n * K + k] = row[k];
+  }
+  return W;
+}
+
+// f32 → f16 bits (Uint16). Scales are small positives; round-toward-zero of the mantissa is fine.
+export function f32ToF16(val) {
+  _f32[0] = val; const x = _u32[0];
+  const sign = (x >>> 16) & 0x8000; let exp = ((x >>> 23) & 0xff) - 112; const mant = x & 0x7fffff;
+  if (exp <= 0) { if (exp < -10) return sign; const m = (mant | 0x800000) >> (1 - exp); return sign | (m >> 13); }
+  if (exp >= 31) return sign | 0x7c00;
+  return sign | (exp << 10) | (mant >> 13);
+}
+const _f32 = new Float32Array(1), _u32 = new Uint32Array(_f32.buffer);
+
+// CODEBOOK-AWARE LDLQ to the 2-bit SCALAR grid {−3,−1,1,3}·sc — the engine's native 2-bit codebook, with
+// NO incoherence (so no power-of-2 padding, no runtime Hadamard). Rounds input columns high→low feeding
+// each future column's error back through L (the LDL factor of the input Hessian); L=null ⇒ plain scalar
+// 2-bit (the fallback when no calibration Hessian of the right dim exists, e.g. the FFN down-proj). Returns
+// the packed 2-bit indices (16 weights/u32, no padding — K must be a multiple of 16). sc = per-32 scales.
+// `band` caps the feedback to the nearest `band` future columns (0 = full). The LDL factor's off-diagonal
+// mass concentrates near the diagonal, so a band recovers most of the gain at O(N·K·band) instead of
+// O(N·K²) — the difference between a feasible and an infeasible 7B compile in single-thread JS.
+export function ldlqRound2bit(W, N, K, L, sc, band = 0, chunk = 4096) {
+  const qw = new Uint32Array((N * K) / 16), nb = K / 32, CH = Math.min(chunk, N), E = new Float32Array(CH * K);
+  for (let r0 = 0; r0 < N; r0 += CH) {                          // rows are independent in LDLQ → chunk them (E is CH·K, not N·K)
+    const rN = Math.min(CH, N - r0); E.fill(0, 0, rN * K);
+    for (let k = K - 1; k >= 0; k--) for (let ii = 0; ii < rN; ii++) {
+      const i = r0 + ii;
+      let corr = W[i * K + k]; if (L) { const jm = band ? Math.min(K, k + 1 + band) : K; for (let j = k + 1; j < jm; j++) corr += E[ii * K + j] * L[j * K + k]; }
+      const s = sc[i * nb + (k >> 5)]; let q = Math.round(corr / s / 2 + 1.5); if (q < 0) q = 0; else if (q > 3) q = 3;
+      E[ii * K + k] = W[i * K + k] - (q * 2 - 3) * s;
+      const idx = i * K + k; qw[idx >> 4] |= q << ((idx & 15) * 2);
+    }
+  }
+  return qw;
+}
+
+export const nextPow2 = (n) => { let p = 1; while (p < n) p <<= 1; return p; };
+// re-quantize an engine Q8 tensor (int8 quants + per-32 f32 scales) → incoherent 2-bit, padding the input
+// dim K to Kp = next power of 2 (the FWHT needs a pow2 length; padded weights/inputs are zeros ⇒ exact).
+// Returns { q: packed 2-bit bytes [N*Kp/4], s: f32 scales [N*Kp/32], Kp }. The runtime rotates the input by
+// the SAME R_Kp (signsFor(Kp)+FWHT), so Ŵ′·x′ = (R·W)(R·x) = W·x.
+export function requant2bit(q8, s, N, K) {
+  const Kp = nextPow2(K), nb = Kp / 32, sb = K / 32;
+  const q = new Int8Array(q8.buffer, q8.byteOffset, N * K);
+  const sign = signsFor(Kp), row = new Float64Array(Kp);
+  const qw = new Uint32Array((N * Kp) / 16), sc = new Float32Array(N * nb);
+  for (let n = 0; n < N; n++) {
+    for (let k = 0; k < Kp; k++) row[k] = (k < K ? q[n * K + k] * s[n * sb + (k >> 5)] : 0) * sign[k];
+    fwht(row);
+    for (let b = 0; b < nb; b++) { let ss = 0; for (let i = 0; i < 32; i++) { const a = row[b * 32 + i]; ss += a * a; } sc[n * nb + b] = (0.5 * Math.sqrt(ss / 32)) || 1e-12; }   // MSE-optimal step for the {−3,−1,1,3} grid on Gaussianised (incoherent) weights
+    for (let k = 0; k < Kp; k++) { const t = row[k] / sc[n * nb + (k >> 5)]; let qq = Math.round((t + 3) / 2); if (qq < 0) qq = 0; else if (qq > 3) qq = 3; const idx = n * Kp + k; qw[idx >> 4] |= qq << ((idx & 15) * 2); }
+  }
+  return { q: new Uint8Array(qw.buffer), s: sc, Kp };
+}
+
+// ── WGSL: input rotation x′ = FWHT(sign ⊙ x), single workgroup, shared memory ──
+const FWHT_WGSL = `
+@group(0) @binding(0) var<storage,read> x: array<f32>;
+@group(0) @binding(1) var<storage,read> sgn: array<f32>;
+@group(0) @binding(2) var<storage,read_write> xr: array<f32>;
+@group(0) @binding(3) var<uniform> P: vec4<u32>;        // K, _, _, _
+var<workgroup> sh: array<f32, 4096>;                    // 16 KB = the WebGPU min workgroup-storage limit; K ≤ 4096 (covers d up to 7B-class)
+@compute @workgroup_size(${FWHT_WG})
+fn main(@builtin(local_invocation_id) lid: vec3<u32>) {
+  let K = P.x; let t = lid.x;
+  for (var i = t; i < K; i += ${FWHT_WG}u) { sh[i] = x[i] * sgn[i]; }
+  workgroupBarrier();
+  var len = 1u;
+  loop {
+    if (len >= K) { break; }
+    let half = K >> 1u;
+    for (var i = t; i < half; i += ${FWHT_WG}u) {
+      let blk = i / len; let j = i % len;
+      let a = blk * (len << 1u) + j; let b = a + len;
+      let u = sh[a]; let v = sh[b]; sh[a] = u + v; sh[b] = u - v;
+    }
+    workgroupBarrier();
+    len = len << 1u;
+  }
+  let nrm = 1.0 / sqrt(f32(K));
+  for (var i = t; i < K; i += ${FWHT_WG}u) { xr[i] = sh[i] * nrm; }
+}`;
+
+// ── WGSL: 2-bit GEMV — WORD-ORIENTED: each thread loads one u32 (16 weights), unpacks in registers,
+// hoists the per-32 block scale (16 weights at a 16-aligned base never cross a 32 boundary → one scale
+// read per word). Threads stride by workgroup over words → coalesced loads. f32 accumulate. ──
+const MM2_WGSL = `
+@group(0) @binding(0) var<storage,read> qw: array<u32>;
+@group(0) @binding(1) var<storage,read> sc: array<f32>;
+@group(0) @binding(2) var<storage,read> x: array<f32>;
+@group(0) @binding(3) var<storage,read_write> o: array<f32>;
+@group(0) @binding(4) var<uniform> P: vec4<u32>;        // N, K, nblk, _
+var<workgroup> red: array<f32, ${MM_WG}>;
+@compute @workgroup_size(${MM_WG})
+fn main(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+  let n = wid.x; let K = P.y; let words = K >> 4u; let rowW = n * words; let rowS = n * P.z;
+  var acc = 0.0; var w = lid.x;
+  loop {
+    if (w >= words) { break; }
+    let packed = qw[rowW + w];
+    let kb = w << 4u; let s = sc[rowS + (kb >> 5u)];
+    for (var j = 0u; j < 16u; j = j + 1u) { acc = acc + x[kb + j] * f32(i32((packed >> (j * 2u)) & 3u) * 2 - 3) * s; }
+    w = w + ${MM_WG}u;
+  }
+  red[lid.x] = acc; workgroupBarrier();
+  var r = ${MM_WG >> 1}u;
+  loop { if (r == 0u) { break; } if (lid.x < r) { red[lid.x] = red[lid.x] + red[lid.x + r]; } workgroupBarrier(); r = r >> 1u; }
+  if (lid.x == 0u) { o[n] = red[0]; }
+}`;
+
+// ── WGSL: Q8 GEMV (the engine's current format) — WORD-ORIENTED too, so the comparison is purely the
+// bytes-read difference, not kernel quality. Each thread loads one u32 (4 int8), unpacks 4. ──
+const MM8_WGSL = `
+@group(0) @binding(0) var<storage,read> qw: array<u32>;
+@group(0) @binding(1) var<storage,read> sc: array<f32>;
+@group(0) @binding(2) var<storage,read> x: array<f32>;
+@group(0) @binding(3) var<storage,read_write> o: array<f32>;
+@group(0) @binding(4) var<uniform> P: vec4<u32>;
+var<workgroup> red: array<f32, ${MM_WG}>;
+@compute @workgroup_size(${MM_WG})
+fn main(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+  let n = wid.x; let K = P.y; let words = K >> 2u; let rowW = n * words; let rowS = n * P.z;
+  var acc = 0.0; var w = lid.x;
+  loop {
+    if (w >= words) { break; }
+    let packed = qw[rowW + w];
+    let kb = w << 2u; let s = sc[rowS + (kb >> 5u)];
+    for (var j = 0u; j < 4u; j = j + 1u) { let b = (packed >> (j * 8u)) & 0xffu; acc = acc + x[kb + j] * f32(i32(b << 24u) >> 24u) * s; }
+    w = w + ${MM_WG}u;
+  }
+  red[lid.x] = acc; workgroupBarrier();
+  var r = ${MM_WG >> 1}u;
+  loop { if (r == 0u) { break; } if (lid.x < r) { red[lid.x] = red[lid.x] + red[lid.x + r]; } workgroupBarrier(); r = r >> 1u; }
+  if (lid.x == 0u) { o[n] = red[0]; }
+}`;
+
+// ── GPU helpers ──
+const U = (typeof GPUBufferUsage !== "undefined") ? GPUBufferUsage : {};
+function pipe(dev, code) { const m = dev.createShaderModule({ code }); return dev.createComputePipeline({ layout: "auto", compute: { module: m, entryPoint: "main" } }); }
+function sbuf(dev, src) { const b = dev.createBuffer({ size: Math.max(16, src.byteLength), usage: U.STORAGE | U.COPY_DST | U.COPY_SRC }); dev.queue.writeBuffer(b, 0, src); return b; }
+function obuf(dev, bytes) { return dev.createBuffer({ size: Math.max(16, bytes), usage: U.STORAGE | U.COPY_SRC }); }
+function ubuf(dev, arr) { const b = dev.createBuffer({ size: 16, usage: U.UNIFORM | U.COPY_DST }); dev.queue.writeBuffer(b, 0, arr); return b; }
+async function readf32(dev, buf, n) { const st = dev.createBuffer({ size: n * 4, usage: U.MAP_READ | U.COPY_DST }); const e = dev.createCommandEncoder(); e.copyBufferToBuffer(buf, 0, st, 0, n * 4); dev.queue.submit([e.finish()]); await st.mapAsync(GPUMapMode.READ); const out = new Float32Array(st.getMappedRange().slice(0)); st.unmap(); st.destroy(); return out; }
+
+// ── the bench: correctness (2-bit incoherent vs f32 ref vs naive-2-bit vs Q8) + perf + memory ──
+export async function runBench(dev, { N = 2048, K = 2048, iters = 200 } = {}) {
+  const nblk = K / 32;
+  // random Gaussian weights + input (a realistic single layer matmul)
+  let s = 1234567; const rnd = () => (s = (s * 1664525 + 1013904223) >>> 0) / 4294967296;
+  const gauss = () => { const u = Math.max(1e-12, rnd()); return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * rnd()); };
+  // heavy-tailed weights like real LLM layers (kurtosis ≫ 3): a Gaussian bulk plus sparse large spikes —
+  // the outliers that wreck naive low-bit quantization and that incoherence (the Hadamard) spreads out.
+  const W = new Float32Array(N * K); for (let i = 0; i < N * K; i++) { let w = gauss() * 0.05; if (rnd() < 0.02) w *= 6; W[i] = w; }
+  const x = new Float32Array(K); for (let i = 0; i < K; i++) x[i] = gauss();
+  // f32 reference y = W·x
+  const yref = new Float32Array(N); for (let n = 0; n < N; n++) { let a = 0; for (let k = 0; k < K; k++) a += W[n * K + k] * x[k]; yref[n] = a; }
+  const relErr = (y) => { let e = 0, r = 0; for (let n = 0; n < N; n++) { const d = y[n] - yref[n]; e += d * d; r += yref[n] * yref[n]; } return Math.sqrt(e / r); };
+
+  // pack incoherent 2-bit + naive 2-bit + Q8 (per-32 scale, the engine format)
+  const inc = pack2bit(W, N, K, { incoherent: true });
+  const nai = pack2bit(W, N, K, { incoherent: false });
+  const q8 = new Int8Array(N * K), q8s = new Float32Array(N * nblk);
+  for (let n = 0; n < N; n++) for (let b = 0; b < nblk; b++) { let mx = 0; for (let i = 0; i < 32; i++) { const a = Math.abs(W[n * K + b * 32 + i]); if (a > mx) mx = a; } const sca = (mx / 127) || 1e-12; q8s[n * nblk + b] = sca; for (let i = 0; i < 32; i++) { let q = Math.round(W[n * K + b * 32 + i] / sca); if (q > 127) q = 127; else if (q < -127) q = -127; q8[n * K + b * 32 + i] = q; } }
+
+  // GPU pipelines
+  const pF = pipe(dev, FWHT_WGSL), p2 = pipe(dev, MM2_WGSL), p8 = pipe(dev, MM8_WGSL);
+  // buffers
+  const xB = sbuf(dev, x), xrB = obuf(dev, K * 4), sgnB = sbuf(dev, inc.sign), Pf = ubuf(dev, new Uint32Array([K, 0, 0, 0]));
+  const qwB = sbuf(dev, inc.qw), scB = sbuf(dev, inc.sc), oB = obuf(dev, N * 4), P2 = ubuf(dev, new Uint32Array([N, K, nblk, 0]));
+  const naiqwB = sbuf(dev, nai.qw), naiscB = sbuf(dev, nai.sc), oNB = obuf(dev, N * 4);
+  const q8B = sbuf(dev, new Uint8Array(q8.buffer)), q8sB = sbuf(dev, q8s), o8B = obuf(dev, N * 4);
+
+  const bgF = (xin) => dev.createBindGroup({ layout: pF.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: xin } }, { binding: 1, resource: { buffer: sgnB } }, { binding: 2, resource: { buffer: xrB } }, { binding: 3, resource: { buffer: Pf } }] });
+  const bg2 = (qw, sc, xin, o) => dev.createBindGroup({ layout: p2.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: qw } }, { binding: 1, resource: { buffer: sc } }, { binding: 2, resource: { buffer: xin } }, { binding: 3, resource: { buffer: o } }, { binding: 4, resource: { buffer: P2 } }] });
+  const bg8 = dev.createBindGroup({ layout: p8.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: q8B } }, { binding: 1, resource: { buffer: q8sB } }, { binding: 2, resource: { buffer: xB } }, { binding: 3, resource: { buffer: o8B } }, { binding: 4, resource: { buffer: P2 } }] });
+
+  // ── correctness ──
+  const doInc = K <= 4096;                               // single-workgroup FWHT covers K ≤ 4096 (16 KB shared)
+  let yInc = null, gpuCpu = null;
+  if (doInc) {
+    // incoherent path: GPU rotate x→x′, then 2-bit matmul with x′
+    { const e = dev.createCommandEncoder(); const p = e.beginComputePass(); p.setPipeline(pF); p.setBindGroup(0, bgF(xB)); p.dispatchWorkgroups(1); p.setPipeline(p2); p.setBindGroup(0, bg2(qwB, scB, xrB, oB)); p.dispatchWorkgroups(N); p.end(); dev.queue.submit([e.finish()]); }
+    yInc = await readf32(dev, oB, N);
+    // CPU re-derivation of the SAME stored 2-bit weights — independent check the GPU kernel agrees
+    const Wrec = unpack2bit(inc.qw, inc.sc, inc.sign, N, K, { incoherent: true });
+    const yCpu = new Float32Array(N); for (let n = 0; n < N; n++) { let a = 0; for (let k = 0; k < K; k++) a += Wrec[n * K + k] * x[k]; yCpu[n] = a; }
+    let e2 = 0, rr = 0; for (let n = 0; n < N; n++) { const d = yInc[n] - yCpu[n]; e2 += d * d; rr += yCpu[n] * yCpu[n]; } gpuCpu = Math.sqrt(e2 / rr);
+  }
+  // naive path (no rotation) + Q8 path
+  { const e = dev.createCommandEncoder(); const p = e.beginComputePass(); p.setPipeline(p2); p.setBindGroup(0, bg2(naiqwB, naiscB, xB, oNB)); p.dispatchWorkgroups(N); p.end(); dev.queue.submit([e.finish()]); }
+  const yNai = await readf32(dev, oNB, N);
+  { const e = dev.createCommandEncoder(); const p = e.beginComputePass(); p.setPipeline(p8); p.setBindGroup(0, bg8); p.dispatchWorkgroups(N); p.end(); dev.queue.submit([e.finish()]); }
+  const yQ8 = await readf32(dev, o8B, N);
+
+  // ── perf — apples-to-apples: time each MATMUL alone (incoherence rotation measured separately) ──
+  // pre-rotate x once so the 2-bit matmul reads x′ without re-running the FWHT in the timed loop.
+  if (doInc) { const e = dev.createCommandEncoder(); const p = e.beginComputePass(); p.setPipeline(pF); p.setBindGroup(0, bgF(xB)); p.dispatchWorkgroups(1); p.end(); dev.queue.submit([e.finish()]); }
+  const time = async (fn) => { fn(); await dev.queue.onSubmittedWorkDone(); const t0 = performance.now(); for (let i = 0; i < iters; i++) fn(); await dev.queue.onSubmittedWorkDone(); return (performance.now() - t0) / iters; };
+  const run2mm = () => { const e = dev.createCommandEncoder(); const p = e.beginComputePass(); p.setPipeline(p2); p.setBindGroup(0, bg2(qwB, scB, doInc ? xrB : xB, oB)); p.dispatchWorkgroups(N); p.end(); dev.queue.submit([e.finish()]); };
+  const run8mm = () => { const e = dev.createCommandEncoder(); const p = e.beginComputePass(); p.setPipeline(p8); p.setBindGroup(0, bg8); p.dispatchWorkgroups(N); p.end(); dev.queue.submit([e.finish()]); };
+  const runF = () => { const e = dev.createCommandEncoder(); const p = e.beginComputePass(); p.setPipeline(pF); p.setBindGroup(0, bgF(xB)); p.dispatchWorkgroups(1); p.end(); dev.queue.submit([e.finish()]); };
+  const ms2 = await time(run2mm), ms8 = await time(run8mm), msF = doInc ? await time(runF) : null;
+
+  const bytes2 = inc.qw.byteLength + inc.sc.byteLength, bytes8 = q8.byteLength + q8s.byteLength;
+  const gbps = (b, ms) => (b / 1e9) / (ms / 1e3);
+  return {
+    N, K, iters,
+    err: { incoherent2bit: doInc ? relErr(yInc) : null, naive2bit: relErr(yNai), q8: relErr(yQ8), gpu_vs_cpu_2bit: gpuCpu },
+    perf: { ms_2bit_mm: +ms2.toFixed(4), ms_q8_mm: +ms8.toFixed(4), ms_fwht: msF == null ? null : +msF.toFixed(4), matmul_speedup: +(ms8 / ms2).toFixed(2), gbps_2bit: +gbps(bytes2, ms2).toFixed(0), gbps_q8: +gbps(bytes8, ms8).toFixed(0) },
+    mem: { MB_2bit: +(bytes2 / 1e6).toFixed(2), MB_q8: +(bytes8 / 1e6).toFixed(2), ratio: +(bytes8 / bytes2).toFixed(2), bits_per_weight: +(bytes2 * 8 / (N * K)).toFixed(2) },
+  };
+}

qvac-ingest.mjs

@@ -0,0 +1,561 @@
+// QVAC disk-streaming GGUF ingestion — pure JS, no wasm in the weight path.
+//
+// The wasm path holds the whole GGUF in wasm32 linear memory (~4 GB ceiling), so
+// it can't ingest a 7B/14B model. This module reads a large GGUF straight off disk
+// (HTTP Range against the served file) and converts each tensor to the engine's
+// block format ON DEMAND, so RAM never holds more than one tensor at a time.
+//
+// It is a faithful port of qvac-gguf::dequantize_raw + qvac-layer::quant_blocks +
+// model_specs, so the bytes it produces are what the GPU engine already consumes.
+// The tokenizer stays in wasm: we feed wasm only the GGUF HEADER (the first
+// data_offset bytes), which is all qvac_load_gpu needs for the BPE + manifest.
+
+import { makeIQ } from "./forge/gguf-forge-iq-dequant.mjs";
+
+// ── f16 → f32 (matches qvac_gguf::f16_to_f32) ──
+export function f16ToF32(h) {
+  const sign = (h >> 15) & 1, exp = (h >> 10) & 0x1f, mant = h & 0x3ff;
+  let val;
+  if (exp === 0) val = mant * Math.pow(2, -24);
+  else if (exp === 0x1f) return mant ? NaN : (sign ? -Infinity : Infinity);
+  else val = (1 + mant / 1024) * Math.pow(2, exp - 15);
+  return sign ? -val : val;
+}
+
+const QK = 32, QK_K = 256;
+export const GGML = {
+  F32: 0, F16: 1, Q4_0: 2, Q4_1: 3, Q8_0: 8, Q2_K: 10, Q3_K: 11, Q4_K: 12, Q5_K: 13, Q6_K: 14,
+  IQ2_XXS: 16, IQ2_XS: 17, IQ3_XXS: 18, IQ1_S: 19, IQ4_NL: 20, IQ3_S: 21, IQ2_S: 22, IQ4_XS: 23, IQ1_M: 29,
+  TQ2_0: 35,
+};
+// IQ-quant byte layouts: [block elements, block bytes]. (ggml-common.h:485-563)
+const IQ_BLOCK = {
+  16: [QK_K, 66], 17: [QK_K, 74], 18: [QK_K, 98], 19: [QK_K, 50], 20: [32, 18],
+  21: [QK_K, 110], 22: [QK_K, 82], 23: [QK_K, 136], 29: [QK_K, 56],
+};
+// BitNet ternary TQ2_0 (ggml-common.h:273): qs[64] + f16 d = 66 B / 256. Runtime
+// dequant is float64 (the Tier-A oracle gguf-forge-dequant.mjs is the bit-exact ref).
+const TQ_BLOCK = { 35: [QK_K, 66] };
+function dequantTq2_0Rt(raw, elements) {
+  const out = new Float32Array(elements);
+  const nb = elements / QK_K;
+  const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+  let o = 0, base = 0;
+  for (let i = 0; i < nb; ++i) {
+    const d = f16ToF32(dv.getUint16(base + 64, true));
+    for (let j = 0; j < 64; j += 32)
+      for (let l = 0; l < 4; ++l)
+        for (let m = 0; m < 32; ++m) out[o++] = (((raw[base + j + m] >> (l * 2)) & 3) - 1) * d;
+    base += 66;
+  }
+  return out;
+}
+const TQ_RT = { 35: dequantTq2_0Rt };
+// Runtime IQ dequant (float64; the Tier-A oracle is the bit-exact reference).
+const _iq = makeIQ((x) => x, f16ToF32);
+const IQ_RT = {
+  16: _iq.dequantIQ2XXS, 17: _iq.dequantIQ2XS, 18: _iq.dequantIQ3XXS, 19: _iq.dequantIQ1S,
+  20: _iq.dequantIQ4NL, 21: _iq.dequantIQ3S, 22: _iq.dequantIQ2S, 23: _iq.dequantIQ4XS, 29: _iq.dequantIQ1M,
+};
+
+// On-disk byte length of `elements` of a ggml type (matches type_byte_len).
+export function typeByteLen(t, elements) {
+  switch (t) {
+    case GGML.F32: return elements * 4;
+    case GGML.F16: return elements * 2;
+    case GGML.Q8_0: return (elements / QK) * (2 + QK);
+    case GGML.Q4_0: return (elements / QK) * (2 + QK / 2);
+    case GGML.Q4_1: return (elements / QK) * (2 + 2 + QK / 2);
+    case GGML.Q2_K: return (elements / QK_K) * 84;
+    case GGML.Q3_K: return (elements / QK_K) * 110;
+    case GGML.Q4_K: return (elements / QK_K) * 144;
+    case GGML.Q5_K: return (elements / QK_K) * 176;
+    case GGML.Q6_K: return (elements / QK_K) * 210;
+    default:
+      if (t in IQ_BLOCK) { const [be, bb] = IQ_BLOCK[t]; return (elements / be) * bb; }
+      if (t in TQ_BLOCK) { const [be, bb] = TQ_BLOCK[t]; return (elements / be) * bb; }
+      throw new Error("unsupported ggml type " + t);
+  }
+}
+// (block elements, block bytes) for the range reader.
+function blockShape(t) {
+  switch (t) {
+    case GGML.F32: return [1, 4];
+    case GGML.F16: return [1, 2];
+    case GGML.Q8_0: return [QK, 2 + QK];
+    case GGML.Q4_0: return [QK, 2 + QK / 2];
+    case GGML.Q4_1: return [QK, 2 + 2 + QK / 2];
+    case GGML.Q2_K: return [QK_K, 84];
+    case GGML.Q3_K: return [QK_K, 110];
+    case GGML.Q4_K: return [QK_K, 144];
+    case GGML.Q5_K: return [QK_K, 176];
+    case GGML.Q6_K: return [QK_K, 210];
+    default:
+      if (t in IQ_BLOCK) return IQ_BLOCK[t];
+      if (t in TQ_BLOCK) return TQ_BLOCK[t];
+      throw new Error("unsupported ggml type " + t);
+  }
+}
+
+// Dequantize raw tensor bytes → Float32Array (port of dequantize_raw).
+export function dequantizeRaw(t, raw, elements) {
+  const out = new Float32Array(elements);
+  const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+  let o = 0;
+  if (t === GGML.F32) {
+    for (let i = 0; i < elements; i++) out[i] = dv.getFloat32(i * 4, true);
+  } else if (t === GGML.F16) {
+    for (let i = 0; i < elements; i++) out[i] = f16ToF32(dv.getUint16(i * 2, true));
+  } else if (t === GGML.Q8_0) {
+    const bb = 2 + QK;
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const d = f16ToF32(dv.getUint16(p, true));
+      for (let j = 0; j < QK; j++) out[o++] = d * (raw[p + 2 + j] << 24 >> 24);
+    }
+  } else if (t === GGML.Q4_0) {
+    const bb = 2 + QK / 2;
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const d = f16ToF32(dv.getUint16(p, true));
+      const qs = p + 2;
+      for (let j = 0; j < QK / 2; j++) out[o + j] = d * ((raw[qs + j] & 0x0f) - 8);       // low nibble → j
+      for (let j = 0; j < QK / 2; j++) out[o + QK / 2 + j] = d * ((raw[qs + j] >> 4) - 8); // high → j+16
+      o += QK;
+    }
+  } else if (t === GGML.Q4_1) {
+    const bb = 2 + 2 + QK / 2;
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const d = f16ToF32(dv.getUint16(p, true)), m = f16ToF32(dv.getUint16(p + 2, true));
+      const qs = p + 4;
+      for (let j = 0; j < QK / 2; j++) out[o + j] = (raw[qs + j] & 0x0f) * d + m;
+      for (let j = 0; j < QK / 2; j++) out[o + QK / 2 + j] = (raw[qs + j] >> 4) * d + m;
+      o += QK;
+    }
+  } else if (t === GGML.Q4_K) {
+    // Q4_K: 256-element super-block of 144 B = d(f16) + dmin(f16) + 12 packed 6-bit scales/mins + 128 nibble qs.
+    const bb = 144;
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const d = f16ToF32(dv.getUint16(p, true)), dmin = f16ToF32(dv.getUint16(p + 2, true));
+      const sc = p + 4, qs = p + 16;
+      const sm = (j) => j < 4 ? [raw[sc + j] & 63, raw[sc + j + 4] & 63]
+                              : [(raw[sc + j + 4] & 0xF) | ((raw[sc + j - 4] >> 6) << 4), (raw[sc + j + 4] >> 4) | ((raw[sc + j] >> 6) << 4)];
+      let q = 0, is = 0;
+      for (let j = 0; j < QK_K; j += 64) {
+        const [s1, m1] = sm(is), [s2, m2] = sm(is + 1);
+        for (let l = 0; l < 32; l++) out[o + l] = d * s1 * (raw[qs + q + l] & 0xF) - dmin * m1;
+        for (let l = 0; l < 32; l++) out[o + 32 + l] = d * s2 * (raw[qs + q + l] >> 4) - dmin * m2;
+        o += 64; q += 32; is += 2;
+      }
+    }
+  } else if (t === GGML.Q6_K) {
+    const bb = 210;
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const ql = p, qh = p + 128, sc = p + 192, d = f16ToF32(dv.getUint16(p + 208, true));
+      for (let n = 0; n < 2; n++) {
+        const qlo = ql + n * 64, qho = qh + n * 32, sco = sc + n * 8, yo = o + n * 128;
+        for (let l = 0; l < 32; l++) {
+          const is = (l / 16) | 0;
+          const q1 = ((raw[qlo + l] & 0x0f) | (((raw[qho + l] >> 0) & 3) << 4)) - 32;
+          const q2 = ((raw[qlo + l + 32] & 0x0f) | (((raw[qho + l] >> 2) & 3) << 4)) - 32;
+          const q3 = ((raw[qlo + l] >> 4) | (((raw[qho + l] >> 4) & 3) << 4)) - 32;
+          const q4 = ((raw[qlo + l + 32] >> 4) | (((raw[qho + l] >> 6) & 3) << 4)) - 32;
+          out[yo + l] = d * (raw[sco + is] << 24 >> 24) * q1;
+          out[yo + l + 32] = d * (raw[sco + is + 2] << 24 >> 24) * q2;
+          out[yo + l + 64] = d * (raw[sco + is + 4] << 24 >> 24) * q3;
+          out[yo + l + 96] = d * (raw[sco + is + 6] << 24 >> 24) * q4;
+        }
+      }
+      o += QK_K;
+    }
+  } else if (t === GGML.Q2_K) {
+    // 84 B: scales[16] qs[64] d(f16) dmin(f16). y = d*(sc&0xF)*q2 - dmin*(sc>>4).
+    const bb = 84;
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const sc = p, qs = p + 16, d = f16ToF32(dv.getUint16(p + 80, true)), dmin = f16ToF32(dv.getUint16(p + 82, true));
+      let is = 0;
+      for (let n = 0; n < QK_K; n += 128) {
+        const q = qs + (n >> 7) * 32;
+        for (let shift = 0; shift < 8; shift += 2) {
+          let s = raw[sc + is++];
+          for (let l = 0; l < 16; l++) out[o++] = d * (s & 0xf) * ((raw[q + l] >> shift) & 3) - dmin * (s >> 4);
+          s = raw[sc + is++];
+          for (let l = 0; l < 16; l++) out[o++] = d * (s & 0xf) * ((raw[q + l + 16] >> shift) & 3) - dmin * (s >> 4);
+        }
+      }
+    }
+  } else if (t === GGML.Q3_K) {
+    // 110 B: hmask[32] qs[64] scales[12] d(f16). 6-bit signed scales via kmask unpack.
+    const bb = 110, km1 = 0x03030303, km2 = 0x0f0f0f0f;
+    const aux = new Uint32Array(4), sb = new Int8Array(aux.buffer);
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const hm = p, qs = p + 32, sco = p + 96, d = f16ToF32(dv.getUint16(p + 108, true));
+      aux[0] = dv.getUint32(sco, true); aux[1] = dv.getUint32(sco + 4, true); aux[2] = dv.getUint32(sco + 8, true);
+      const tmp = aux[2];
+      aux[2] = ((aux[0] >>> 4) & km2) | (((tmp >>> 4) & km1) << 4);
+      aux[3] = ((aux[1] >>> 4) & km2) | (((tmp >>> 6) & km1) << 4);
+      aux[0] = (aux[0] & km2) | (((tmp >>> 0) & km1) << 4);
+      aux[1] = (aux[1] & km2) | (((tmp >>> 2) & km1) << 4);
+      let is = 0, m = 1;
+      for (let n = 0; n < QK_K; n += 128) {
+        const q = qs + (n >> 7) * 32;
+        for (let shift = 0; shift < 8; shift += 2) {
+          let dl = d * (sb[is++] - 32);
+          for (let l = 0; l < 16; l++) out[o++] = dl * (((raw[q + l] >> shift) & 3) - ((raw[hm + l] & m) ? 0 : 4));
+          dl = d * (sb[is++] - 32);
+          for (let l = 0; l < 16; l++) out[o++] = dl * (((raw[q + l + 16] >> shift) & 3) - ((raw[hm + l + 16] & m) ? 0 : 4));
+          m <<= 1;
+        }
+      }
+    }
+  } else if (t === GGML.Q5_K) {
+    // 176 B: d(f16) dmin(f16) scales[12] qh[32] ql[128]. Q4_K nibbles + 5th bit from qh.
+    const bb = 176;
+    const smk4 = (sc, j) => j < 4 ? [raw[sc + j] & 63, raw[sc + j + 4] & 63]
+                                  : [(raw[sc + j + 4] & 0xF) | ((raw[sc + j - 4] >> 6) << 4), (raw[sc + j + 4] >> 4) | ((raw[sc + j] >> 6) << 4)];
+    for (let p = 0; p + bb <= raw.byteLength; p += bb) {
+      const d = f16ToF32(dv.getUint16(p, true)), dmin = f16ToF32(dv.getUint16(p + 2, true));
+      const sc = p + 4, qh = p + 16; let ql = p + 48, is = 0, u1 = 1, u2 = 2;
+      for (let j = 0; j < QK_K; j += 64) {
+        const [s1, m1] = smk4(sc, is), [s2, m2] = smk4(sc, is + 1);
+        const d1 = d * s1, mm1 = dmin * m1, d2 = d * s2, mm2 = dmin * m2;
+        for (let l = 0; l < 32; l++) out[o++] = d1 * ((raw[ql + l] & 0xF) + ((raw[qh + l] & u1) ? 16 : 0)) - mm1;
+        for (let l = 0; l < 32; l++) out[o++] = d2 * ((raw[ql + l] >> 4) + ((raw[qh + l] & u2) ? 16 : 0)) - mm2;
+        ql += 32; is += 2; u1 <<= 2; u2 <<= 2;
+      }
+    }
+  } else if (t in IQ_RT) {
+    return IQ_RT[t](raw, elements); // IQ-quants (float64 runtime; oracle is the bit-exact ref)
+  } else if (t in TQ_RT) {
+    return TQ_RT[t](raw, elements); // BitNet TQ2_0 (float64 runtime; oracle is the bit-exact ref)
+  } else throw new Error("unsupported ggml type " + t);
+  return out;
+}
+
+// Re-quantize a [n,k] f32 tensor into the engine's per-32-block format
+// (port of qvac-layer::quant_blocks). bits=4 → (nibble-8)*scale, scale=amax/7,
+// sequential nibble packing; bits=8 → int8, scale=amax/127. Returns {q,s}.
+// Arithmetic is done in f32 (Math.fround) with round-half-away-from-zero to match
+// Rust's f32 `round()` byte-for-byte, so the frames are bit-identical to wasm's.
+const fr = Math.fround;
+const rnd = (x) => x >= 0 ? Math.floor(x + 0.5) : Math.ceil(x - 0.5); // half away from zero (Rust f32::round)
+export function quantBlocks(f, n, k, bits) {
+  const nb = k / 32;
+  const s = new Float32Array(n * nb);
+  let si = 0;
+  if (bits === 4) {
+    const q = new Uint8Array(n * k / 2);
+    for (let row = 0; row < n; row++) {
+      const base = row * k;
+      for (let b = 0; b < nb; b++) {
+        const bo = base + b * 32;
+        let amax = 0; for (let j = 0; j < 32; j++) { const a = Math.abs(f[bo + j]); if (a > amax) amax = a; }
+        amax = Math.max(amax, 1e-9); const scale = fr(amax / 7); s[si++] = scale;
+        for (let j = 0; j < 32; j++) {
+          let qv = rnd(fr(f[bo + j] / scale)); qv = qv < -8 ? -8 : qv > 7 ? 7 : qv; qv = (qv + 8) & 0xf;
+          const g = bo + j;
+          if ((g & 1) === 0) q[g >> 1] |= qv; else q[g >> 1] |= qv << 4;
+        }
+      }
+    }
+    return { q, s };
+  } else {
+    const q = new Uint8Array(n * k);
+    for (let row = 0; row < n; row++) {
+      const base = row * k;
+      for (let b = 0; b < nb; b++) {
+        const bo = base + b * 32;
+        let amax = 0; for (let j = 0; j < 32; j++) { const a = Math.abs(f[bo + j]); if (a > amax) amax = a; }
+        amax = Math.max(amax, 1e-9); const scale = fr(amax / 127); s[si++] = scale;
+        for (let j = 0; j < 32; j++) { let qv = rnd(fr(f[bo + j] / scale)); qv = qv < -127 ? -127 : qv > 127 ? 127 : qv; q[bo + j] = qv & 0xff; }
+      }
+    }
+    return { q, s };
+  }
+}
+
+// FAST PATH: GGUF Q4_0 → engine Q4 with NO dequant/requant — a pure relayout.
+// GGUF Q4_0 already stores (nibble-8)*d, exactly the engine's convention, so the
+// nibble value maps straight across; we only reorder the interleaved (j, j+16)
+// nibbles into the engine's sequential packing and widen the f16 scale to f32.
+// This is both faster (integer-only) and bit-exact to the GGUF (no requant loss).
+export function relayoutQ4(raw, n, k) {
+  const nb = k / 32;
+  const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+  const q = new Uint8Array(n * k / 2), s = new Float32Array(n * nb);
+  let bo = 0, si = 0;
+  for (let row = 0; row < n; row++) {
+    const rowBase = row * k;
+    for (let b = 0; b < nb; b++) {
+      s[si++] = f16ToF32(dv.getUint16(bo, true));
+      const qs = bo + 2, blkBase = rowBase + b * 32;
+      for (let w = 0; w < 32; w++) {
+        const nib = w < 16 ? (raw[qs + w] & 0x0f) : (raw[qs + (w - 16)] >> 4);
+        const g = blkBase + w;
+        if ((g & 1) === 0) q[g >> 1] |= nib; else q[g >> 1] |= nib << 4;
+      }
+      bo += 18;
+    }
+  }
+  return { q, s };
+}
+// FAST PATH: GGUF Q8_0 → engine Q8 — copy the i8 quants, widen f16 scale to f32.
+export function relayoutQ8(raw, n, k) {
+  const nb = k / 32;
+  const dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+  const q = new Uint8Array(n * k), s = new Float32Array(n * nb);
+  let bo = 0, si = 0, qi = 0;
+  for (let row = 0; row < n; row++) {
+    for (let b = 0; b < nb; b++) {
+      s[si++] = f16ToF32(dv.getUint16(bo, true));
+      for (let w = 0; w < 32; w++) q[qi++] = raw[bo + 2 + w];
+      bo += 34;
+    }
+  }
+  return { q, s };
+}
+
+// ── GGUF header parser (just enough: tensor directory + data offset) ──
+class Cur {
+  constructor(buf) { this.b = buf; this.dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength); this.p = 0; this.v1 = false; }
+  need(n) { if (this.p + n > this.b.byteLength) throw new RangeError("short"); }
+  u8() { this.need(1); return this.b[this.p++]; }
+  u16() { this.need(2); const v = this.dv.getUint16(this.p, true); this.p += 2; return v; }
+  u32() { this.need(4); const v = this.dv.getUint32(this.p, true); this.p += 4; return v; }
+  u64() { this.need(8); const lo = this.dv.getUint32(this.p, true), hi = this.dv.getUint32(this.p + 4, true); this.p += 8; return hi * 4294967296 + lo; }
+  lenField() { return this.v1 ? this.u32() : this.u64(); }
+  skipStr() { const n = this.lenField(); this.need(n); this.p += n; }
+  skipValue(ty) {
+    switch (ty) {
+      case 0: case 1: case 7: this.p += 1; break;
+      case 2: case 3: this.p += 2; break;
+      case 4: case 5: case 6: this.p += 4; break;
+      case 10: case 11: case 12: this.p += 8; break;
+      case 8: this.skipStr(); break;
+      case 9: { const ety = this.u32(); const cnt = this.lenField(); for (let i = 0; i < cnt; i++) this.skipValue(ety); break; }
+      default: throw new Error("bad meta type " + ty);
+    }
+  }
+  // Read a SCALAR metadata value (numbers/bool/string); arrays are skipped (return undefined).
+  readScalar(ty) {
+    switch (ty) {
+      case 0: return this.u8();
+      case 1: { const v = this.u8(); return v << 24 >> 24; }
+      case 2: return this.u16();
+      case 3: { const v = this.u16(); return v << 16 >> 16; }
+      case 4: return this.u32();
+      case 5: { const v = this.u32(); return v | 0; }
+      case 6: { this.need(4); const v = this.dv.getFloat32(this.p, true); this.p += 4; return v; }
+      case 7: return this.u8() !== 0;
+      case 8: { const n = this.lenField(); const s = new TextDecoder().decode(this.b.subarray(this.p, this.p + n)); this.p += n; return s; }
+      case 10: return this.u64();
+      case 11: return this.u64();
+      case 12: { this.need(8); const v = this.dv.getFloat64(this.p, true); this.p += 8; return v; }
+      case 9: { const ety = this.u32(); const cnt = this.lenField(); for (let i = 0; i < cnt; i++) this.skipValue(ety); return undefined; }
+      default: throw new Error("bad meta type " + ty);
+    }
+  }
+}
+
+// Parse a GGUF header buffer → { version, dataOffset, tensors:[{name,dims,ggmlType,offset}] }.
+// `buf` must contain at least up to the (aligned) end of the tensor-info table.
+export function parseGgufHeader(buf) {
+  const c = new Cur(buf);
+  if (c.u32() !== 0x46554747) throw new Error("not GGUF");
+  const version = c.u32();
+  if (version !== 1 && version !== 2 && version !== 3) throw new Error("GGUF version " + version);
+  c.v1 = version === 1;
+  const tensorCount = c.lenField();
+  const metaCount = c.lenField();
+  let alignment = 32;
+  const meta = {};
+  for (let i = 0; i < metaCount; i++) {
+    const keyLen = c.lenField(); const key = new TextDecoder().decode(buf.subarray(c.p, c.p + keyLen)); c.p += keyLen;
+    const ty = c.u32();
+    const v = c.readScalar(ty);                          // arrays → undefined (skipped)
+    if (v !== undefined) meta[key] = v;
+    if (key === "general.alignment" && typeof v === "number") alignment = v;
+  }
+  const tensors = [];
+  for (let i = 0; i < tensorCount; i++) {
+    const nl = c.lenField(); const name = new TextDecoder().decode(buf.subarray(c.p, c.p + nl)); c.p += nl;
+    const nd = c.u32(); const dims = []; for (let j = 0; j < nd; j++) dims.push(c.lenField());
+    const ggmlType = c.u32(); const offset = c.u64();
+    tensors.push({ name, dims, ggmlType, offset });
+  }
+  alignment = Math.max(1, alignment);
+  const dataOffset = Math.ceil(c.p / alignment) * alignment;
+  return { version, dataOffset, tensors, meta };
+}
+
+// Build the engine manifest (dims + tensor list with N,K,blk) from a parsed GGUF
+// header — a pure-JS port of qvac-layer::model_specs + gpu_export_manifest, so
+// conversion/streaming needs no wasm. `tensors` is the header's tensor directory.
+export function buildManifest(meta, tensors, bits) {
+  const arch = meta["general.architecture"] || "llama";
+  const mu = (k) => { const v = meta[`${arch}.${k}`]; return typeof v === "number" ? Math.round(v) : undefined; };
+  const tset = new Set(tensors.map((t) => t.name));
+  const tbyname = {}; for (const t of tensors) tbyname[t.name] = t;
+  const d = mu("embedding_length") || 0;
+  const n_layers = mu("block_count") || 0;
+  const n_heads = mu("attention.head_count") || 0;
+  const n_kv_heads = mu("attention.head_count_kv") || n_heads;
+  // For MoE, the experts use expert_feed_forward_length (e.g. Qwen3-30B-A3B: 768),
+  // which differs from the (unused) dense feed_forward_length (6144). OLMoE's two
+  // values happen to be equal. `ff` everywhere downstream means the EXPERT ff for MoE.
+  const ff = (mu("expert_feed_forward_length") || mu("feed_forward_length")) || 0;
+  const hd = mu("attention.key_length") || (n_heads ? Math.floor(d / n_heads) : 0);
+  const kv_dim = n_kv_heads * hd;
+  const rope_base = (typeof meta[`${arch}.rope.freq_base`] === "number") ? meta[`${arch}.rope.freq_base`] : 10000;
+  const attn_bias = tset.has("blk.0.attn_q.bias");
+  const qk_norm = tset.has("blk.0.attn_q_norm.weight");
+  const qk_norm_dim = qk_norm ? (tbyname["blk.0.attn_q_norm.weight"].dims[0] | 0) : 0; // hd (per-head, Qwen3) or d (full, OLMoE)
+  const n_experts = mu("expert_count") || 0;               // >0 → MoE
+  const n_used = mu("expert_used_count") || 0;
+  const moe = n_experts > 0;
+  const bitnet = /^bitnet/.test(arch);                     // BitNet b1.58: sub-norms before wo/w_down + ReLU² gated FFN
+  const tied = !tset.has("output.weight");
+  const vocab = d > 0 && tbyname["token_embd.weight"] ? Math.floor(tbyname["token_embd.weight"].dims.reduce((a, b) => a * b, 1) / d) : 0;
+  const blk = (name, N, K) => ({ name, N, K, blk: true });
+  const nrm = (name, K) => ({ name, N: 1, K, blk: false });
+  const t = [];
+  t.push(blk("embed", vocab, d));
+  t.push(nrm("final_norm", d));
+  t.push(blk("lm_head", vocab, d));
+  for (let i = 0; i < n_layers; i++) {
+    t.push(nrm(`l${i}.attn_norm`, d));
+    t.push(blk(`l${i}.wq`, n_heads * hd, d));
+    t.push(blk(`l${i}.wk`, kv_dim, d));
+    t.push(blk(`l${i}.wv`, kv_dim, d));
+    if (attn_bias) { t.push(nrm(`l${i}.bq`, n_heads * hd)); t.push(nrm(`l${i}.bk`, kv_dim)); t.push(nrm(`l${i}.bv`, kv_dim)); }
+    if (qk_norm) { t.push(nrm(`l${i}.q_norm`, qk_norm_dim)); t.push(nrm(`l${i}.k_norm`, qk_norm_dim)); }
+    if (bitnet) t.push(nrm(`l${i}.attn_sub_norm`, n_heads * hd));
+    t.push(blk(`l${i}.wo`, d, n_heads * hd));
+    t.push(nrm(`l${i}.ffn_norm`, d));
+    if (bitnet) t.push(nrm(`l${i}.ffn_sub_norm`, ff));
+    if (moe) {
+      t.push(nrm(`l${i}.router`, n_experts * d));          // ffn_gate_inp [n_experts, d] f32 (CPU top-k)
+      // experts are NOT enumerated here (n_layers·n_experts·3 is huge); the engine
+      // generates `l{i}.e{e}.{gate,up,down}` names for the top-k it actually needs.
+    } else {
+      t.push(blk(`l${i}.w_gate`, ff, d));
+      t.push(blk(`l${i}.w_up`, ff, d));
+      t.push(blk(`l${i}.w_down`, d, ff));
+    }
+  }
+  const out = { d, n_heads, n_kv_heads, ff, vocab, n_layers, hd, bits, rope_base, attn_bias, qk_norm, qk_norm_dim, tied, tensors: t };
+  if (moe) out.moe = { n_experts, n_used };
+  if (bitnet) { out.sub_norm = true; out.ffn_act = "relu2"; }
+  return out;
+}
+
+// engine tensor name → GGUF tensor name (mirror of model_specs).
+export function ggufNameFor(name, hasOutputWeight) {
+  if (name === "embed") return "token_embd.weight";
+  if (name === "final_norm") return "output_norm.weight";
+  if (name === "lm_head") return hasOutputWeight ? "output.weight" : "token_embd.weight";
+  const m = name.match(/^l(\d+)\.(.+)$/); if (!m) return null;
+  const i = m[1], r = m[2], p = `blk.${i}.`;
+  const map = {
+    "attn_norm": "attn_norm.weight", "ffn_norm": "ffn_norm.weight",
+    "attn_sub_norm": "attn_sub_norm.weight", "ffn_sub_norm": "ffn_sub_norm.weight",
+    "wq": "attn_q.weight", "wk": "attn_k.weight", "wv": "attn_v.weight", "wo": "attn_output.weight",
+    "bq": "attn_q.bias", "bk": "attn_k.bias", "bv": "attn_v.bias",
+    "q_norm": "attn_q_norm.weight", "k_norm": "attn_k_norm.weight",
+    "w_gate": "ffn_gate.weight", "w_up": "ffn_up.weight", "w_down": "ffn_down.weight",
+  };
+  return map[r] ? p + map[r] : null;
+}
+
+// Read the GGUF header from `url` (HTTP Range), growing the read until the tensor
+// table fits. Returns { dataOffset, tensors, headerBytes } (headerBytes = the first
+// dataOffset bytes, to hand to wasm qvac_load_gpu for the tokenizer + manifest).
+export async function readHeader(url, readRange, initial = 48 * 1024 * 1024) {
+  let n = initial, parsed = null, buf = null;
+  for (let tries = 0; tries < 6; tries++) {
+    buf = await readRange(url, 0, n);
+    try { parsed = parseGgufHeader(buf); break; } catch (e) { if (e instanceof RangeError || /short/.test(String(e))) { n *= 2; continue; } throw e; }
+  }
+  if (!parsed) throw new Error("could not parse GGUF header");
+  const headerBytes = buf.length >= parsed.dataOffset ? buf.subarray(0, parsed.dataOffset) : await readRange(url, 0, parsed.dataOffset);
+  return { dataOffset: parsed.dataOffset, tensors: parsed.tensors, headerBytes };
+}
+
+// Build the per-tensor fetcher the GPU engine consumes. `manifest` is the wasm
+// manifest (dims + tensors with N,K,blk). Returns fetchTensor(name) → Uint8Array,
+// byte-identical to what qvac_gpu_tensor would return — but sourced from disk.
+export function makeDiskFetcher({ url, readRange, dataOffset, tensors, manifest, bits }) {
+  const tdir = {}; for (const t of tensors) tdir[t.name] = t;
+  const hasOut = !!tdir["output.weight"];
+  const mByName = {}; for (const t of manifest.tensors) mByName[t.name] = t;
+  const ROW_CHUNK = 8192;
+  const ffM = manifest.ff, dM = manifest.d;
+
+  // Resolve an engine tensor name → { info, N, K, blk, eltOffset }. Handles MoE
+  // expert slices `l{i}.e{e}.{gate,up,down}` (the e-th slab of the 3-D ffn_*_exps
+  // tensor) and the router `l{i}.router` (ffn_gate_inp, f32) in addition to the
+  // plain tensors in the manifest.
+  const resolve = (name) => {
+    let m = name.match(/^l(\d+)\.e(\d+)\.(gate|up|down)$/);
+    if (m) {
+      const i = m[1], e = +m[2], role = m[3];
+      const info = tdir[`blk.${i}.ffn_${role}_exps.weight`]; if (!info) return null;
+      const N = role === "down" ? dM : ffM, K = role === "down" ? ffM : dM;
+      return { info, N, K, blk: true, eltOffset: e * N * K };
+    }
+    m = name.match(/^l(\d+)\.router$/);
+    if (m) { const info = tdir[`blk.${m[1]}.ffn_gate_inp.weight`]; return info ? { info, N: 1, K: (manifest.moe.n_experts * dM), blk: false, eltOffset: 0 } : null; }
+    const spec = mByName[name]; const gname = ggufNameFor(name, hasOut); const info = gname && tdir[gname];
+    return (spec && info) ? { info, N: spec.N, K: spec.K, blk: spec.blk, eltOffset: 0 } : null;
+  };
+
+  return async function fetchTensor(name) {
+    const r = resolve(name);
+    if (!r) return new Uint8Array(0);
+    const { info, N, K, blk, eltOffset } = r;
+    const [bElems, bBytes] = blockShape(info.ggmlType);
+    const tBase = dataOffset + info.offset + (eltOffset / bElems) * bBytes; // slab offset for experts
+    if (!blk) {                                         // norm / bias / router → [f32]
+      const elems = K;
+      const raw = await readRange(url, tBase, typeByteLen(info.ggmlType, elems));
+      const f = dequantizeRaw(info.ggmlType, raw, elems);
+      return new Uint8Array(f.buffer, f.byteOffset, f.byteLength);
+    }
+    // block weight → [all q bytes][all f32 scales], chunked by rows so a 152k-vocab
+    // tensor never materialises whole as f32 (mirror of quant_tensor_chunked).
+    const [blkElems, blkBytes] = blockShape(info.ggmlType);
+    const qBytesTotal = bits === 4 ? (N * K) / 2 : N * K;
+    const scaleCount = N * (K / 32);
+    const out = new Uint8Array(qBytesTotal + scaleCount * 4);
+    const scales = new Float32Array(out.buffer, qBytesTotal, scaleCount);
+    // Fast relayout when the source quant matches the engine's width (the common
+    // case: a Q4_0 model → 4-bit engine). No f32 ever materialises → also lets the
+    // big embed/lm_head be done in one pass.
+    const fast = (info.ggmlType === GGML.Q4_0 && bits === 4) || (info.ggmlType === GGML.Q8_0 && bits === 8);
+    if (fast) {
+      const raw = await readRange(url, tBase, typeByteLen(info.ggmlType, N * K));
+      const { q, s } = info.ggmlType === GGML.Q4_0 ? relayoutQ4(raw, N, K) : relayoutQ8(raw, N, K);
+      out.set(q, 0); scales.set(s, 0);
+      return out;
+    }
+    let qPos = 0, sPos = 0;
+    for (let r = 0; r < N; r += ROW_CHUNK) {
+      const nr = Math.min(ROW_CHUNK, N - r);
+      const startElem = r * K, countElem = nr * K;
+      const byteStart = (startElem / blkElems) * blkBytes, byteLen = (countElem / blkElems) * blkBytes;
+      const raw = await readRange(url, tBase + byteStart, byteLen);
+      const f = dequantizeRaw(info.ggmlType, raw, countElem);
+      const { q, s } = quantBlocks(f, nr, K, bits);
+      out.set(q, qPos); qPos += q.length;
+      scales.set(s, sPos); sPos += s.length;
+    }
+    return out;
+  };
+}
+
+// HTTP Range reader against a same-origin URL.
+export function rangeReader() {
+  return async (url, start, len) => {
+    const r = await fetch(url, { headers: { Range: `bytes=${start}-${start + len - 1}` } });
+    if (!r.ok && r.status !== 206) throw new Error(`range ${start}+${len}: HTTP ${r.status}`);
+    return new Uint8Array(await r.arrayBuffer());
+  };
+}