Ask bankML: your own bankML (verified, receipt checked in the page) or a Hugging Face provider (labelled not bankML); source at github main cfe81e1 (serve --allow-origin)

CHANGELOG.md

@@ -27,6 +27,15 @@ decode speed, the third, is measured on an idle machine next.
   against 38.8 ms** (13×), p90 49.3 against 80.6 ms, over the oracle's 1,645 masks. The oracle now computes every
   mask both ways: **196 / 196 runs, 1,645 / 1,645 masks** identical to llama.cpp b11192 by each.
 
+### Your own bankML from a web page (`--allow-origin`)
+- `bankml serve … --allow-origin ORIGIN` lets one named web page call the gateway from a browser: its CORS preflight
+  is answered (with Chrome's private-network grant, as a public page reaching a loopback address requires) and its
+  answers, streamed or not, carry `Access-Control-Allow-Origin`; any other origin gets none and a 403 preflight. The
+  loopback `Host` and JSON-POST rules are unchanged. It is what lets the bankML Space's page
+  ([PYTHAI/bankml](https://huggingface.co/spaces/PYTHAI/bankml)) talk to a visitor's own bankML, free, on their own
+  CPU — the way Savante's page reaches a local engine. Checked live: the preflight, plain and streamed answers with
+  the receipt, and another origin refused.
+
 ### The code audit and the documentation (2026-10-06)
 - **Comments, professional and short.** Every source file's comments were cut to the contract, the invariants, the
   safety reasoning and the exact upstream behaviour that keeps the bits; the history and rationale moved to its
@@ -155,7 +164,8 @@ measurements.
   × 4 prompts: each sampler alone, typical-p before top-p and min-p's unsorted path, XTC with a clamped probability and
   a disabling threshold, dynamic temperature at 0, DRY with defaults, custom breakers and with the repeat penalty, all
   five at once): mindx-gen39 **76 / 76** answers token-identical (3,576 tokens), Bonsai-1.7B **76 / 76** (2,587
-  tokens); **16 / 16** refusals each with llama-server's message. Bonsai-8B: to be recorded.
+  tokens), Bonsai-8B **76 / 76** (2,361 tokens, `oracle_samplers_8b`); **16 / 16** refusals on each, with
+  llama-server's message.
 - `oracle_std_sort` (`testing/sort_oracle.cpp`, libstdc++'s own `std::sort`): **876 / 876** orders identical — sizes 0
   to 1,000, heavy ties, sorted, reversed and equal keys — the order typical-p's unstable sort leaves equal scores in.
 

LICENSING.md

@@ -34,7 +34,7 @@ Rules that keep the layers honest:
 | what | licence |
 |---|---|
 | `upstream/` (the AVX2 `Q2_0` kernel prepared for llama.cpp) | `MIT`, llama.cpp's licence, so it can be contributed as is |
-| `testing/gguf_guard.py` | vendored from minaiml (same authors); `MIT OR Apache-2.0` here |
+| `testing/gguf_guard.py` | vendored from [minaiml](https://github.com/minaiml) (same authors); `MIT OR Apache-2.0` here |
 | `sAGI/voice/knobs/savante_knobs.js` | a build of DreamKnob and React (MIT); regenerate with `node sAGI/voice/knobs/build.mjs` |
 | `sAGI/voice/cache/`, `sAGI/voice/export/` | Savante's voice, rendered by bankml with Piper and the `en_GB-cori-high` voice (trained on public-domain LibriVox recordings); offered under `MIT OR Apache-2.0` |
 | models | not part of this repository; bankml imports only models with open-source licences and pins each by sha256 (`sAGI/models.py`) |

README.md

@@ -5,6 +5,10 @@ colorFrom: green
 colorTo: indigo
 sdk: static
 app_file: index.html
+hf_oauth: true
+hf_oauth_expiration_minutes: 480
+hf_oauth_scopes:
+  - inference-api
 pinned: true
 license: mit
 short_description: Verified 1-bit and ternary LLMs on a CPU, in Rust
@@ -18,10 +22,12 @@ tags:
   - verified-inference
 ---
 
-> **This Space holds bankML's whole source**, and a page presenting it. It is ready to run the engine itself:
-> `Dockerfile` and `hf/start.sh` serve `bankml serve --native` with the ternary Bonsai-8B (verified against its sha256
-> pin before it can answer) and the bankML console in front, speaking as bankML (`sAGI/personas/bankml.persona`),
-> public and read-only. That needs Docker hardware on the Space (set `sdk: docker` and `app_port: 7860`). Source of record:
+> **Ask bankML, two ways, never confused.** *Your own bankML*: this page talks to `bankml serve` on your machine
+> (started with `--allow-origin https://pythai-bankml.static.hf.space`) — bankML's verified arithmetic on your CPU,
+> free, with a receipt whose sha256 the page checks. *A Hugging Face provider*: sign in, and a provider-hosted model
+> answers with bankML's persona (`sAGI/personas/bankml.persona`) on your inference quota — labelled on every answer
+> as not bankML, with no receipt. This Space also holds bankML's whole source, and is ready to run the engine itself
+> (`Dockerfile`, `hf/start.sh`) once it has Docker hardware. Source of record:
 > [github.com/cryptoAGI/bankml](https://github.com/cryptoAGI/bankml) · licence `MIT OR Apache-2.0`.
 
 <h1 align="center">bankML</h1>
@@ -48,7 +54,8 @@ tags:
 <p align="center">
   <a href="https://deltaverse.pythai.net/bankml"><b>Why bankML</b></a> (the short version, on the web) &middot;
   <a href="docs/thesis.md"><b>the thesis</b></a> &middot; <a href="docs/usage.md"><b>usage</b></a> &middot;
-  <a href="CHANGELOG.md"><b>changelog</b></a>
+  <a href="CHANGELOG.md"><b>changelog</b></a> &middot;
+  <a href="https://huggingface.co/spaces/PYTHAI/bankml"><b>on Hugging Face</b></a>
 </p>
 
 ---

bankML/main.rs

@@ -13,7 +13,7 @@ const USAGE: &str = "usage: bankml usage [PID …]
        bankml pin FILE --fork FORK.json
        bankml verify FILE --fork FORK.json [--engine mainline|prism] [--json]
        bankml serve FILE --fork FORK.json [--upstream HOST:PORT | --spawn LLAMA_SERVER] [--listen HOST:PORT] [--threads N] [--ctx N] [--spec-ngram] [--slot-dir DIR]
-       bankml serve FILE --fork FORK.json --native [--listen HOST:PORT] [--upstream HOST:PORT] [--ctx N] [--registry [DIR]] [--keep-alive DUR] [--slot-dir DIR]
+       bankml serve FILE --fork FORK.json --native [--listen HOST:PORT] [--upstream HOST:PORT] [--ctx N] [--registry [DIR]] [--keep-alive DUR] [--slot-dir DIR] [--allow-origin ORIGIN]
                                                               (answers from bankML's own forward pass; also serves the engine address;
                                                               OpenAI /v1 and Ollama /api; --registry: every model pinned in DIR,
                                                               default ~/.local/share/bankml/forks, by name, one resident at a time)
@@ -293,6 +293,7 @@ fn main() {
                     // `--registry` without DIR: the importer's forks directory.
                     registry: a.iter().any(|x| x == "--registry").then(|| registry_dir(&a)),
                     keep_alive: opt("--keep-alive"),
+                    allow_origin: opt("--allow-origin"),
                 };
                 match bankml::serve::run(cfg) {
                     Ok(()) => 0,

bankML/ollama.rs

@@ -522,7 +522,7 @@ fn answer(c: &mut TcpStream, l: &Loaded, req: &Json, msgs: Option<&Json>, o: Opt
     };
     let mut content = crate::grammar::ContentStream::new(&constraint);
     if stream {
-        write!(c, "HTTP/1.1 200 OK\r\nContent-Type: application/x-ndjson\r\nCache-Control: no-cache\r\nConnection: close\r\n\r\n")?;
+        write!(c, "HTTP/1.1 200 OK\r\nContent-Type: application/x-ndjson\r\nCache-Control: no-cache\r\n{}Connection: close\r\n\r\n", crate::serve::cors_headers())?;
         let send = |c: &mut TcpStream, piece: &str| piece.is_empty() || c.write_all(piece_line(model, chat, piece).as_bytes()).and_then(|_| c.flush()).is_ok();
         let done = eng.complete(&prompt, params, o.max, grammar, |piece| {
             if t.ttft.is_none() {

bankML/serve.rs

@@ -43,6 +43,25 @@ pub struct Config {
     pub registry: Option<PathBuf>,
     /// `--native`: how long `/api/*` keeps a model resident when the request does not say (Ollama's default, 5m)
     pub keep_alive: Option<String>,
+    /// one web page origin (`https://host[:port]`) whose scripts may call this gateway from a browser: CORS and
+    /// Chrome's private-network preflight are answered for it alone; the loopback `Host` rule still holds
+    pub allow_origin: Option<String>,
+}
+
+/// Whether `o` is an origin: `http(s)://host[:port]`, no path, query or credentials.
+pub fn is_origin(o: &str) -> bool {
+    let rest = o.strip_prefix("https://").or_else(|| o.strip_prefix("http://"));
+    rest.is_some_and(|r| !r.is_empty() && r.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | ':' | '[' | ']')))
+}
+
+thread_local! {
+    /// The CORS headers for the request this connection thread is answering (empty unless its `Origin` is allowed).
+    static CORS: std::cell::RefCell<String> = const { std::cell::RefCell::new(String::new()) };
+}
+
+/// The CORS header lines to add to this connection's response (`\r\n`-terminated; empty when none apply).
+pub(crate) fn cors_headers() -> String {
+    CORS.with(|c| c.borrow().clone())
 }
 
 struct State {
@@ -57,6 +76,8 @@ struct State {
     ident: FileIdent,
     /// where `/slots/{id}?action=save|restore` keeps slot files (`--slot-dir`; native mode)
     slot_dir: Option<PathBuf>,
+    /// `--allow-origin`: the one web origin answered with CORS headers
+    allow_origin: Option<String>,
 }
 
 /// The file identity checked before each P0 answer: device, inode, size and mtime, not the bytes (re-hashing per
@@ -110,6 +131,9 @@ mod sig {
 
 /// Verify the model, launch or check the upstream (or start `--native`), then serve until killed.
 pub fn run(cfg: Config) -> Result<(), String> {
+    if let Some(o) = cfg.allow_origin.as_deref().filter(|o| !is_origin(o)) {
+        return Err(format!("--allow-origin {o}: an origin is http(s)://host[:port], with no path"));
+    }
     let before = ident(&cfg.model).map_err(|e| format!("{}: {e}", cfg.model.display()))?;
     let verified = crate::verify(&cfg.model, &cfg.fork_json, cfg.engine)?;
     let model = cfg.model.canonicalize().map_err(|e| format!("{}: {e}", cfg.model.display()))?;
@@ -153,7 +177,7 @@ pub fn run(cfg: Config) -> Result<(), String> {
     }
     let hashed_at = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
     let engine = "llama.cpp b11192 llama-server (loopback), behind bankml P0".to_string();
-    let st = Arc::new(State { native: None, keep_alive: crate::native::KeepAlive::Forever, verified, model, upstream, engine, hashed_at, ident: id, slot_dir: None });
+    let st = Arc::new(State { native: None, keep_alive: crate::native::KeepAlive::Forever, verified, model, upstream, engine, hashed_at, ident: id, slot_dir: None, allow_origin: cfg.allow_origin.clone() });
     let l = TcpListener::bind(&cfg.listen).map_err(|e| format!("cannot listen on {}: {e}", cfg.listen))?;
     eprintln!("bankml serve {}: {} verified (sha256 {}), upstream {} serves it; listening on http://{}",
         crate::VERSION, st.model.display(), st.verified.model_sha256, st.upstream, cfg.listen);
@@ -189,7 +213,7 @@ fn run_native(cfg: Config, verified: Verified, model: PathBuf, id: FileIdent, up
     if let Some(d) = &cfg.slot_dir {
         std::fs::create_dir_all(d).map_err(|e| format!("--slot-dir {}: {e}", d.display()))?;
     }
-    let st = Arc::new(State { slot_dir: cfg.slot_dir.clone(), native: Some(rs), keep_alive: ka, verified: Verified { model_sha256: sha.clone(), guard: "play", engine: cfg.engine.as_str(), arch: None, name: None, types: Vec::new() },
+    let st = Arc::new(State { slot_dir: cfg.slot_dir.clone(), allow_origin: cfg.allow_origin.clone(), native: Some(rs), keep_alive: ka, verified: Verified { model_sha256: sha.clone(), guard: "play", engine: cfg.engine.as_str(), arch: None, name: None, types: Vec::new() },
                               model, upstream: upstream.clone(), engine, hashed_at, ident: id });
     let l = TcpListener::bind(&cfg.listen).map_err(|e| format!("cannot listen on {}: {e}", cfg.listen))?;
     let lu = TcpListener::bind(&upstream).map_err(|e| format!("cannot listen on the engine address {upstream}: {e} (is llama-server running there?)"))?;
@@ -378,7 +402,7 @@ pub(crate) fn respond(c: &mut TcpStream, code: u16, ctype: &str, body: &[u8]) ->
         _ => "Error",
     };
     let code = if (100..600).contains(&code) { code } else { 502 }; // a garbled upstream head is a bad gateway
-    write!(c, "HTTP/1.1 {code} {reason}\r\nContent-Type: {ctype}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", body.len())?;
+    write!(c, "HTTP/1.1 {code} {reason}\r\nContent-Type: {ctype}\r\nContent-Length: {}\r\n{}Connection: close\r\n\r\n", body.len(), cors_headers())?;
     c.write_all(body)
 }
 
@@ -405,6 +429,18 @@ fn handle(mut c: TcpStream, st: &State) -> std::io::Result<()> {
     if !loopback_host(header(&h, "host").unwrap_or("")) {
         return refuse(403, b"bankml serve answers loopback clients only (Host must be 127.0.0.1, localhost or [::1])", &mut r);
     }
+    // --allow-origin: that one web page may read the answers from a browser; every other origin gets no CORS headers
+    let allowed = header(&h, "origin").filter(|o| st.allow_origin.as_deref() == Some(*o)).map(str::to_string);
+    CORS.with(|c| *c.borrow_mut() = allowed.as_deref().map(|o| format!("Access-Control-Allow-Origin: {o}\r\nVary: Origin\r\n")).unwrap_or_default());
+    if method == "OPTIONS" {
+        if allowed.is_none() {
+            return refuse(403, b"bankml serve: this origin is not allowed (start serve with --allow-origin ORIGIN)", &mut r);
+        }
+        // the preflight; Chrome asks before a public page may reach a loopback address (Private Network Access)
+        let pna = header(&h, "access-control-request-private-network").is_some_and(|v| v.eq_ignore_ascii_case("true"));
+        return write!(c, "HTTP/1.1 204 No Content\r\n{}Access-Control-Allow-Methods: GET, POST\r\nAccess-Control-Allow-Headers: Content-Type\r\n{}Access-Control-Max-Age: 600\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
+                      cors_headers(), if pna { "Access-Control-Allow-Private-Network: true\r\n" } else { "" });
+    }
     if header(&h, "transfer-encoding").is_some() {
         return refuse(400, b"chunked requests are not accepted; send Content-Length", &mut r);
     }
@@ -583,7 +619,7 @@ fn native_chat(c: &mut TcpStream, rs: &crate::native::Residency, body: &[u8]) ->
     let model_id = l.model.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
     let created = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
     let r = if stream {
-        write!(c, "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\nConnection: close\r\n\r\n")?;
+        write!(c, "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\n{}Connection: close\r\n\r\n", cors_headers())?;
         // with logprobs, llama-server's shape: the first token's partial opens with the role delta, and each token's
         // entry rides on the last delta its partial sends (no delta, no entry)
         let logprobs = nc.params.n_probs > 0;
@@ -978,7 +1014,7 @@ fn chat(c: &mut TcpStream, st: &State, body: &[u8]) -> std::io::Result<()> {
         let merged = format!("{}, \"bankml_receipt\": {}}}", &s[..end], t.receipt(&st.engine, &st.verified));
         return respond(c, 200, "application/json", merged.as_bytes());
     }
-    write!(c, "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\nConnection: close\r\n\r\n")?;
+    write!(c, "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\n{}Connection: close\r\n\r\n", cors_headers())?;
     let mut pending = Vec::new();
     while let Some(ch) = b.next(&mut r)? {
         pending.extend(ch);
@@ -1268,6 +1304,16 @@ mod tests {
         assert_eq!(header(&h, "host"), Some("127.0.0.1:18093"));
     }
 
+    #[test]
+    fn origins_are_scheme_host_port_only() {
+        for o in ["https://pythai-bankml.static.hf.space", "http://127.0.0.1:8000", "https://[::1]:7860"] {
+            assert!(is_origin(o), "{o}");
+        }
+        for o in ["https://a.example/path", "pythai-bankml.static.hf.space", "https://", "https://u@h", "https://h?x=1", "*"] {
+            assert!(!is_origin(o), "{o}");
+        }
+    }
+
     #[test]
     fn only_loopback_hosts() {
         for h in ["127.0.0.1", "127.0.0.1:18093", "localhost:18093", "LOCALHOST", "[::1]:18093", "[::1]"] {

bankml-chat.js

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+// Ask bankML, from this static page: two ways, never confused.
+//  · Your own bankML — this browser talks to `bankml serve` on the visitor's machine (started with
+//    --allow-origin for this page): bankML's verified arithmetic, the visitor's CPU and RAM, a receipt on every
+//    answer whose sha256 this page checks. Free.
+//  · A Hugging Face provider — sign in with Hugging Face; a provider-hosted model answers under bankML's persona,
+//    billed to the visitor's inference quota. NOT bankML's arithmetic, no receipt; said on every answer.
+// Nothing an engine or a provider returns becomes markup: text only.
+import { oauthLoginUrl, oauthHandleRedirectIfPresent } from "https://cdn.jsdelivr.net/npm/@huggingface/hub@2.17.1/+esm";
+import { InferenceClient } from "https://cdn.jsdelivr.net/npm/@huggingface/inference@4.13.28/+esm";
+
+const $ = (id) => document.getElementById(id);
+const SESSION = "bankml.oauth";
+const DEFAULT_ENDPOINT = "http://127.0.0.1:18093";
+const DEFAULT_MODEL = "Qwen/Qwen3-8B";
+const history = [];
+let persona = null;
+let oauth = null;
+
+const mode = () => document.querySelector('input[name="mode"]:checked').value;
+
+// ── the persona: the same file the bankML console speaks from ─────────────────────────────────────────────────
+async function loadPersona() {
+  try {
+    const r = await fetch("sAGI/personas/bankml.persona", { cache: "no-store" });
+    persona = await r.json();
+  } catch (e) {
+    persona = null;
+    $("askstatus").textContent = "the persona could not be read: " + e;
+  }
+}
+
+// ── the SELF block, as the console builds it: one sentence per measurement, "not measured" when it was not ──────
+const get = async (ep, path) => {
+  try {
+    const r = await fetch(ep + path, { cache: "no-store" });
+    return r.ok ? await r.json() : null;
+  } catch { return null; }
+};
+async function selfText(ep) {
+  const [b, u, m] = [await get(ep, "/bankml") || {}, await get(ep, "/bankml/usage") || {}, await get(ep, "/bankml/metrics") || {}];
+  const last = (m.records || [{}]).slice(-1)[0] || {};
+  const v = (x, unit = "", scale = 1, d = 1) => (x === null || x === undefined ? "not measured" : (x * scale).toFixed(d) + unit);
+  const ver = b.verified || {};
+  return [
+    `- the model I am running: ${ver.name || b.resident || "none"} (sha256 ${String(ver.model_sha256 || "").slice(0, 16)}…), bankML ${ver.bankml}`,
+    `- tokens I have read in total (prompts): ${v(m.prompt_tokens, "", 1, 0)}`,
+    `- tokens I have written in total (answers): ${v(m.completion_tokens, "", 1, 0)}`,
+    `- time to first token of my last answer: ${v(last.ttft_ms, " milliseconds", 1, 0)}`,
+    `- prompt reading speed of my last answer: ${v(last.prompt_tps, " tokens per second")}`,
+    `- generation speed of my last answer: ${v(last.eval_tps, " tokens per second")}`,
+    `- CPU use right now: ${v(u.cpu_percent, " percent of one core")}`,
+    `- memory I hold (RSS): ${v(u.rss_bytes, " GB", 1e-9, 2)}; memory still available on this machine: ${v(u.mem_available_bytes, " GB", 1e-9, 2)}`,
+    `- power the CPU package draws: ${v(u.package_watts, " watts")}; energy per token I write: ${v(m.joules_per_token, " joules", 1, 3)}`,
+  ].join("\n");
+}
+
+// ── the conversation ──────────────────────────────────────────────────────────────────────────────────────────
+function bubble(role, text) {
+  const d = document.createElement("div");
+  d.className = "msg " + role;
+  d.textContent = text;
+  $("chat").append(d);
+  d.scrollIntoView({ block: "nearest" });
+  return d;
+}
+function note(el, text, cls) {
+  const p = document.createElement("div");
+  p.className = "meta " + (cls || "");
+  p.textContent = text;
+  el.after(p);
+  return p;
+}
+async function sha256hex(text) {
+  const h = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(h)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// ── your own bankML ───────────────────────────────────────────────────────────────────────────────────────────
+async function connect() {
+  const ep = $("endpoint").value.trim().replace(/\/+$/, "") || DEFAULT_ENDPOINT;
+  $("localstatus").textContent = "connecting…";
+  const b = await get(ep, "/bankml");
+  if (!b) {
+    $("localstatus").textContent = "not reachable — is bankml serve running with --allow-origin " + location.origin + " ? (see below)";
+    return false;
+  }
+  const v = b.verified || {};
+  $("localstatus").textContent = v.guard === "play"
+    ? `✓ connected: ${v.name || b.resident || "model"} · bankML ${v.bankml} · sha256 ${String(v.model_sha256 || "").slice(0, 12)}…`
+    : "connected, but no verified model is loaded yet";
+  return v.guard === "play";
+}
+async function askLocal(message) {
+  const ep = $("endpoint").value.trim().replace(/\/+$/, "") || DEFAULT_ENDPOINT;
+  const system = persona.system_prompt + "\n\nSELF (measured by bankML just now):\n" + await selfText(ep);
+  const out = bubble("assistant", "…");
+  let text = "", receipt = null;
+  const r = await fetch(ep + "/v1/chat/completions", {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ messages: [{ role: "system", content: system }, ...history.slice(-12), { role: "user", content: message }],
+      stream: true, max_tokens: 384 }),
+  });
+  if (!r.ok) throw new Error(`HTTP ${r.status}: ${(await r.text()).slice(0, 300)}`);
+  const reader = r.body.getReader(), dec = new TextDecoder();
+  let buf = "";
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    let i;
+    while ((i = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, i).trim();
+      buf = buf.slice(i + 1);
+      if (!line.startsWith("data:") || line === "data: [DONE]") continue;
+      const d = JSON.parse(line.slice(5));
+      if (d.bankml_receipt) { receipt = d.bankml_receipt; continue; }
+      const piece = d.choices?.[0]?.delta?.content;
+      if (piece) { text += piece; out.textContent = text; }
+    }
+  }
+  const ok = receipt && (await sha256hex(text)) === receipt.response_sha256;
+  note(out, receipt
+    ? `${ok ? "✓" : "✗"} receipt — bankML ${receipt.bankml} · model sha256 ${String(receipt.model_sha256 || "").slice(0, 12)}… · answer sha256 ${ok ? "matches the text received" : "does NOT match the text received"}`
+    : "no receipt came with this answer", ok ? "ok" : "bad");
+  history.push({ role: "user", content: message }, { role: "assistant", content: text });
+}
+
+// ── a Hugging Face provider (not bankML) ──────────────────────────────────────────────────────────────────────
+function readSession() { try { return JSON.parse(sessionStorage.getItem(SESSION) || "null"); } catch { return null; } }
+function writeSession(v) { try { v ? sessionStorage.setItem(SESSION, JSON.stringify(v)) : sessionStorage.removeItem(SESSION); } catch {} }
+const signedIn = () => !!(oauth && oauth.accessToken && new Date(oauth.accessTokenExpiresAt) > new Date());
+function renderAuth() {
+  $("signin").hidden = signedIn();
+  $("signout").hidden = !signedIn();
+  $("who").textContent = signedIn()
+    ? `signed in as ${oauth.userInfo?.preferred_username || oauth.userInfo?.name || "you"} — answers spend your inference quota`
+    : "not signed in";
+}
+async function askProvider(message) {
+  const model = $("model").value.trim() || DEFAULT_MODEL;
+  if (!/^[\w.-]+\/[\w.-]+$/.test(model)) throw new Error("the model must be a Hugging Face repository id, owner/name");
+  // the persona, told the truth about where it is running
+  const system = persona.system_prompt + `\n\nIMPORTANT: this answer is NOT produced by bankML. It is produced by ${model} through a Hugging Face inference provider: there is no bankML arithmetic, no receipt and no SELF block. Say so if you are asked about your speed, your use, your receipt or your verification.`;
+  const out = bubble("assistant", "…");
+  let text = "";
+  const client = new InferenceClient(oauth.accessToken);
+  const stream = client.chatCompletionStream({ provider: "auto", model, max_tokens: 384,
+    messages: [{ role: "system", content: system }, ...history.slice(-12), { role: "user", content: message }] });
+  for await (const chunk of stream) {
+    const piece = chunk?.choices?.[0]?.delta?.content;
+    if (piece) { text += piece; out.textContent = text; }
+  }
+  note(out, `not bankML — ${model} via a Hugging Face provider · no receipt · your quota`, "warn");
+  history.push({ role: "user", content: message }, { role: "assistant", content: text });
+}
+
+// ── wiring ─────────────────────────────────────────────────────────────────────────────────────────────────────
+function renderMode() {
+  const m = mode();
+  $("localrow").hidden = m !== "local";
+  $("hfrow").hidden = m !== "hf";
+  $("modenote").textContent = m === "local"
+    ? "bankML's own arithmetic on your machine: verified model, receipt checked here, nothing sent anywhere else."
+    : "Not bankML: a provider-hosted model speaks with bankML's persona, without its arithmetic or a receipt.";
+}
+document.querySelectorAll('input[name="mode"]').forEach((r) => r.addEventListener("change", renderMode));
+$("connect").addEventListener("click", connect);
+$("signin").addEventListener("click", async () => {
+  if (!window.huggingface?.variables?.OAUTH_CLIENT_ID) { $("who").textContent = "sign-in works only on the Hugging Face Space itself"; return; }
+  window.location.href = await oauthLoginUrl({ scopes: window.huggingface.variables.OAUTH_SCOPES });
+});
+$("signout").addEventListener("click", () => { writeSession(null); oauth = null; renderAuth(); });
+$("send").addEventListener("click", async () => {
+  const message = $("message").value.trim();
+  if (!message || !persona) return;
+  if (mode() === "hf" && !signedIn()) { $("askstatus").textContent = "sign in with Hugging Face first"; return; }
+  $("message").value = "";
+  $("send").disabled = true;
+  $("askstatus").textContent = "";
+  bubble("user", message);
+  try {
+    await (mode() === "local" ? askLocal(message) : askProvider(message));
+  } catch (e) {
+    const local = mode() === "local";
+    $("askstatus").textContent = (local ? "your bankML did not answer: " : "the provider did not answer: ") + String(e.message || e).slice(0, 300)
+      + (local ? " — is bankml serve running with --allow-origin " + location.origin + " ?" : "");
+  } finally {
+    $("send").disabled = false;
+  }
+});
+$("message").addEventListener("keydown", (e) => { if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) $("send").click(); });
+$("origin").textContent = location.origin;
+
+(async () => {
+  $("endpoint").value = DEFAULT_ENDPOINT;
+  $("model").value = DEFAULT_MODEL;
+  renderMode();
+  await loadPersona();
+  if (persona) $("mantra").textContent = "“" + persona.mantra + "”";
+  try { const res = await oauthHandleRedirectIfPresent(); if (res) writeSession(res); } catch (e) { $("who").textContent = "sign-in failed: " + String(e).slice(0, 120); }
+  oauth = readSession();
+  renderAuth();
+})();

docs/BUILD_HISTORY.md

@@ -107,7 +107,7 @@ then memory traffic per token, with strategies from llama.cpp, vLLM, Ollama and
    dependency justified in `Cargo.toml` comments. A single static binary.
 3. **Verified response** — every answer carries its evidence, and a model that cannot be
    verified does not answer:
-   - before load: the GGUF guard (port of minaiml `gguf_guard.py`) → `play | refuse | need_more`;
+   - before load: the GGUF guard (port of [minaiml](https://github.com/minaiml) `gguf_guard.py`) → `play | refuse | need_more`;
      refuse is shown with its reason, never a silent fallback (Bonsai 2 Q2_0 loads on mainline
      and answers in gibberish — the worst failure);
    - the file's sha256 must match a pinned record (`FORK.json` of the PYTHAI fork);

docs/index.html

@@ -113,6 +113,9 @@ article p[align="center"] { text-align: center; }
   .picker select { width: 100%; font: 15px var(--f-body); padding: 8px; border-radius: 6px; border: 1px solid var(--rule); background: var(--panel); color: var(--ink); }
   article h1 { font-size: 1.65rem; }
 }
+.masthead .links { margin: 6px 0 0; font: 500 12.5px/1.4 var(--f-mono); }
+.masthead .links a { color: inherit; text-decoration: underline; text-underline-offset: 2px; opacity: .85; }
+.masthead .links a:hover { opacity: 1; }
 @media (prefers-reduced-motion: no-preference) { html { scroll-behavior: smooth; } }
 </style>
 
@@ -120,6 +123,7 @@ article p[align="center"] { text-align: center; }
   <div class="masthead-inner">
     <p class="brand"><span class="trits" aria-hidden="true"><i></i><i></i><i></i></span>bankml<span class="ver" id="ver">0.2.7</span></p>
     <span class="tag">Verified low-bit inference for the CPU you already have — the documentation, as of <span id="asof">0.2.7</span>.</span>
+    <p class="links"><a href="https://github.com/cryptoAGI/bankml">GitHub</a> · <a href="https://huggingface.co/spaces/PYTHAI/bankml">Hugging Face</a> · <a href="https://deltaverse.pythai.net/bankml">why bankML</a> · <a href="#thesis">the thesis</a> · <a href="https://github.com/minaiml">minaiml</a> (<a href="https://huggingface.co/spaces/PYTHAI/minaiml">Space</a>)</p>
     <div class="proof">gate record 0.3.6: the penalties — repeat, frequency and presence, token-identical to llama-server on <b>56 / 56</b> answers on each of three models, live <b>85 / 85</b> · gate record 0.3.5: JSON schemas — llama-server’s grammar on each template (<b>173 / 173</b> schemas × 3 templates against llama.cpp’s own code) and its answers token-identical on all five native models (<b>28 / 28</b>, <b>11 / 11</b>, <b>56 / 56</b> × 3), the content rule matched on <b>30,063 / 30,063</b> texts per template · <code>bankml create</code>: mindX’s persona layer, made from mindXtrain’s merged output, token-identical end to end (<b>27 / 27</b>, two ways) · gate record 0.3.4: mindX’s own model natively — <code>mindx-gen39</code> and SmolLM2-135M-Instruct (the Llama graph in F16) and Bonsai-1.7B (tied embeddings) token-identical to llama-server b11192: whole model <b>800 / 800</b> and <b>840 / 840</b> rows bit-exact, F16 products <b>552,268 / 552,268</b> elements bit-exact against ggml, seeded sampling <b>40 / 40</b> on each, conversations <b>9 / 9</b>, JSON mode <b>23 / 23</b> · JSON mode — answers under llama-server’s own <code>json_object</code> grammar token-identical, greedy and seeded (<b>23 / 23</b> answers on the 1-bit model, <b>13 / 13</b> on the ternary), and llama.cpp’s grammar sampler matched on <b>1,645 / 1,645</b> whole-vocabulary masks · a C API, <code>libbankml</code>, identical to <code>serve --native</code> · Savante answered by bankML’s own forward pass — whole conversations identical to llama-server on <b>9 / 9</b> turns (text, token counts, prompt-cache reuse) · own forward pass <b>1,064 / 1,064</b> rows bit-exact for the 1-bit and the ternary model · seeded sampling identical on <b>40 / 40</b> continuations · <b>8,188,239,872</b> ternary weights and <b>762 / 762</b> dot products bit-exact against llama.cpp b11192’s compiled library · one ternary token <b>0.222 s vs 2.139 s</b></div>
   </div>
 </header>

docs/install.md

@@ -353,6 +353,7 @@ oracles all do this.
 | `--ctx N` | `4096` | both | the context: `-c N` for the spawned llama-server, `n_ctx` for the native engine. A prompt of `N` tokens or more is refused (0.3.8: with llama-server's `exceed_context_size_error` 400 body on `/v1`); an Ollama `num_ctx` above it is refused |
 | `--spec-ngram` | off | llama.cpp | `--spec-type ngram-simple` in the spawned engine: n-gram speculative decoding, exact at temperature 0, opt-in because it measured within noise |
 | `--slot-dir DIR` | — | both | llama.cpp mode: `--slot-save-path DIR` for the spawned engine. Native mode (0.3.8): `POST /slots/0?action=save\|restore\|erase` with `{"filename"}`, as llama-server's slot API; the directory is created at start. Either way, a restart restores the system prompt instead of computing it again. Without it, the slot actions answer 501 |
+| `--allow-origin ORIGIN` | — | both | 0.3.9: one web page (`https://host[:port]`) whose scripts may call this gateway from a browser — the bankML Space's page, for example (`https://pythai-bankml.static.hf.space`). bankML answers that origin's CORS preflight (with Chrome's `Access-Control-Allow-Private-Network`) and adds `Access-Control-Allow-Origin` to its answers, streamed ones included; any other origin gets no CORS headers and a 403 preflight. The loopback `Host` and JSON-POST rules are unchanged |
 | `--native` | off | — | native mode |
 | `--registry [DIR]` | off; bare: `$BANKML_FORKS`, else `~/.local/share/bankml/forks` | native | serve every model pinned in `DIR` by name, one resident at a time, each verified again when it loads; answer `/api/create`, `/api/copy`, `/api/delete` for derived models. A following argument that starts with `--` is not taken as `DIR` |
 | `--keep-alive DUR` | `5m` | native | how long an `/api/*` request that names no `keep_alive` keeps the model resident: `"5m"`, `"1h30m"`, seconds, `0` (unload after the answer), negative (for good). OpenAI and llama-server endpoints keep the model resident |

docs/modules/gguf.md

@@ -3,7 +3,7 @@
 ## Summary
 
 `gguf.rs` reads the header of a GGUF v3 file and decides whether bankml may play it. The decision is the
-**guard**: `play`, `refuse` with reasons, or `need_more` header bytes. It is a port of minaiml's Python
+**guard**: `play`, `refuse` with reasons, or `need_more` header bytes. It is a port of [minaiml](https://github.com/minaiml)'s Python
 `gguf_guard.py` (same verdicts, same reasons, same JSON keys). The guard never reads tensor data.
 
 The module also holds what the rest of bankml needs to reach tensor data safely: type names, block layouts,

docs/thesis.md

@@ -132,7 +132,76 @@ bankML's discipline is to establish exactly that, against an independent referen
 integrity, not proof: they bind the answer's text to a pinned file and to the request, between a client and its own
 gateway ([research.md §3](research.md#3-verifiable-and-attested-inference)).
 
-### II.5 What bankML inherits, extends and breaks
+### II.5 The contemporary field (survey of 6 October 2026)
+
+This section maps the work bankML sits among, as found on 6 October 2026: every paper below was checked against its
+arXiv abstract, and every repository's existence and last activity against GitHub on that date. Projects' own speed
+figures are theirs, not reproduced here. A wider survey with the verifiable-inference field is in
+[research.md](research.md).
+
+#### II.5.1 Ternary and 1-bit models
+
+Two programmes now train language models through the ternary constraint rather than quantizing after training. The
+BitNet line (Microsoft Research) moved from the 1.58-bit recipe (Ma et al. 2024) to an openly released 2-billion-
+parameter ternary model trained on 4 trillion tokens (Ma et al. 2025), then to 4-bit activations beside the 1-bit
+weights (Wang, Ma and Wei 2024; 2025, the latter by a Hadamard transformation of the activations), and to distilling
+full-precision models into 1.58 bits (Wu et al. 2025). Spectra (Kaushal et al. 2024) trained a suite of 54 models from
+99 M to 3.9 B parameters to compare ternary "TriLMs" with float and post-training-quantized peers at equal size, and
+Spectra 1.1 (Vaidhya et al. 2025) scaled TriLMs to 1.2 T tokens with scaling laws and its own inference kernel.
+Alongside these, TernaryLLM (Chen et al. 2024) and OneBit (Xu et al. 2024) push quantization-aware training of
+existing models to ternary and 1-bit weights, PTQ1.61 (Zhao et al. 2025) reaches below two bits after training,
+ParetoQ (Liu et al. 2025) maps scaling laws across extreme bit widths, and MatMul-free language modelling (Zhu et al.
+2024) removes matrix multiplication by ternary weights altogether.
+
+The Bonsai models bankML serves come from PrismML and are dense Qwen3 networks trained to one bit (`Q1_0`) and to
+ternary values (`Q2_0`, group 64, 2.25 bits per weight). PrismML's own format table
+([docs.prismml.com](https://docs.prismml.com/download/formats)) records that group-64 `Q2_0` is in mainline llama.cpp,
+that a group-128 legacy `Q2_0` is deprecated, and that its newer Ternary Bonsai 2 formats (`PQ2_0`, `PTQ1_0`) use a
+rotated weight basis that needs an activation-side Walsh–Hadamard transform at run time — the file a stock engine
+loads and answers in fluent nonsense, which is why bankML's guard refuses it (§III.2), and the same family of
+rotation bankML reproduced for llama.cpp's quantized cache (§III.4).
+
+#### II.5.2 Kernels and engines for ternary and 1-bit weights
+
+| work | what it is | relation to bankML |
+|---|---|---|
+| [llama.cpp](https://github.com/ggml-org/llama.cpp) upstream | `Q1_0` ([#21273](https://github.com/ggml-org/llama.cpp/pull/21273); x86 AVX2+FMA in [#21636](https://github.com/ggml-org/llama.cpp/pull/21636)); `Q2_0` ([#24448](https://github.com/ggml-org/llama.cpp/pull/24448), NEON and scalar); an x86 `Q2_0` kernel needing AVX-VNNI ([#26348](https://github.com/ggml-org/llama.cpp/pull/26348), open); the older `TQ1_0`/`TQ2_0` ([#10010](https://github.com/ggml-org/llama.cpp/pull/10010)) | the reference: bankML reproduces b11192's compiled code bit for bit and adds the plain-AVX2 `Q2_0` kernel it lacks |
+| [PrismML's fork](https://github.com/PrismML-Eng/llama.cpp) | kernels for the Bonsai 2 formats, e.g. `PQ2_0` AVX2/AVX-VNNI ([#206](https://github.com/PrismML-Eng/llama.cpp/pull/206)) | different formats; refused by bankML's guard until a kernel and an oracle exist |
+| [bitnet.cpp](https://github.com/microsoft/BitNet) (Wang, Zhou, Song et al. 2024; 2025) | lookup-table and I2_S kernels for BitNet b1.58 on CPU; reports 2.37–6.17× on x86 | a different weight format (BitNet's), and a different exactness claim (lossless to its own model, not to an external reference) |
+| [T-MAC](https://github.com/microsoft/T-MAC) (Wei et al. 2025) | lookup-table mixed-precision GEMM on CPU and NPU | the table-lookup alternative to bankML's `maddubs` arithmetic |
+| Vec-LUT (Li et al. 2025) | vector table lookup for parallel ultra-low-bit inference on edge devices | the same direction as T-MAC, parallelised |
+| Spectra 1.1's TriRun (Vaidhya et al. 2025) | a GPU kernel for packed ternary weights | GPU, not CPU |
+
+#### II.5.3 Inference engines written in Rust
+
+| engine | what it is | state on 2026-10-06 | exactness claim |
+|---|---|---|---|
+| [candle](https://github.com/huggingface/candle) (Hugging Face) | a minimalist ML framework; GGUF K-quants on CPU (AVX2/NEON), CUDA, Metal, WASM | active, the base most Rust LLM projects build on | none against llama.cpp found |
+| [mistral.rs](https://github.com/EricLBuehler/mistral.rs) | an LLM server on candle: many architectures, ISQ, GPTQ/AWQ/HQQ/FP8 | active | none found |
+| [burn](https://github.com/tracel-ai/burn) | a general tensor and deep-learning framework | active | not a GGUF engine |
+| [Crane](https://github.com/lucasjinreal/Crane), [kalosm](https://github.com/floneum/kalosm), [cake](https://github.com/evilsocket/cake) | LLM/VLM engines and libraries on candle; cake distributes inference across devices | active | none found |
+| [OxiLLaMa](https://github.com/cool-japan/oxillama) | a pure-Rust GGUF engine with its own AVX2/AVX-512/NEON kernels, including `TQ1_0`/`TQ2_0` and `Q1_0_G128` | active (alpha) | top-1 logit parity within a tolerance |
+| [Frink](https://github.com/antonellof/frink) | a pure-Rust GGUF engine with quantized CPU, Metal and CUDA kernels and MoE | active | quantizer bytes identical on two formats |
+| [Cera](https://github.com/hyeons-lab/cera) | a Rust-native GGUF engine (AVX2/AVX-512, NEON dotprod/i8mm, optional wgpu) | crate 0.6.3, 2026-09-25 | none stated |
+| [llama-gguf](https://github.com/Lexmata/llama-gguf), [lm.rs](https://github.com/samuel-vitorino/lm.rs) | small engines, correctness-first / minimal | llama-gguf 2026-04; lm.rs inactive since 2024-10 | none stated |
+| [bitnet-rs](https://github.com/lilyco-42/bitnet-rs), [bitnet-toy](https://github.com/tidynest/bitnet-toy) | BitNet b1.58 in Rust (a port of bitnet.cpp; a from-scratch teaching engine) | 2026-09 | unit tests against its own C++ baseline |
+| [alice-aegis](https://github.com/Aefinity-AI/alice-aegis) | a `no_std` UEFI ternary engine with frozen integer semantics and SHA-256 receipts chaining the logits | 2026-10 | bit-identical across its own ISAs, not against an external reference |
+| [ratchet](https://github.com/huggingface/ratchet), [tract](https://github.com/sonos/tract), [rten](https://github.com/robertknight/rten) | browser/WebGPU and ONNX inference | active | not GGUF engines |
+| [rustformers/llm](https://github.com/rustformers/llm), [llama-cpp-rs](https://github.com/utilityai/llama-cpp-rs) | the first, archived (2024); the second, bindings to llama.cpp's C++ | — | inherit llama.cpp's arithmetic by calling it |
+
+#### II.5.4 Where bankML stands among them
+
+Three things in this survey are bankML's alone. It is the only engine found that reproduces the reference's
+*compiled* library bit for bit — every weight, every dot product, every token of whole conversations — rather than
+within a tolerance or against itself; alice-aegis shares the receipt idea and the exact integer discipline but checks
+against its own builds. It is the only Rust engine found with ggml's group-64 ternary `Q2_0`, and its plain-AVX2 kernel
+fills the x86 gap that upstream's open VNNI kernel leaves on CPUs without VNNI. And it is one zero-dependency binary
+whose every answer carries a receipt. It is behind the field in breadth: candle and mistral.rs run far more
+architectures and formats and run on GPUs, OxiLLaMa and upstream llama.cpp have NEON kernels for these formats, and
+the BitNet and T-MAC kernels serve a different ternary format at speeds bankML has not been compared with. The
+research programmes above produce the models; bankML's contribution is to run the ones in ggml's formats exactly.
+
+### II.6 What bankML inherits, extends and breaks
 
 It **inherits** ggml's formats, its kernels' semantics and llama-server's protocol. It **extends** them with an x86
 ternary kernel the reference lacks, a gate in front of every answer, and receipts. It **breaks** with the convention
@@ -164,7 +233,8 @@ already shown identical.
    result and not shipped ([`testing/experiments/`](../testing/experiments/)).
 2. **The compiled reference is the specification, not its source.** Where the shipped library and its C source
    disagree, the library wins (§II.3).
-3. **A model that cannot be verified does not answer.** The guard ([`bankML/gguf.rs`](../bankML/gguf.rs)) refuses,
+3. **A model that cannot be verified does not answer.** The guard ([`bankML/gguf.rs`](../bankML/gguf.rs), a port of
+   the GGUF guard of [minaiml](https://github.com/minaiml), the authors' delivery layer for models on laptops and phones) refuses,
    from the header alone and with a reason, the three low-bit traps, including a file mainline loads and answers in
    fluent nonsense. The pin ([`bankML/sha256.rs`](../bankML/sha256.rs)) refuses a file whose hash differs from its
    provenance record.
@@ -313,6 +383,8 @@ Ashkboos, S., Mohtashami, A., Croci, M. L., Li, B., Cameron, P., Jaggi, M., Alis
 
 Cankaya, E. (2026). "Bit-Exact AI Inference Verification Without Performance Tradeoffs." [arXiv:2606.00279](https://arxiv.org/abs/2606.00279).
 
+Chen, T., Li, Z., Xu, W. et al. (2024). "TernaryLLM: Ternarized Large Language Model." [arXiv:2406.07177](https://arxiv.org/abs/2406.07177).
+
 Codephreak, Professor and Magnusson, G. L. (2026). Design directives for bankML and the mindX runtime, recorded in the
 project (project record, 2026-07-04 to 2026-09-28); quoted in [TECHNICAL.md](TECHNICAL.md#thesis--professor-codephreak-and-gregory-l-magnusson).
 
@@ -335,6 +407,9 @@ Surveys* 23(1): 5–48. [doi:10.1145/103162.103163](https://doi.org/10.1145/1031
 Hubara, I., Courbariaux, M., Soudry, D., El-Yaniv, R. and Bengio, Y. (2016). "Binarized Neural Networks." *Advances in
 Neural Information Processing Systems 29*. [Proceedings](https://papers.nips.cc/paper_files/paper/2016/hash/d8330f857a17c53d217014ee776bfd50-Abstract.html); preprint [arXiv:1602.02830](https://arxiv.org/abs/1602.02830).
 
+Kaushal, A., Vaidhya, T., Mondal, A. K. et al. (2024). "Spectra: Surprising Effectiveness of Pretraining Ternary
+Language Models at Scale." [arXiv:2407.12327](https://arxiv.org/abs/2407.12327).
+
 Kwon, W., Li, Z., Zhuang, S., Sheng, Y., Zheng, L., Yu, C. H., Gonzalez, J. E., Zhang, H. and Stoica, I. (2023).
 "Efficient Memory Management for Large Language Model Serving with PagedAttention." *Proceedings of the 29th Symposium
 on Operating Systems Principles (SOSP 2023)*. [arXiv:2309.06180](https://arxiv.org/abs/2309.06180).
@@ -344,9 +419,21 @@ Software* 39(2). [doi:10.1109/MS.2021.3073045](https://doi.org/10.1109/MS.2021.3
 
 Li, F., Zhang, B. and Liu, B. (2016). "Ternary Weight Networks." [arXiv:1605.04711](https://arxiv.org/abs/1605.04711).
 
+Li, X., Yin, C., Wang, W. et al. (2025). "Vec-LUT: Vector Table Lookup for Parallel Ultra-Low-Bit LLM Inference on Edge
+Devices." [arXiv:2512.06443](https://arxiv.org/abs/2512.06443).
+
+Liu, Z., Zhao, C., Huang, H. et al. (2025). "ParetoQ: Improving Scaling Laws in Extremely Low-bit LLM Quantization."
+[arXiv:2502.02631](https://arxiv.org/abs/2502.02631).
+
+Ma, S., Wang, H., Huang, S. et al. (2025). "BitNet b1.58 2B4T Technical Report." [arXiv:2504.12285](https://arxiv.org/abs/2504.12285).
+
 Ma, S., Wang, H., Ma, L., Wang, L., Wang, W., Huang, S., Dong, L., Wang, R., Xue, J. and Wei, F. (2024). "The Era of
 1-bit LLMs: All Large Language Models are in 1.58 Bits." [arXiv:2402.17764](https://arxiv.org/abs/2402.17764).
 
+minaiml (software). "min ai ml — language models in miniature": delivery software for models on laptops and
+phones, the origin of bankML's GGUF guard. [github.com/minaiml](https://github.com/minaiml) · [Hugging Face Space
+PYTHAI/minaiml](https://huggingface.co/spaces/PYTHAI/minaiml).
+
 Qwen Team (2025). "Qwen3 Technical Report." [arXiv:2505.09388](https://arxiv.org/abs/2505.09388).
 
 Rastegari, M., Ordonez, V., Redmon, J. and Farhadi, A. (2016). "XNOR-Net: ImageNet Classification Using Binary
@@ -360,6 +447,14 @@ Thompson, K. (1984). "Reflections on Trusting Trust." *Communications of the ACM
 Tseng, A., Chee, J., Sun, Q., Kuleshov, V. and De Sa, C. (2024). "QuIP#: Even Better LLM Quantization with Hadamard
 Incoherence and Lattice Codebooks." *International Conference on Machine Learning (ICML 2024)*. [arXiv:2402.04396](https://arxiv.org/abs/2402.04396).
 
+Vaidhya, T., Kaushal, A., Jain, V. et al. (2025). "Spectra 1.1: Scaling Laws and Efficient Inference for Ternary Language
+Models." [arXiv:2506.23025](https://arxiv.org/abs/2506.23025).
+
+Wang, H., Ma, S. and Wei, F. (2024). "BitNet a4.8: 4-bit Activations for 1-bit LLMs." [arXiv:2411.04965](https://arxiv.org/abs/2411.04965).
+
+Wang, H., Ma, S. and Wei, F. (2025). "BitNet v2: Native 4-bit Activations with Hadamard Transformation for 1-bit LLMs."
+[arXiv:2504.18415](https://arxiv.org/abs/2504.18415).
+
 Wang, H., Ma, S., Dong, L., Huang, S., Wang, H., Ma, L., Yang, F., Wang, R., Wu, Y. and Wei, F. (2023). "BitNet:
 Scaling 1-bit Transformers for Large Language Models." [arXiv:2310.11453](https://arxiv.org/abs/2310.11453).
 
@@ -372,9 +467,18 @@ Wang, J., Zhou, H., Song, T. et al. (2025). "Bitnet.cpp: Efficient Edge Inferenc
 Wei, J. et al. (2025). "T-MAC: CPU Renaissance via Table Lookup for Low-Bit LLM Deployment on Edge." *Proceedings of
 EuroSys 2025*. [arXiv:2407.00088](https://arxiv.org/abs/2407.00088).
 
+Wu, X., Huang, S., Wang, W. et al. (2025). "BitNet Distillation." [arXiv:2510.13998](https://arxiv.org/abs/2510.13998).
+
+Xu, Y., Han, X., Yang, Z. et al. (2024). "OneBit: Towards Extremely Low-bit Large Language Models." [arXiv:2402.11295](https://arxiv.org/abs/2402.11295).
+
+Zhao, J., Zhang, M., Wang, M. et al. (2025). "PTQ1.61: Push the Real Limit of Extremely Low-Bit Post-Training
+Quantization Methods for Large Language Models." [arXiv:2502.13179](https://arxiv.org/abs/2502.13179).
+
 Zhu, C., Han, S., Mao, H. and Dally, W. J. (2017). "Trained Ternary Quantization." *International Conference on
 Learning Representations (ICLR 2017)*. [arXiv:1612.01064](https://arxiv.org/abs/1612.01064).
 
+Zhu, R.-J., Zhang, Y., Abreu, S. et al. (2024). "Scalable MatMul-free Language Modeling." [arXiv:2406.02528](https://arxiv.org/abs/2406.02528).
+
 *Notes on the references.* Author lists for the 2024–2026 preprints follow [research.md](research.md), which records
 which details were re-fetched and which are as commonly cited. QuaRot and QuIP# are cited for the technique of
 rotating activations by a Hadamard transform before quantization; the attribution of llama.cpp's own rotation to

docs/usage.md

@@ -247,6 +247,9 @@ In the next release (not yet tagged); each is checked against llama-server b1119
   llama-server `-np 1`. Like llama-server, it keeps the states of other conversations in RAM (`BANKML_CACHE_RAM`, MiB;
   0 off, -1 no limit; unset, 8192 MiB but at most a quarter of the memory available at load), so a conversation that comes back after
   another does not recompute its whole history.
+- **Your bankML from a web page (0.3.9).** `--allow-origin https://pythai-bankml.static.hf.space` lets the bankML
+  Space's page talk to your own `bankml serve` from your browser: your CPU, your verified model, a receipt on every
+  answer, nothing sent anywhere else. Only that one origin is answered with CORS headers.
 - **A smaller conversation memory (0.3.9, in progress).** `BANKML_CACHE_TYPE=q8_0` keeps the KV cache in q8_0 instead of f16,
   about half the memory, so a long context fits on a small machine. It is llama.cpp's `--cache-type-k q8_0
   --cache-type-v q8_0` exactly, with the Hadamard rotation llama.cpp applies around a quantized cache, and gives the

index.html

@@ -125,6 +125,27 @@
     .table td:first-child{color:#fff; font-weight:500; width:34%;}
     .road li strong{color:rgb(var(--am));}
     .hope p{font-size:18px; color:#eef;}
+    #ask .mantra{font-size:19px;color:#fff;margin:.2em 0 .6em}
+    #ask .modes{display:grid;gap:6px;margin:8px 0}
+    #ask .modes label{color:var(--muted);cursor:pointer}
+    #ask .modenote{font-size:14px;color:var(--quiet);margin:.3em 0 .8em}
+    #ask .row{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin:8px 0}
+    #ask input[type=text],#ask #endpoint,#ask #model{flex:1 1 220px;min-width:0;background:rgba(0,0,0,.35);color:#fff;border:1px solid var(--rule);border-radius:8px;padding:8px 10px;font:14px ui-monospace,Menlo,monospace}
+    #ask textarea{flex:1 1 260px;min-width:0;background:rgba(0,0,0,.35);color:#fff;border:1px solid var(--rule);border-radius:8px;padding:9px 10px;font:15px system-ui,sans-serif;resize:vertical}
+    #ask button{background:rgba(var(--cy),.16);color:#fff;border:1px solid rgba(var(--cy),.5);border-radius:8px;padding:8px 14px;font:600 14px system-ui,sans-serif;cursor:pointer}
+    #ask button:hover{background:rgba(var(--cy),.3)}
+    #ask button:disabled{opacity:.5;cursor:wait}
+    #ask .status{font-size:13.5px;color:var(--quiet);flex:1 1 100%}
+    #ask details{flex:1 1 100%;font-size:14.5px;color:var(--muted)}
+    #ask details code{word-break:break-all}
+    #chat{display:grid;gap:8px;margin:12px 0 4px;max-height:420px;overflow-y:auto}
+    #chat .msg{white-space:pre-wrap;border-radius:10px;padding:9px 12px;line-height:1.5}
+    #chat .msg.user{background:rgba(var(--vi),.18);justify-self:end;max-width:85%;color:#fff}
+    #chat .msg.assistant{background:rgba(0,0,0,.35);border:1px solid var(--rule);color:#e8eef5}
+    #chat .meta{font:12.5px ui-monospace,Menlo,monospace;color:var(--quiet);margin:-4px 2px 4px}
+    #chat .meta.ok{color:#56d364}
+    #chat .meta.bad{color:#ff7b72}
+    #chat .meta.warn{color:rgb(var(--am))}
     footer{max-width:780px; margin:0 auto; padding:10px 16px 90px; text-align:center; color:var(--quiet); font-size:14px;}
     .social{display:flex; gap:22px; justify-content:center; align-items:center; margin:14px 0 10px;}
     .social a{display:inline-flex; align-items:center; gap:8px; border:none; color:var(--muted);}
@@ -147,6 +168,43 @@
         and 0.3.8 and 0.3.9 are being built on the way to the 0.4.0 milestone.</p>
     </header>
 
+
+    <section id="ask">
+      <h2>Ask bankML</h2>
+      <p class="mantra" id="mantra"></p>
+      <div class="modes" role="radiogroup" aria-label="who answers">
+        <label><input type="radio" name="mode" value="local" checked> <b>Your own bankML</b> — verified, with a receipt, on your CPU (free)</label>
+        <label><input type="radio" name="mode" value="hf"> <b>A Hugging Face provider</b> — not bankML, no receipt, your inference quota</label>
+      </div>
+      <p class="modenote" id="modenote"></p>
+      <div id="localrow" class="row">
+        <input id="endpoint" aria-label="your bankml serve address" spellcheck="false">
+        <button id="connect" type="button">connect</button>
+        <span id="localstatus" class="status"></span>
+        <details>
+          <summary>Start your own bankML for this page (Linux, AVX2; free)</summary>
+          <ol>
+            <li><code>git clone https://github.com/cryptoAGI/bankml &amp;&amp; cd bankml &amp;&amp; ./install.sh</code> — builds bankML and imports and verifies Bonsai-8B.</li>
+            <li><code>./install.sh stop</code> (the installer's own serve does not allow web pages), then:<br>
+              <code>target/release/bankml serve .models/Bonsai-8B-Q1_0.gguf --fork ~/.local/share/bankml/forks/Bonsai-8B-Q1_0.gguf.FORK.json --native --allow-origin <span id="origin"></span></code></li>
+            <li>Press <b>connect</b>. Your browser may ask to let this page reach your machine: that is the request for your own bankML on 127.0.0.1, and nothing else.</li>
+          </ol>
+        </details>
+      </div>
+      <div id="hfrow" class="row" hidden>
+        <input id="model" aria-label="provider model (owner/name)" spellcheck="false">
+        <button id="signin" type="button">Sign in with Hugging Face</button>
+        <button id="signout" type="button" hidden>sign out</button>
+        <span id="who" class="status"></span>
+      </div>
+      <div id="chat" aria-live="polite"></div>
+      <div class="row ask">
+        <textarea id="message" rows="2" placeholder="Ask bankML about itself, its exactness, its speed… (Ctrl+Enter)"></textarea>
+        <button id="send" type="button">Ask</button>
+      </div>
+      <p id="askstatus" class="status"></p>
+    </section>
+
     <section>
       <h2>bankML in one paragraph</h2>
       <p>bankML runs language models on the computer you already have: a laptop, a small server, no graphics card
@@ -420,5 +478,6 @@
     mount(layer);
   })();
   </script>
+  <script type="module" src="bankml-chat.js"></script>
 </body>
 </html>