Compiled (not trained) 91M-param Llama autocomplete model, TypeScript runtime and UI, docs

LICENSE

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

README.md

@@ -0,0 +1,160 @@
+---
+license: mit
+language:
+- en
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- llama
+- hand-crafted
+- compiled
+- autocomplete
+- no-training
+- n-gram
+widget:
+- text: Once upon a
+- text: I hope this email
+- text: The quick brown
+---
+
+# tiny-autocomplete
+
+A 91M-parameter Llama-format model whose weights were **compiled, not trained**.
+No gradient descent was run, and no other model or pretrained weights were used. Every number
+comes from a closed-form rule in [`build_weights.py`](build_weights.py), applied to ~1,100
+common English phrases in [`phrases/`](phrases). Full details are in
+[docs/how-it-works.md](docs/how-it-works.md).
+
+| Prompt | Greedy completion |
+|---|---|
+| Once upon a | time. |
+| The quick brown | fox jumps over the lazy dog. |
+| I hope this email | finds you well. |
+| Thank you for your | help. |
+| Can I have the | check, please? |
+| Looking forward to | hearing from you. |
+| Actions speak | louder than words. |
+| How are | you doing? |
+
+## Use it with transformers
+
+```python
+from transformers import pipeline
+
+gen = pipeline("text-generation", model="tmickleydoyle/tiny-autocomplete")
+gen("Once upon a")[0]["generated_text"]   # 'Once upon a time.'
+```
+
+Next-word suggestions with probabilities:
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+tok = AutoTokenizer.from_pretrained("tmickleydoyle/tiny-autocomplete")
+model = AutoModelForCausalLM.from_pretrained("tmickleydoyle/tiny-autocomplete")
+
+ids = tok("Thank you for", return_tensors="pt")
+with torch.no_grad():
+    probs = model(**ids).logits[0, -1].softmax(-1)
+for p, i in zip(*probs.topk(5)):
+    print(repr(tok.decode(i)), f"{p:.1%}")   # ' your' 37.6%, ' the' 16.7%, ...
+
+out = model.generate(**ids, max_new_tokens=16)
+print(tok.decode(out[0], skip_special_tokens=True))   # ' thank you for your help.'
+```
+
+The tokenizer lowercases input, so output is lowercase. A BOS token is prepended
+automatically.
+
+## Use it without Python (TypeScript, zero dependencies)
+
+`model.ts` reads `config.json`, `model.safetensors` and `tokenizer.json` and runs the Llama
+forward pass in plain TypeScript. It needs no ML library. It runs on [Bun](https://bun.sh)
+or Node ≥ 23.6.
+
+```bash
+git lfs install
+git clone https://huggingface.co/tmickleydoyle/tiny-autocomplete
+cd tiny-autocomplete
+
+bun ui.ts                               # web UI at http://localhost:3000
+bun autocomplete.ts                     # terminal REPL
+bun autocomplete.ts "Once upon a" "Can you"
+```
+
+In the web UI, type a prompt to see the predicted completion as gray ghost text and the top
+5 next words with probabilities. **Tab** accepts the completion, **Enter** accepts the
+top next word, and clicking a word appends it.
+
+## What it computes
+
+The network is an exact transformer implementation of an **interpolated Witten-Bell 5-gram
+language model**. It predicts the next word from the current word plus up to 3 before it,
+falling back to shorter contexts when a longer one is unknown. Its log-probabilities match the
+reference n-gram to within 1e-3 nats.
+
+## How the weights are built (summary)
+
+The residual stream is split into named slots: a constant 1, the current token's code, the
+codes of the 3 previous tokens, and a logit slot.
+
+- **Embeddings:** each token gets a seeded random unit vector of size 256, plus the constant.
+- **Attention:** 3 heads with constant queries and keys. Their RoPE phases make each head look
+  exactly 1, 2 or 3 tokens back, with a margin of ≥ 30 nats. The head copies that token's code
+  into its slot.
+- **MLP:** one neuron per context of 1–4 tokens seen in the phrases (13,148 neurons in total).
+  A neuron fires only when every token in its context matches. It adds
+  `log p(next | context) − log p(next | shorter context)` to the logits. These additions
+  telescope to the log-probability under the longest known context.
+- **Norms and head:** RMSNorm weights cancel the fixed residual norms. `lm_head` reads the
+  logit slot.
+
+The [docs](docs/how-it-works.md) have the formulas, the proof of exactness, and how to
+recompile with your own phrases.
+
+## Architecture
+
+`LlamaForCausalLM` with standard modules only, so no `trust_remote_code` is needed. The settings
+are 1 layer, hidden 2088, 3 query heads, 1 KV head, head_dim 256, MLP width 13,148, vocab 1,053,
+rope_theta 2, float32.
+
+| Tensor | Params |
+|---|---|
+| `embed_tokens`, `lm_head` | 4,397,328 |
+| attention q/k/v/o | 4,276,224 |
+| MLP gate/up/down | 82,359,072 |
+| RMSNorms | 6,264 |
+| **total** | **91,038,888** |
+
+## Limitations
+
+- It only knows its ~1,100 source phrases: 1,053 words, at most 4 tokens of context, and
+  128 positions. Unknown words become `<unk>`, and the model backs off past them.
+- It's a lookup machine, not a reasoning model. On novel text it predicts common next
+  words, not meaningful continuations.
+- The prompt is treated as the start of a sentence.
+- The phrase list was written by an AI coding assistant (Claude) for this project. No
+  corpus was scraped.
+
+## Rebuild and verify
+
+```bash
+pip install -r requirements.txt
+python build_weights.py   # writes config, weights and tokenizer from phrases/*.txt
+python test_model.py      # HF loading, n-gram exactness, pipeline, TypeScript parity
+```
+
+Tested with transformers 4.52.4 and 5.22.1, Bun 1.3 and Node 24.
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `config.json`, `generation_config.json`, `model.safetensors` | model |
+| `tokenizer.json`, `tokenizer_config.json` | tokenizer |
+| `build_weights.py` | the compiler that writes every file above |
+| `phrases/*.txt` | source phrases |
+| `test_model.py` | verification suite |
+| `model.ts`, `autocomplete.ts`, `ui.ts`, `ui.html` | zero-dependency TypeScript runtime, CLI and web UI |
+| `docs/how-it-works.md` | full construction details |

autocomplete.ts

@@ -0,0 +1,37 @@
+// Command-line autocomplete tester (zero dependencies).
+//
+//   bun autocomplete.ts                     interactive prompt
+//   bun autocomplete.ts "once upon a"       complete one or more prompts
+//   bun autocomplete.ts --json "how are"    machine-readable output (used by tests)
+//
+// Also runs on Node >= 23.6 (`node autocomplete.ts`). For a browser UI see ui.ts.
+
+import { createInterface } from "node:readline";
+import { Autocompleter } from "./model.ts";
+
+const DIR = import.meta.dirname ?? new URL(".", import.meta.url).pathname;
+const ac = new Autocompleter(DIR);
+
+function show(prompt: string): void {
+  const t0 = performance.now();
+  const r = ac.complete(prompt);
+  const ms = Math.round(performance.now() - t0);
+  console.log(`${prompt}\x1b[36m${r.completion}\x1b[0m   (${ms} ms)`);
+  console.log("  next: " + r.top.map((t) => `${JSON.stringify(t.token)} ${(Math.exp(t.logprob) * 100).toFixed(1)}%`).join("  "));
+}
+
+const args = process.argv.slice(2);
+if (args[0] === "--json") {
+  console.log(JSON.stringify(args.slice(1).map((p) => ac.complete(p))));
+} else if (args.length) {
+  args.forEach(show);
+} else {
+  const cfg = ac.model.cfg;
+  console.log(`Loaded ${cfg.num_hidden_layers}-layer model, vocab ${cfg.vocab_size}. Type a prefix (Ctrl+D to quit).`);
+  const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: "> " });
+  rl.prompt();
+  rl.on("line", (line) => {
+    if (line.trim()) show(line);
+    rl.prompt();
+  });
+}

build_weights.py

@@ -0,0 +1,320 @@
+"""Compile phrases/*.txt into a Llama-format autocomplete model. No training.
+
+Every weight is set by a closed-form rule; nothing is fit by gradient descent
+and no other model is used. The result is an exact transformer implementation
+of an interpolated Witten-Bell 5-gram language model over the phrase list.
+
+Residual stream layout (hidden_size = 1 + 4*CODE_DIM + vocab):
+    [0]                     constant 1 (acts as a bias, Llama has none)
+    cur slot   (CODE_DIM)   code of the current token        <- embedding
+    prev1..3   (CODE_DIM)   codes of the 1..3 previous tokens <- attention
+    out slot   (vocab)      next-token logits, scaled by OUT_SCALE <- MLP
+
+Token codes are seeded random unit vectors (nearly orthogonal). Attention head
+a (a = 1..3) has constant query/key vectors whose RoPE phases make the score
+peak at exactly a positions back; its value copies that token's code into
+slot prev_a. Positions before the start fall back to position 0 (BOS).
+
+The MLP has one neuron per context seen in the phrases (1-4 tokens, plus one
+always-on unigram neuron). A neuron's gate sums code matches across slots
+minus (k - 0.5), so it fires only when all k tokens match. It writes
+log p(next | ctx) - log p(next | shorter ctx) into the out slot. All suffixes
+of the true context fire together, so the sum telescopes to the log
+probability under the longest matching context.
+"""
+
+import json
+import math
+from collections import Counter, defaultdict
+from functools import lru_cache
+from pathlib import Path
+
+import torch
+from safetensors.torch import save_file
+from tokenizers import Tokenizer, decoders, models, normalizers, pre_tokenizers, processors
+from transformers import GenerationConfig, LlamaConfig, PreTrainedTokenizerFast
+
+ROOT = Path(__file__).parent
+PHRASE_DIR = ROOT / "phrases"
+EOS, UNK = "<|endoftext|>", "<unk>"  # EOS doubles as BOS and pad, like GPT-2
+
+SEED = 1234
+CODE_DIM = 256
+N_PREV = 3  # previous tokens attended to; context = N_PREV + current
+ORDER = N_PREV + 1
+MAX_POS = 128
+ATTN_MARGIN = 30.0  # min attention logit gap (nats) between target and any other position
+BETA = 100.0  # gate sharpness; matched neurons sit at z = BETA / 2
+OUT_SCALE = 1e-4  # keeps the out slot tiny so the final RMSNorm scale stays fixed
+UNK_LOGIT = -30.0
+ROPE_THETA_CANDIDATES = [2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 1000.0, 10000.0]
+
+NORMALIZER = normalizers.Sequence([normalizers.NFKC(), normalizers.Lowercase()])
+PRE_TOKENIZER = pre_tokenizers.ByteLevel(add_prefix_space=True)
+
+
+def pieces(text: str) -> list[str]:
+    return [p for p, _ in PRE_TOKENIZER.pre_tokenize_str(NORMALIZER.normalize_str(text))]
+
+
+def load_phrases() -> list[list[str]]:
+    seen, out = set(), []
+    for path in sorted(PHRASE_DIR.glob("*.txt")):
+        for line in path.read_text().splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            toks = pieces(line)
+            if tuple(toks) not in seen:
+                seen.add(tuple(toks))
+                out.append(toks)
+    return out
+
+
+class NGram:
+    """Interpolated Witten-Bell n-gram; the reference the weights must reproduce."""
+
+    def __init__(self, sequences: list[list[int]], vocab_size: int):
+        self.V = vocab_size
+        self.counts = [defaultdict(Counter) for _ in range(ORDER + 1)]
+        for seq in sequences:
+            # ORDER BOS tokens: the last one is the real BOS position the model sees.
+            padded = [0] * ORDER + seq + [0]
+            for i in range(ORDER - 1, len(padded) - 1):
+                for k in range(ORDER + 1):
+                    ctx = tuple(padded[i - k + 1 : i + 1]) if k else ()
+                    self.counts[k][ctx][padded[i + 1]] += 1
+
+        uni = torch.zeros(vocab_size, dtype=torch.float64)
+        for j, c in self.counts[0][()].items():
+            uni[j] = c
+        logits = torch.log(uni + 1.0)  # add-one smoothing
+        logits[1] = UNK_LOGIT
+        self.base_logits = logits - logits[2:].mean()  # constant shift; softmax-invariant
+        self.p0 = torch.softmax(self.base_logits, 0)
+
+    @lru_cache(maxsize=None)
+    def prob(self, j: int, ctx: tuple) -> float:
+        if not ctx:
+            return self.p0[j].item()
+        lower = self.prob(j, ctx[1:])
+        table = self.counts[len(ctx)].get(ctx)
+        if table is None:
+            return lower
+        total, uniq = sum(table.values()), len(table)
+        return (table.get(j, 0) + uniq * lower) / (total + uniq)
+
+    def delta(self, ctx: tuple) -> dict[int, float]:
+        """log p_k - log p_{k-1}, minus the constant log(u/(c+u)) shared by unseen tokens."""
+        table = self.counts[len(ctx)][ctx]
+        uniq = len(table)
+        out = {}
+        for j, c in table.items():
+            q = self.prob(j, ctx[1:])
+            out[j] = math.log(c + uniq * q) - math.log(uniq * q)
+        return out
+
+    def contexts(self) -> list[tuple]:
+        return [ctx for k in range(1, ORDER + 1) for ctx in sorted(self.counts[k])]
+
+    def reference_logits(self, ids: list[int]) -> torch.Tensor:
+        """Logits (up to a constant) the model should emit after the last token of ids."""
+        t = len(ids) - 1
+        window = [ids[max(t - a, 0)] for a in range(N_PREV, -1, -1)]  # oldest .. current
+        logits = self.base_logits.clone()
+        for k in range(1, ORDER + 1):
+            ctx = tuple(window[-k:])
+            if ctx in self.counts[k]:
+                for j, d in self.delta(ctx).items():
+                    logits[j] += d
+        return logits
+
+
+def rope_attention_scale(head_dim: int) -> tuple[float, torch.Tensor, float]:
+    """Pick rope_theta maximizing the worst-case attention margin; return (theta, inv_freq, q_amp)."""
+    best = None
+    for theta in ROPE_THETA_CANDIDATES:
+        inv_freq = 1.0 / (theta ** (torch.arange(0, head_dim, 2, dtype=torch.int64).double() / head_dim))
+        offsets = torch.arange(-MAX_POS, MAX_POS + 1, dtype=torch.float64)
+        kernel = torch.cos(offsets[:, None] * inv_freq[None, :]).sum(1)  # K(x), index x + MAX_POS
+        worst = math.inf
+        for lag in range(1, N_PREV + 1):
+            for t in range(MAX_POS):
+                s_target = max(t - lag, 0)
+                xs = torch.tensor([t - s - lag for s in range(t + 1)]) + MAX_POS
+                scores = kernel[xs]
+                others = torch.cat([scores[:s_target], scores[s_target + 1 :]])
+                if len(others):
+                    worst = min(worst, (scores[s_target] - others.max()).item())
+        if best is None or worst > best[0]:
+            best = (worst, theta, inv_freq)
+    worst, theta, inv_freq = best
+    assert worst > 0, "no rope_theta separates positions"
+    # score = q_amp * sum_i cos(...) / sqrt(head_dim)  (key amplitude 1)
+    q_amp = ATTN_MARGIN * math.sqrt(head_dim) / worst
+    return theta, inv_freq, q_amp
+
+
+def build(phrases: list[list[str]]):
+    freq = Counter(p for toks in phrases for p in toks)
+    vocab = [EOS, UNK] + sorted(freq, key=lambda p: (-freq[p], p))
+    index = {p: i for i, p in enumerate(vocab)}
+    V, m = len(vocab), CODE_DIM
+    ngram = NGram([[index[p] for p in toks] for toks in phrases], V)
+    contexts = ngram.contexts()
+
+    CONST, CUR = 0, 1
+    prev_slot = [1 + a * m for a in range(N_PREV + 1)]  # prev_slot[0] is the cur slot
+    OUT = 1 + (N_PREV + 1) * m
+    n_heads, h = N_PREV, m
+    # transformers validates hidden_size % num_heads == 0; pad with unused zero dims.
+    D = -(-(OUT + V) // (8 * n_heads)) * (8 * n_heads)
+    N = 1 + len(contexts)
+
+    gen = torch.Generator().manual_seed(SEED)
+    codes = torch.randn(V, m, generator=gen, dtype=torch.float64)
+    codes /= codes.norm(dim=1, keepdim=True)
+    gram = codes @ codes.T
+    gram.fill_diagonal_(0)
+    max_coherence = gram.abs().max().item()
+    assert max_coherence < 0.4, max_coherence
+
+    embed = torch.zeros(V, D, dtype=torch.float64)
+    embed[:, CONST] = 1.0
+    embed[:, CUR : CUR + m] = codes
+
+    theta, inv_freq, q_amp = rope_attention_scale(h)
+    half = h // 2
+    q_proj = torch.zeros(n_heads * h, D, dtype=torch.float64)
+    for a in range(n_heads):
+        lag = a + 1
+        q_proj[a * h : a * h + half, CONST] = q_amp * torch.cos(lag * inv_freq)
+        q_proj[a * h + half : (a + 1) * h, CONST] = -q_amp * torch.sin(lag * inv_freq)
+    k_proj = torch.zeros(h, D, dtype=torch.float64)
+    k_proj[:half, CONST] = 1.0
+    v_proj = torch.zeros(h, D, dtype=torch.float64)
+    v_proj[:, CUR : CUR + m] = torch.eye(m, dtype=torch.float64)
+    o_proj = torch.zeros(D, n_heads * h, dtype=torch.float64)
+    for a in range(n_heads):
+        o_proj[prev_slot[a + 1] : prev_slot[a + 1] + m, a * h : (a + 1) * h] = torch.eye(m, dtype=torch.float64)
+
+    gate = torch.zeros(N, D, dtype=torch.float64)
+    up = torch.zeros(N, D, dtype=torch.float64)
+    down = torch.zeros(D, N, dtype=torch.float64)
+    on = (BETA / 2) * torch.sigmoid(torch.tensor(BETA / 2, dtype=torch.float64)).item()  # silu(BETA/2)
+    up[:, CONST] = 1.0
+    gate[0, CONST] = BETA / 2  # always-on unigram neuron
+    down[OUT : OUT + V, 0] = OUT_SCALE * ngram.base_logits / on
+    for n, ctx in enumerate(contexts, start=1):
+        k = len(ctx)
+        for a, tok in enumerate(reversed(ctx)):  # a = 0 current, a = 1 previous, ...
+            gate[n, prev_slot[a] : prev_slot[a] + m] = BETA * codes[tok]
+        gate[n, CONST] = -BETA * (k - 0.5)
+        for j, d in ngram.delta(ctx).items():
+            down[OUT + j, n] = OUT_SCALE * d / on
+
+    lm_head = torch.zeros(V, D, dtype=torch.float64)
+    lm_head[torch.arange(V), OUT + torch.arange(V)] = 1.0 / OUT_SCALE
+
+    # RMSNorm weights undo the norm for the (fixed) input norms: |x|^2 = 2 before
+    # attention, 1 + 1 + N_PREV after it.
+    attn_norm = math.sqrt(2 / D)
+    mlp_norm = math.sqrt((2 + N_PREV) / D)
+    state = {
+        "model.embed_tokens.weight": embed,
+        "model.layers.0.input_layernorm.weight": torch.full((D,), attn_norm),
+        "model.layers.0.self_attn.q_proj.weight": q_proj,
+        "model.layers.0.self_attn.k_proj.weight": k_proj,
+        "model.layers.0.self_attn.v_proj.weight": v_proj,
+        "model.layers.0.self_attn.o_proj.weight": o_proj,
+        "model.layers.0.post_attention_layernorm.weight": torch.full((D,), mlp_norm),
+        "model.layers.0.mlp.gate_proj.weight": gate,
+        "model.layers.0.mlp.up_proj.weight": up,
+        "model.layers.0.mlp.down_proj.weight": down,
+        "model.norm.weight": torch.full((D,), mlp_norm),
+        "lm_head.weight": lm_head,
+    }
+    state = {k: v.to(torch.float32).contiguous() for k, v in state.items()}
+
+    config = LlamaConfig(
+        vocab_size=V,
+        hidden_size=D,
+        intermediate_size=N,
+        num_hidden_layers=1,
+        num_attention_heads=n_heads,
+        num_key_value_heads=1,
+        head_dim=h,
+        hidden_act="silu",
+        max_position_embeddings=MAX_POS,
+        rms_norm_eps=1e-10,
+        rope_theta=theta,
+        tie_word_embeddings=False,
+        bos_token_id=0,
+        eos_token_id=0,
+        pad_token_id=0,
+    )
+    info = {
+        "vocab": V,
+        "hidden": D,
+        "neurons": N,
+        "rope_theta": theta,
+        "max_code_coherence": round(max_coherence, 3),
+        "params": sum(t.numel() for t in state.values()),
+    }
+    return vocab, ngram, state, config, info
+
+
+def build_tokenizer(vocab: list[str]) -> PreTrainedTokenizerFast:
+    tok = Tokenizer(models.WordLevel({p: i for i, p in enumerate(vocab)}, unk_token=UNK))
+    tok.normalizer = NORMALIZER
+    tok.pre_tokenizer = PRE_TOKENIZER
+    tok.decoder = decoders.ByteLevel()
+    tok.post_processor = processors.TemplateProcessing(single=f"{EOS} $A", special_tokens=[(EOS, 0)])
+    return PreTrainedTokenizerFast(
+        tokenizer_object=tok,
+        bos_token=EOS,
+        eos_token=EOS,
+        unk_token=UNK,
+        pad_token=EOS,
+        clean_up_tokenization_spaces=False,
+        model_max_length=MAX_POS,
+    )
+
+
+def compile_model():
+    """Build everything in memory (used by the tests for the n-gram reference)."""
+    phrases = load_phrases()
+    return (len(phrases), *build(phrases))
+
+
+def main() -> None:
+    n_phrases, vocab, _, state, config, info = compile_model()
+    assert info["params"] <= 1_000_000_000, info
+
+    save_file(state, ROOT / "model.safetensors", metadata={"format": "pt"})
+    config.save_pretrained(ROOT)
+    cfg_path = ROOT / "config.json"
+    cfg = json.loads(cfg_path.read_text())
+    cfg["architectures"] = ["LlamaForCausalLM"]
+    cfg["rope_theta"] = info["rope_theta"]  # transformers 4.x reads this key, 5.x reads rope_parameters
+    cfg["torch_dtype"] = "float32"
+    cfg_path.write_text(json.dumps(cfg, indent=2, sort_keys=True) + "\n")
+    GenerationConfig(bos_token_id=0, eos_token_id=0, pad_token_id=0, do_sample=False, max_new_tokens=16).save_pretrained(ROOT)
+
+    build_tokenizer(vocab).save_pretrained(ROOT)
+    # transformers 5 writes "TokenizersBackend", which 4.x can't resolve;
+    # PreTrainedTokenizerFast loads on both. 4.x also emits token_type_ids
+    # by default, which Llama's generate() rejects, and overrides the
+    # pre-tokenizer's add_prefix_space unless the config states it.
+    tok_cfg_path = ROOT / "tokenizer_config.json"
+    tok_cfg = json.loads(tok_cfg_path.read_text())
+    tok_cfg["tokenizer_class"] = "PreTrainedTokenizerFast"
+    tok_cfg["add_prefix_space"] = True
+    tok_cfg["model_input_names"] = ["input_ids", "attention_mask"]
+    tok_cfg_path.write_text(json.dumps(tok_cfg, indent=2) + "\n")
+
+    print(json.dumps({"phrases": n_phrases, **info}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

config.json

@@ -0,0 +1,33 @@
+{
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 0,
+  "eos_token_id": 0,
+  "head_dim": 256,
+  "hidden_act": "silu",
+  "hidden_size": 2088,
+  "initializer_range": 0.02,
+  "intermediate_size": 13148,
+  "max_position_embeddings": 128,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 3,
+  "num_hidden_layers": 1,
+  "num_key_value_heads": 1,
+  "pad_token_id": 0,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-10,
+  "rope_parameters": {
+    "rope_theta": 2.0,
+    "rope_type": "default"
+  },
+  "rope_theta": 2.0,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float32",
+  "transformers_version": "5.22.1",
+  "use_cache": true,
+  "vocab_size": 1053
+}

docs/how-it-works.md

@@ -0,0 +1,151 @@
+# How tiny-autocomplete was built
+
+This model was **compiled, not trained**. No gradient descent, no optimizer, no
+pretrained weights, and no other model's outputs were used. `build_weights.py` turns
+a phrase list into a standard `LlamaForCausalLM` checkpoint using closed-form rules.
+Running it twice gives byte-identical weights.
+
+The network computes an **interpolated Witten-Bell 5-gram language model** exactly. It
+predicts the next token from the current token and up to 3 before it.
+
+## 1. Phrases and tokenizer
+
+`phrases/*.txt` holds about 1,100 common English sentences, one per line, in four files:
+social phrases, everyday requests, idioms and proverbs, and opinions and work phrases. The
+list was written for this project by an AI coding assistant (Claude). No corpus was scraped.
+
+The tokenizer is word-level with GPT-2 style byte-level pre-tokenization:
+
+- NFKC normalization, then lowercase.
+- Split on the GPT-2 regex. Words keep their leading space as `Ġ`, and punctuation and
+  contractions (`'s`, `'t`, ...) become their own tokens.
+- Each piece found in the phrases is one vocabulary entry (1,053 total), plus two specials:
+  `<|endoftext|>` (id 0, used as BOS, EOS and pad) and `<unk>` (id 1).
+- A post-processor prepends BOS, so every prompt starts at position 0 with `<|endoftext|>`.
+
+## 2. The reference n-gram
+
+Each phrase becomes `[BOS, BOS, BOS, BOS, w1, ..., wn, EOS]`. For every position, the
+compiler counts which token follows each context of length k = 0..4 that ends there.
+
+- **Order 0:** add-one-smoothed unigram, with `<unk>` pinned at logit -30.
+- **Order k ≥ 1:** Witten-Bell interpolation with the next-shorter context (drop the
+  oldest token):
+
+  ```
+  p_k(j | ctx) = (c(ctx, j) + u(ctx) * p_{k-1}(j | ctx[1:])) / (c(ctx) + u(ctx))
+  ```
+
+  Here `c` is a count and `u(ctx)` is the number of distinct tokens seen after `ctx`.
+  An unseen context backs off: `p_k = p_{k-1}`.
+
+The model must reproduce `p_K(· | longest known context)`, where K is the longest context
+that appears in the phrase list.
+
+## 3. The residual stream as named slots
+
+| Dims | Slot | Written by |
+|---|---|---|
+| 0 | constant `1` (Llama has no biases; this plays that role) | embedding |
+| 1–256 | code of the **current** token | embedding |
+| 257–512 | code of the token **1 back** | attention head 1 |
+| 513–768 | code of the token **2 back** | attention head 2 |
+| 769–1024 | code of the token **3 back** | attention head 3 |
+| 1025–2077 | **logits**, one dim per vocab entry, scaled by 1e-4 | MLP |
+| 2078–2087 | unused padding (transformers wants hidden % heads == 0) | — |
+
+**Token codes** are seeded Gaussian vectors in 256 dimensions, normalized to unit
+length. With 1,053 of them, the largest |cosine| between two different codes is 0.30.
+That's far enough below 1 that a "match" (dot = 1) and a "non-match" (dot ≤ 0.3) can't
+be confused.
+
+## 4. Attention: previous-token heads from RoPE alone
+
+Llama has no absolute positions. The only position signal is RoPE, which rotates query
+and key pairs by `position * inv_freq[i]`.
+
+- The **key** for every token is the same constant (read from the constant dim): 1 on
+  the first half of each RoPE pair.
+- The **query** for head *a* is also constant, with each pair's phase set to
+  `-a * inv_freq[i]`. The attention score between positions t and s is then
+
+  ```
+  score(t, s) = A * Σ_i cos((t - s - a) * inv_freq[i]) / sqrt(head_dim)
+  ```
+
+  which peaks exactly when `s = t - a`.
+- When `t < a` there is no position `a` back, and the closest position is 0, which is BOS.
+  The model then "sees" BOS in that slot, matching the BOS padding used when counting.
+- `rope_theta` is picked from a candidate list to maximize the worst-case gap between the
+  target position and every other position, for all t < 128 and a ∈ {1, 2, 3}. It came out
+  to 2. The amplitude `A` then scales that worst gap to **30 nats**, so softmax puts
+  > 0.9999999 weight on the target.
+- **Value** = the current-token code. **Output projection** = identity into slot *a*.
+
+All 3 heads share one key/value head (`num_key_value_heads = 1`).
+
+## 5. MLP: one neuron per context
+
+Llama's MLP is `down(silu(gate(x)) * up(x))`. The compiler creates one neuron for each
+context seen in the phrases (13,147 of them, lengths 1–4) and one always-on unigram neuron.
+
+For a context `(c_{k-1}, ..., c_1, c_0)` of length k (c_0 = current token):
+
+- **gate** = `100 * (code(c_0)·cur + code(c_1)·prev1 + ... - (k - 0.5) * const)`.
+  If all k tokens match, this is `+50`. If any one fails (dot ≤ 0.3), it's at most
+  `100 * (0.3 - 0.5) = -20`, and `silu(-20)` ≈ -4e-8, effectively off.
+- **up** = 1 (the constant dim).
+- **down** writes, for each token j seen after this context,
+
+  ```
+  delta_j = log p_k(j | ctx) - log p_{k-1}(j | ctx[1:])
+  ```
+
+  into the logit slot. The constant `log(u/(c+u))` shared by every unseen token is
+  dropped, since softmax ignores constant shifts. That makes the column sparse.
+
+**Why this is exact.** If a context of length k is in the table, so are all its shorter
+suffixes, and their neurons fire too. The unigram neuron writes `log p_0`, and the
+neurons for lengths 1..K add their deltas. The sum telescopes to `log p_K(· | longest
+known context)` plus a constant. No neuron has to know which context is the longest.
+
+## 6. Norms and output head
+
+- The residual has a known fixed norm at each point: |x|² = 2 before attention and 5
+  after it. Each RMSNorm weight is set to `sqrt(norm² / hidden)`, so the norms leave the
+  stream unchanged.
+- The MLP writes logits scaled by 1e-4, so they barely change the final norm (< 0.02%).
+- `lm_head` is `1e4` times the identity on the logit slot.
+
+## 7. Verification (`test_model.py`)
+
+The tests check the following:
+- **Hugging Face loading:** the files load with `AutoModelForCausalLM`, `AutoTokenizer` and
+  `pipeline("text-generation")` on transformers 4.52 and 5.22.
+- **Exactness:** next-token log-probs match the reference n-gram within 5e-3 nats (observed
+  ~8e-4). This is checked on 200 phrase prefixes and 50 random word-salad sequences of up to
+  80 tokens.
+- **Completions:** a set of prompts produce the expected greedy completions.
+- **Unknown words:** out-of-vocabulary words back off cleanly.
+- **TypeScript parity:** the zero-dependency TypeScript runtime (`model.ts`) gives the same
+  top-3 tokens and log-probs as PyTorch.
+
+## 8. Changing it
+
+Edit or add lines in `phrases/*.txt`, then run `python build_weights.py` and
+`python test_model.py`. The size grows with the number of distinct contexts. The MLP
+dominates at about 3 × hidden × contexts parameters. Settings at the top of
+`build_weights.py`:
+
+| Constant | Meaning |
+|---|---|
+| `CODE_DIM` | token-code size (bigger means fewer near-collisions and a larger model) |
+| `N_PREV` | how many previous tokens are attended to (n-gram order = N_PREV + 2) |
+| `MAX_POS` | longest sequence the attention margin is guaranteed for |
+| `ATTN_MARGIN`, `BETA` | sharpness of attention and of the neuron gates |
+
+## History
+
+The first version was a 120-parameter model (hidden size 2) that only knew a single next word
+for each of 22 words. That size can't hold any context, so the design was scaled up to this
+compiled n-gram, staying under a 1B-parameter budget.

generation_config.json

@@ -0,0 +1,8 @@
+{
+  "bos_token_id": 0,
+  "do_sample": false,
+  "eos_token_id": 0,
+  "max_new_tokens": 16,
+  "pad_token_id": 0,
+  "transformers_version": "5.22.1"
+}

model.safetensors

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

model.ts

@@ -0,0 +1,266 @@
+// Zero-dependency inference for this model: reads config.json, model.safetensors
+// and tokenizer.json and runs the Llama forward pass in plain TypeScript.
+// No ML library, no other model. Used by autocomplete.ts (CLI) and ui.ts (web UI).
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export type Config = {
+  vocab_size: number;
+  hidden_size: number;
+  intermediate_size: number;
+  num_hidden_layers: number;
+  num_attention_heads: number;
+  num_key_value_heads: number;
+  head_dim?: number;
+  rms_norm_eps: number;
+  rope_theta?: number;
+  rope_parameters?: { rope_theta: number };
+  max_position_embeddings: number;
+  eos_token_id: number;
+};
+
+// ---------- safetensors ----------
+
+function loadSafetensors(path: string): Map<string, Float32Array> {
+  const buf = readFileSync(path);
+  const headerLen = Number(buf.readBigUInt64LE(0));
+  const header = JSON.parse(buf.subarray(8, 8 + headerLen).toString("utf8"));
+  const base = 8 + headerLen;
+  const tensors = new Map<string, Float32Array>();
+  for (const [name, info] of Object.entries<any>(header)) {
+    if (name === "__metadata__") continue;
+    if (info.dtype !== "F32") throw new Error(`${name}: unsupported dtype ${info.dtype}`);
+    const [begin, end] = info.data_offsets as [number, number];
+    const offset = buf.byteOffset + base + begin;
+    const length = (end - begin) / 4;
+    tensors.set(
+      name,
+      offset % 4 === 0
+        ? new Float32Array(buf.buffer, offset, length)
+        : new Float32Array(buf.buffer.slice(offset, offset + length * 4)),
+    );
+  }
+  return tensors;
+}
+
+// ---------- tokenizer (WordLevel + ByteLevel, as in tokenizer.json) ----------
+
+function bytesToUnicode(): Map<number, string> {
+  const bs: number[] = [];
+  for (let b = 33; b <= 126; b++) bs.push(b);
+  for (let b = 161; b <= 172; b++) bs.push(b);
+  for (let b = 174; b <= 255; b++) bs.push(b);
+  const cs = [...bs];
+  let n = 0;
+  for (let b = 0; b < 256; b++) {
+    if (!bs.includes(b)) {
+      bs.push(b);
+      cs.push(256 + n++);
+    }
+  }
+  return new Map(bs.map((b, i) => [b, String.fromCodePoint(cs[i])]));
+}
+
+const GPT2_SPLIT = /'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+/gu;
+
+export class Tokenizer {
+  vocab: Map<string, number>;
+  inverse: string[];
+  special = new Set<number>();
+  unkId: number;
+  bosId: number;
+  private byteEnc = bytesToUnicode();
+  private byteDec = new Map([...this.byteEnc].map(([b, c]) => [c, b]));
+
+  constructor(path: string) {
+    const json = JSON.parse(readFileSync(path, "utf8"));
+    this.vocab = new Map(Object.entries<number>(json.model.vocab));
+    this.inverse = [];
+    for (const [tok, id] of this.vocab) this.inverse[id] = tok;
+    for (const t of json.added_tokens ?? []) if (t.special) this.special.add(t.id);
+    this.unkId = this.vocab.get(json.model.unk_token)!;
+    const bos = json.post_processor?.single?.find((p: any) => p.SpecialToken)?.SpecialToken?.id;
+    this.bosId = this.vocab.get(bos)!;
+  }
+
+  encode(text: string): number[] {
+    let norm = text.normalize("NFKC").toLowerCase();
+    if (!/^\s/.test(norm)) norm = " " + norm; // ByteLevel add_prefix_space
+    const ids = [this.bosId];
+    for (const piece of norm.match(GPT2_SPLIT) ?? []) {
+      const mapped = [...new TextEncoder().encode(piece)].map((b) => this.byteEnc.get(b)!).join("");
+      ids.push(this.vocab.get(mapped) ?? this.unkId);
+    }
+    return ids;
+  }
+
+  decode(ids: number[]): string {
+    const chars = ids.filter((id) => !this.special.has(id)).map((id) => this.inverse[id]).join("");
+    return new TextDecoder().decode(new Uint8Array([...chars].map((c) => this.byteDec.get(c) ?? 63)));
+  }
+}
+
+// ---------- Llama forward pass ----------
+
+function matvec(w: Float32Array, x: Float64Array, rows: number, cols: number): Float64Array {
+  const y = new Float64Array(rows);
+  for (let r = 0; r < rows; r++) {
+    let s = 0;
+    const off = r * cols;
+    for (let c = 0; c < cols; c++) s += w[off + c] * x[c];
+    y[r] = s;
+  }
+  return y;
+}
+
+function rmsnorm(x: Float64Array, w: Float32Array, eps: number): Float64Array {
+  let ss = 0;
+  for (const v of x) ss += v * v;
+  const inv = 1 / Math.sqrt(ss / x.length + eps);
+  return x.map((v, i) => v * inv * w[i]);
+}
+
+export class Llama {
+  cfg: Config;
+  w: Map<string, Float32Array>;
+  headDim: number;
+  invFreq: Float64Array;
+
+  constructor(dir: string) {
+    this.cfg = JSON.parse(readFileSync(join(dir, "config.json"), "utf8"));
+    this.w = loadSafetensors(join(dir, "model.safetensors"));
+    const c = this.cfg;
+    this.headDim = c.head_dim ?? c.hidden_size / c.num_attention_heads;
+    const theta = c.rope_parameters?.rope_theta ?? c.rope_theta ?? 10000;
+    const half = this.headDim / 2;
+    this.invFreq = new Float64Array(half).map((_, i) => 1 / theta ** ((2 * i) / this.headDim));
+  }
+
+  get numParams(): number {
+    let n = 0;
+    for (const t of this.w.values()) n += t.length;
+    return n;
+  }
+
+  private t(name: string): Float32Array {
+    const t = this.w.get(name);
+    if (!t) throw new Error(`missing tensor ${name}`);
+    return t;
+  }
+
+  private rope(vec: Float64Array, offset: number, pos: number): void {
+    const half = this.headDim / 2;
+    for (let i = 0; i < half; i++) {
+      const a = pos * this.invFreq[i];
+      const cos = Math.cos(a), sin = Math.sin(a);
+      const x1 = vec[offset + i], x2 = vec[offset + i + half];
+      vec[offset + i] = x1 * cos - x2 * sin;
+      vec[offset + i + half] = x2 * cos + x1 * sin;
+    }
+  }
+
+  /** Log-probabilities of the next token after `ids`. */
+  nextLogprobs(ids: number[]): Float64Array {
+    const c = this.cfg, D = c.hidden_size, H = c.num_attention_heads, KV = c.num_key_value_heads;
+    const hd = this.headDim, I = c.intermediate_size, L = c.num_hidden_layers;
+    const embed = this.t("model.embed_tokens.weight");
+    const keys: Float64Array[][] = Array.from({ length: L }, () => []);
+    const vals: Float64Array[][] = Array.from({ length: L }, () => []);
+    let x = new Float64Array(D);
+
+    for (let pos = 0; pos < ids.length; pos++) {
+      x = Float64Array.from(embed.subarray(ids[pos] * D, (ids[pos] + 1) * D));
+      const last = pos === ids.length - 1;
+      for (let l = 0; l < L; l++) {
+        const p = `model.layers.${l}.`;
+        const xn = rmsnorm(x, this.t(p + "input_layernorm.weight"), c.rms_norm_eps);
+        const q = matvec(this.t(p + "self_attn.q_proj.weight"), xn, H * hd, D);
+        const k = matvec(this.t(p + "self_attn.k_proj.weight"), xn, KV * hd, D);
+        const v = matvec(this.t(p + "self_attn.v_proj.weight"), xn, KV * hd, D);
+        for (let h = 0; h < H; h++) this.rope(q, h * hd, pos);
+        for (let h = 0; h < KV; h++) this.rope(k, h * hd, pos);
+        keys[l].push(k);
+        vals[l].push(v);
+
+        const attn = new Float64Array(H * hd);
+        for (let h = 0; h < H; h++) {
+          const kvh = Math.floor(h / (H / KV)) * hd;
+          const scores = keys[l].map((kk) => {
+            let s = 0;
+            for (let d = 0; d < hd; d++) s += q[h * hd + d] * kk[kvh + d];
+            return s / Math.sqrt(hd);
+          });
+          const max = Math.max(...scores);
+          const exps = scores.map((s) => Math.exp(s - max));
+          const z = exps.reduce((a, b) => a + b, 0);
+          exps.forEach((e, s) => {
+            for (let d = 0; d < hd; d++) attn[h * hd + d] += (e / z) * vals[l][s][kvh + d];
+          });
+        }
+        const o = matvec(this.t(p + "self_attn.o_proj.weight"), attn, D, H * hd);
+        for (let i = 0; i < D; i++) x[i] += o[i];
+
+        // The last layer's MLP only matters where we read logits.
+        if (l === L - 1 && !last) continue;
+        const xn2 = rmsnorm(x, this.t(p + "post_attention_layernorm.weight"), c.rms_norm_eps);
+        const g = matvec(this.t(p + "mlp.gate_proj.weight"), xn2, I, D);
+        const u = matvec(this.t(p + "mlp.up_proj.weight"), xn2, I, D);
+        for (let i = 0; i < I; i++) g[i] = (g[i] / (1 + Math.exp(-g[i]))) * u[i];
+        const dn = matvec(this.t(p + "mlp.down_proj.weight"), g, D, I);
+        for (let i = 0; i < D; i++) x[i] += dn[i];
+      }
+    }
+
+    const logits = matvec(this.t("lm_head.weight"), rmsnorm(x, this.t("model.norm.weight"), c.rms_norm_eps), c.vocab_size, D);
+    const max = Math.max(...logits);
+    const lse = max + Math.log(logits.reduce((a, v) => a + Math.exp(v - max), 0));
+    return logits.map((v) => v - lse);
+  }
+}
+
+// ---------- autocomplete ----------
+
+export type Completion = {
+  prompt: string;
+  completion: string;
+  top: { id: number; token: string; logprob: number }[];
+};
+
+export class Autocompleter {
+  tok: Tokenizer;
+  model: Llama;
+  maxNew: number;
+
+  constructor(dir: string) {
+    this.tok = new Tokenizer(join(dir, "tokenizer.json"));
+    this.model = new Llama(dir);
+    const gen = JSON.parse(readFileSync(join(dir, "generation_config.json"), "utf8"));
+    this.maxNew = gen.max_new_tokens ?? 16;
+  }
+
+  /** Greedy completion plus the top-k candidates for the next token. */
+  complete(prompt: string, topK = 3): Completion {
+    const { tok, model } = this;
+    const ids = tok.encode(prompt);
+    const first = model.nextLogprobs(ids);
+    const top = [...first.keys()]
+      .sort((a, b) => first[b] - first[a])
+      .slice(0, topK)
+      .map((id) => ({ id, token: tok.decode([id]) || tok.inverse[id], logprob: first[id] }));
+    const out: number[] = [];
+    let next = argmax(first);
+    while (next !== model.cfg.eos_token_id && out.length < this.maxNew && ids.length < model.cfg.max_position_embeddings) {
+      out.push(next);
+      ids.push(next);
+      next = argmax(model.nextLogprobs(ids));
+    }
+    return { prompt, completion: tok.decode(out), top };
+  }
+}
+
+function argmax(a: Float64Array): number {
+  let best = 0;
+  for (let i = 1; i < a.length; i++) if (a[i] > a[best]) best = i;
+  return best;
+}

phrases/everyday.txt

@@ -0,0 +1,275 @@
+Can you help me?
+Can you help me with this?
+Can you help me, please?
+Can you do me a favor?
+Can you call me back?
+Can you call me back later?
+Can you say that again?
+Can you repeat that, please?
+Can you speak more slowly, please?
+Can you send me the file?
+Can you pick me up?
+Can you pick me up at the airport?
+Can you turn off the lights?
+Can you turn on the lights?
+Can you turn down the music?
+Can you open the window?
+Can you close the door?
+Can you pass the salt, please?
+Can you give me a hand?
+Can you tell me the way to the station?
+Can I have the check, please?
+Can I have a glass of water?
+Can I have the menu, please?
+Can I get a glass of water?
+Can I get a cup of coffee?
+Can I get the bill, please?
+Can I pay by card?
+Can I pay with cash?
+Can I try this on?
+Can I borrow your pen?
+Can I use your phone?
+Can I use the bathroom?
+Can I ask a question?
+Can I talk to you for a minute?
+Can I come with you?
+Could you help me, please?
+Could you please help me?
+Could you tell me where the bathroom is?
+Could you please send me the details?
+Could you please call me back?
+Could I have some water, please?
+Would you like some coffee?
+Would you like some tea?
+Would you like something to drink?
+Would you like to join us?
+Would you like to come over?
+Would you mind closing the door?
+Would you mind helping me?
+Do you have a minute?
+Do you have any questions?
+Do you have the time?
+Do you have a table for two?
+Do you know what time it is?
+Do you know where the station is?
+Do you know how to get there?
+Do you speak English?
+Do you need any help?
+Do you need a ride?
+Do you want something to eat?
+Do you want to go out tonight?
+Do you accept credit cards?
+What time is it?
+What time is it now?
+What time do you open?
+What time do you close?
+What time does the train leave?
+What time does the meeting start?
+What time should we meet?
+What day is it today?
+What is the date today?
+What's the weather like today?
+What's the weather like tomorrow?
+What do you want to eat?
+What do you want to do?
+What do you mean?
+What do you think?
+What happened?
+What is this?
+What is that?
+What's wrong?
+What's for dinner?
+What would you like to order?
+What would you recommend?
+Where is the bathroom?
+Where is the restroom?
+Where is the nearest hospital?
+Where is the train station?
+Where is the bus stop?
+Where is the exit?
+Where are you?
+Where are you going?
+Where are my keys?
+Where did you put it?
+Where do you live?
+Where should we meet?
+How much is this?
+How much does it cost?
+How much is it?
+How much do I owe you?
+How do I get there?
+How do I get to the airport?
+How do you spell that?
+How do you say that in English?
+How do you know?
+How long does it take?
+How long will it take?
+How long have you been here?
+How far is it?
+How many people are coming?
+How old are you?
+How was the movie?
+When is the meeting?
+When are you coming home?
+When will you be back?
+When does the store open?
+When does the store close?
+Why are you late?
+Why not?
+Who is calling, please?
+Who is it?
+Is it going to rain today?
+Is there a bank near here?
+Is there a pharmacy near here?
+Is this the right way?
+Is breakfast included?
+It's going to rain today.
+It's very hot today.
+It's really cold outside.
+It's raining outside.
+It's snowing outside.
+It looks like rain.
+Don't forget your umbrella.
+Don't forget to call me.
+Don't forget to lock the door.
+I'm hungry.
+I'm thirsty.
+I'm tired.
+I'm so tired.
+I'm busy right now.
+I'm running late.
+I'm going to be late.
+I'll be home late tonight.
+I'm going to bed.
+I'm going to the store.
+I'm going to the gym.
+I'm going home.
+I'm leaving now.
+I'm looking for the bathroom.
+I'm looking for a job.
+I'm just looking, thank you.
+I'm not feeling well.
+I don't feel well.
+I have a headache.
+I have a cold.
+I have a doctor's appointment.
+I need to see a doctor.
+I need to go to the hospital.
+I need to go to the store.
+I need to go to work.
+I need to go to bed.
+I need to talk to you.
+I need some help.
+I need your help.
+I need a break.
+I need more time.
+I need to make a reservation.
+I would like to make a reservation.
+I would like to order a pizza.
+I would like a cup of coffee, please.
+I would like the chicken, please.
+I'd like to book a table for two.
+I'd like to check in, please.
+I'd like to check out, please.
+I'll have the same.
+I'll have a coffee, please.
+I'll take it.
+I'll pay for dinner.
+I'll call you back.
+I'll see you there.
+I'll be there in five minutes.
+I'll get back to you.
+I'll do it later.
+I'll think about it.
+I lost my keys.
+I lost my phone.
+I forgot my password.
+I can't find my keys.
+I can't find my phone.
+I can't hear you.
+I don't understand.
+I don't know.
+I don't know what to do.
+I don't have time.
+I didn't know that.
+I have a question.
+I have an idea.
+I have to go.
+I have to go now.
+I have to work tomorrow.
+I got it.
+I understand.
+I agree.
+Let's go.
+Let's go home.
+Let's go out for dinner.
+Let's eat.
+Let's get started.
+Let's meet at the coffee shop.
+Let's talk about it later.
+Let's take a break.
+Let's watch a movie.
+Let me check.
+Let me help you.
+Let me think about it.
+Let me see.
+Let me call you back.
+Please call me back.
+Please wait a moment.
+Please hold on.
+Please sit down.
+Please turn off your phone.
+Please be quiet.
+Please close the door.
+Please wait here.
+Just a moment, please.
+Just a minute.
+One moment, please.
+Hold on a second.
+Wait for me.
+Hurry up.
+Come here.
+Come with me.
+Follow me.
+Turn left at the corner.
+Turn right at the light.
+Go straight ahead.
+It's on the left.
+It's on the right.
+It's right over there.
+It's not far from here.
+It's just around the corner.
+The meeting is at noon.
+The meeting has been canceled.
+The train is late.
+The store is closed.
+The food is delicious.
+The bill, please.
+Check, please.
+Table for two, please.
+A cup of coffee, please.
+A glass of water, please.
+Water, please.
+Keep the change.
+Here you go.
+Here it is.
+This is delicious.
+This is too expensive.
+That sounds good.
+That sounds great.
+That works for me.
+See you at the meeting.
+Call me if you need anything.
+Call an ambulance.
+Help me, please.
+Help!
+Watch out!
+Be careful.
+Drive safely.
+Did you eat yet?
+Did you sleep well?
+Did you get my message?
+Did you see that?
+Have you eaten yet?
+Have you seen my keys?
+Have you been here before?

phrases/idioms.txt

@@ -0,0 +1,321 @@
+Once upon a time.
+The quick brown fox jumps over the lazy dog.
+Better late than never.
+Actions speak louder than words.
+It's raining cats and dogs.
+Practice makes perfect.
+When in Rome, do as the Romans do.
+Better safe than sorry.
+Every cloud has a silver lining.
+A piece of cake.
+A blessing in disguise.
+A penny saved is a penny earned.
+A penny for your thoughts.
+A watched pot never boils.
+A stitch in time saves nine.
+A picture is worth a thousand words.
+A friend in need is a friend indeed.
+A chip off the old block.
+A leopard can't change its spots.
+A bird in the hand is worth two in the bush.
+A rolling stone gathers no moss.
+A dime a dozen.
+A diamond in the rough.
+A fish out of water.
+A jack of all trades.
+A drop in the bucket.
+A needle in a haystack.
+A wild goose chase.
+A lost cause.
+A heart of gold.
+A chip on your shoulder.
+A clean slate.
+A hard pill to swallow.
+A shot in the dark.
+A rule of thumb.
+A red herring.
+A dog eat dog world.
+A light at the end of the tunnel.
+A sight for sore eyes.
+Absence makes the heart grow fonder.
+All that glitters is not gold.
+All's fair in love and war.
+All's well that ends well.
+All good things must come to an end.
+All roads lead to Rome.
+All bark and no bite.
+All in a day's work.
+All thumbs.
+An apple a day keeps the doctor away.
+An eye for an eye.
+An ounce of prevention is worth a pound of cure.
+An eager beaver.
+As easy as pie.
+As American as apple pie.
+As cool as a cucumber.
+As fit as a fiddle.
+As happy as a clam.
+As light as a feather.
+As old as the hills.
+As plain as the nose on your face.
+As quiet as a mouse.
+As right as rain.
+As sly as a fox.
+As stubborn as a mule.
+As white as a ghost.
+As busy as a bee.
+As dead as a doornail.
+As clear as mud.
+As good as gold.
+As mad as a hatter.
+As strong as an ox.
+As cute as a button.
+As blind as a bat.
+Back to the drawing board.
+Barking up the wrong tree.
+Beauty is in the eye of the beholder.
+Beggars can't be choosers.
+Better the devil you know.
+Birds of a feather flock together.
+Bite off more than you can chew.
+Bite the bullet.
+Bite the hand that feeds you.
+Blood is thicker than water.
+Break a leg.
+Burn the midnight oil.
+Burn the candle at both ends.
+By the skin of your teeth.
+Beat around the bush.
+Bend over backwards.
+The best of both worlds.
+Beyond the pale.
+Bite the dust.
+Blow off steam.
+Break the ice.
+Burn your bridges.
+Bury the hatchet.
+His bark is worse than his bite.
+Break even.
+Caught between a rock and a hard place.
+Charity begins at home.
+Cleanliness is next to godliness.
+Curiosity killed the cat.
+Cut corners.
+Cut to the chase.
+Call it a day.
+Caught red-handed.
+Come rain or shine.
+Cost an arm and a leg.
+Cross that bridge when you come to it.
+Cry wolf.
+Call a spade a spade.
+Close but no cigar.
+Cut your losses.
+The calm before the storm.
+The cold shoulder.
+Don't judge a book by its cover.
+Don't cry over spilled milk.
+Don't count your chickens before they hatch.
+Don't look a gift horse in the mouth.
+Don't put all your eggs in one basket.
+Don't rock the boat.
+Don't make a mountain out of a molehill.
+Down in the dumps.
+Draw the line.
+Easy come, easy go.
+Every dog has its day.
+Every man for himself.
+Every rose has its thorn.
+Easier said than done.
+The elephant in the room.
+Familiarity breeds contempt.
+Fight fire with fire.
+First come, first served.
+Fortune favors the bold.
+Face the music.
+A fly on the wall.
+Fool me once, shame on you, fool me twice, shame on me.
+Give him an inch and he'll take a mile.
+Go against the grain.
+Good things come to those who wait.
+Great minds think alike.
+Get a taste of your own medicine.
+Get the ball rolling.
+Get up on the wrong side of the bed.
+Give the benefit of the doubt.
+Go back to square one.
+Go the extra mile.
+Go with the flow.
+It goes without saying.
+Grasping at straws.
+Haste makes waste.
+Health is wealth.
+Herding cats.
+History repeats itself.
+Hit the nail on the head.
+Honesty is the best policy.
+Hope for the best, prepare for the worst.
+Hang in there.
+Head in the clouds.
+Head over heels.
+Hit the hay.
+Hit the sack.
+Hold your horses.
+If it ain't broke, don't fix it.
+If the shoe fits, wear it.
+Ignorance is bliss.
+It never rains but it pours.
+It takes two to tango.
+It's a small world.
+It's better to give than to receive.
+It's never too late.
+It's the thought that counts.
+In a nutshell.
+In the heat of the moment.
+In the nick of time.
+It takes one to know one.
+Jump on the bandwagon.
+Jump the gun.
+Keep your chin up.
+Keep your eye on the ball.
+Keep your friends close and your enemies closer.
+Keep your fingers crossed.
+Kill two birds with one stone.
+Kick the bucket.
+Knowledge is power.
+Laughter is the best medicine.
+Let bygones be bygones.
+Let sleeping dogs lie.
+Let the cat out of the bag.
+Life is short.
+Live and learn.
+Look before you leap.
+Love is blind.
+Learn the ropes.
+Let the chips fall where they may.
+Live and let live.
+Make hay while the sun shines.
+Many hands make light work.
+Measure twice, cut once.
+Misery loves company.
+Money can't buy happiness.
+Money doesn't grow on trees.
+Money is the root of all evil.
+Monkey see, monkey do.
+Make ends meet.
+There's a method to the madness.
+Miss the boat.
+Make a long story short.
+Necessity is the mother of invention.
+Never put off until tomorrow what you can do today.
+Never say never.
+No news is good news.
+No pain, no gain.
+No man is an island.
+No time like the present.
+Nothing ventured, nothing gained.
+There's no rest for the wicked.
+Once bitten, twice shy.
+One good turn deserves another.
+One man's trash is another man's treasure.
+Opportunity knocks but once.
+Out of sight, out of mind.
+Out of the frying pan and into the fire.
+Out of the blue.
+Off the beaten path.
+Off the hook.
+On the ball.
+On the same page.
+On thin ice.
+Once in a blue moon.
+Over the moon.
+Patience is a virtue.
+Pride comes before a fall.
+Put the cart before the horse.
+Par for the course.
+Pass the buck.
+Play it by ear.
+Play devil's advocate.
+Pull yourself together.
+Pull your weight.
+Put your best foot forward.
+Peace of mind.
+Rome wasn't built in a day.
+Rain on your parade.
+Read between the lines.
+Rings a bell.
+Silence is golden.
+Slow and steady wins the race.
+Spare the rod and spoil the child.
+Speak of the devil.
+Still waters run deep.
+Strike while the iron is hot.
+Sit on the fence.
+Skeletons in the closet.
+Spill the beans.
+Steal someone's thunder.
+Straight from the horse's mouth.
+The apple doesn't fall far from the tree.
+The ball is in your court.
+The best things in life are free.
+The customer is always right.
+The early bird catches the worm.
+The end justifies the means.
+The exception proves the rule.
+The grass is always greener on the other side.
+The pen is mightier than the sword.
+The pot calling the kettle black.
+The proof is in the pudding.
+The road to hell is paved with good intentions.
+The squeaky wheel gets the grease.
+The truth hurts.
+The whole nine yards.
+There's more than one way to skin a cat.
+There's no place like home.
+There's no smoke without fire.
+There's no such thing as a free lunch.
+Time flies when you're having fun.
+Time heals all wounds.
+Time is money.
+Time will tell.
+To each his own.
+Too many cooks spoil the broth.
+Two heads are better than one.
+Two wrongs don't make a right.
+Take it with a grain of salt.
+Take the bull by the horns.
+The whole kit and caboodle.
+Through thick and thin.
+Throw in the towel.
+Tie the knot.
+The tip of the iceberg.
+Turn a blind eye.
+Turn over a new leaf.
+Tongue in cheek.
+The last straw.
+United we stand, divided we fall.
+Under the weather.
+Up in the air.
+Variety is the spice of life.
+Walk a mile in someone's shoes.
+Waste not, want not.
+What goes around comes around.
+What doesn't kill you makes you stronger.
+When life gives you lemons, make lemonade.
+When one door closes, another opens.
+When the going gets tough, the tough get going.
+Where there's a will, there's a way.
+Where there's smoke, there's fire.
+Water under the bridge.
+Wear your heart on your sleeve.
+When pigs fly.
+Word of mouth.
+You can't have your cake and eat it too.
+You can't make an omelet without breaking eggs.
+You can't please everyone.
+You can't teach an old dog new tricks.
+You reap what you sow.
+You scratch my back, I'll scratch yours.
+You win some, you lose some.
+Add insult to injury.
+Don't kill the messenger.

phrases/opinions_work.txt

@@ -0,0 +1,278 @@
+I think so.
+I think you're right.
+I think we should go.
+I think it's a good idea.
+I think it's a great idea.
+I think that's a good idea.
+I don't think so.
+I don't think that's a good idea.
+I agree with you.
+I completely agree.
+I totally agree.
+I couldn't agree more.
+I disagree.
+I'm not sure.
+I'm not sure about that.
+I'm not so sure.
+I see what you mean.
+I see your point.
+I know what you mean.
+I know how you feel.
+I understand how you feel.
+I believe you.
+I believe in you.
+I trust you.
+I love you.
+I love you so much.
+I love you too.
+I love it.
+I like it.
+I really like it.
+I don't like it.
+I miss you.
+I miss you so much.
+I miss you too.
+I need you.
+I'm proud of you.
+I'm so proud of you.
+I'm happy for you.
+I'm so happy for you.
+I'm so happy.
+I'm happy to help.
+I'm glad to hear that.
+I'm glad you're here.
+I'm glad you liked it.
+I'm excited.
+I'm so excited.
+I'm worried about you.
+I'm here for you.
+I'm always here for you.
+I'm on your side.
+I'm sorry you feel that way.
+I feel the same way.
+I feel great.
+I feel sick.
+I can't believe it.
+I can't wait.
+I can't wait to see you.
+I can't do this anymore.
+I can do it.
+You can do it.
+You can do this.
+You've got this.
+You did a great job.
+You did it.
+You look great.
+You look beautiful.
+You look tired.
+You're right.
+You're so right.
+You're the best.
+You're amazing.
+You're so kind.
+You're very kind.
+You're welcome to join us.
+You deserve it.
+You should try it.
+You know what I mean?
+You never know.
+You're kidding.
+You're kidding me.
+Don't worry.
+Don't worry about it.
+Don't worry, be happy.
+Don't give up.
+Don't be afraid.
+Don't be sad.
+Don't be late.
+Don't be silly.
+Don't do that.
+Don't touch that.
+Don't tell anyone.
+Never give up.
+Keep up the good work.
+Keep going.
+Keep it up.
+Hang in there.
+Take your time.
+Take it easy.
+Calm down.
+Cheer up.
+It's okay.
+It's not your fault.
+It's not a big deal.
+It's going to be okay.
+It's going to be fine.
+Everything is going to be okay.
+Everything will be fine.
+It doesn't matter.
+It's up to you.
+It's my fault.
+It's a good idea.
+It's a deal.
+It's too late.
+It's time to go.
+It's time for bed.
+It's worth it.
+That's right.
+That's true.
+That's not true.
+That's a good idea.
+That's a great idea.
+That's a good question.
+That's a great question.
+That's fine.
+That's fine with me.
+That's okay.
+That's not fair.
+That's enough.
+That's it.
+That makes sense.
+That doesn't make sense.
+That's what I thought.
+That's why I love you.
+Me too.
+Me neither.
+So do I.
+Of course.
+Of course not.
+Absolutely.
+Definitely.
+Exactly.
+Maybe.
+Maybe later.
+Maybe next time.
+Probably.
+Sure.
+Sure, no problem.
+Sure thing.
+Okay.
+Okay, sounds good.
+Sounds good.
+Sounds good to me.
+Sounds like a plan.
+Good idea.
+Good point.
+Good question.
+Fair enough.
+Not really.
+Not at all.
+Not yet.
+Not now.
+I hope this email finds you well.
+I hope you are doing well.
+I hope you had a great weekend.
+I am writing to follow up on our conversation.
+I just wanted to follow up on my last email.
+Just a quick reminder about the meeting.
+Please find attached the report.
+Please find the attached file.
+Please see the attached document.
+Please let me know if you have any questions.
+Please let me know if you need anything else.
+Please let me know your availability.
+Please let me know what you think.
+Please let me know as soon as possible.
+Please feel free to contact me.
+Please feel free to reach out.
+Please don't hesitate to contact me.
+Please review the document.
+Please confirm your attendance.
+Let me know if you need anything.
+Let me know if you have any questions.
+Let me know what you think.
+Let me know if that works for you.
+Let me know when you're free.
+Let me get back to you on that.
+Feel free to reach out.
+Feel free to ask.
+Looking forward to hearing from you.
+Looking forward to seeing you.
+Looking forward to working with you.
+I look forward to hearing from you.
+I look forward to meeting you.
+I look forward to working with you.
+Thank you for your email.
+Thank you for your quick response.
+Thank you for reaching out.
+Thank you for the update.
+Thanks for the update.
+Thanks for getting back to me.
+Thanks for reaching out.
+Thanks in advance.
+Thanks for your hard work.
+Best regards.
+Kind regards.
+Warm regards.
+Sincerely.
+Have a great day ahead.
+As soon as possible.
+At your earliest convenience.
+For your information.
+Sorry for the inconvenience.
+Sorry for the confusion.
+Sorry for the delay.
+I will get back to you as soon as possible.
+I will send you the details.
+I will look into it.
+I will keep you posted.
+I'll keep you updated.
+I'll let you know.
+I'll send it over.
+I'll take care of it.
+I'm working on it.
+I'm in a meeting.
+I'm in a meeting right now.
+I'm out of the office.
+Can we schedule a meeting?
+Can we reschedule the meeting?
+Can we talk tomorrow?
+Can we move the meeting to tomorrow?
+Can you send me an update?
+Can you review this?
+Does that work for you?
+Does that make sense?
+Is that okay with you?
+Are you available tomorrow?
+Are you available for a quick call?
+Let's schedule a call.
+Let's touch base next week.
+Let's discuss this in the meeting.
+Let's circle back on this.
+Let's move forward.
+Let's get to work.
+The meeting is canceled.
+The deadline is tomorrow.
+We need to talk.
+We need to finish this today.
+We need more time.
+We can do it.
+We did it.
+We are happy to help.
+We apologize for the inconvenience.
+We appreciate your patience.
+We appreciate your business.
+We look forward to hearing from you.
+Your order has been shipped.
+Your call is important to us.
+How can I help you today?
+How may I help you?
+Is there anything else I can help you with?
+Thank you for contacting us.
+Thank you for your order.
+Thank you for shopping with us.
+Have a nice day, and thank you.
+Great work, everyone.
+Great job, team.
+Good work.
+Well said.
+Nice work.
+Nice job.
+I appreciate it.
+I really appreciate it.
+I really appreciate your help.
+I appreciate your help.
+I owe you one.
+I'm grateful for your help.
+It means a lot to me.
+It was a pleasure working with you.

phrases/social.txt

@@ -0,0 +1,266 @@
+Hello, how are you?
+Hello, how are you doing?
+Hi, how are you?
+Hi, how's it going?
+Hey, what's up?
+Hey, how have you been?
+How are you?
+How are you doing?
+How are you doing today?
+How are you feeling?
+How are you feeling today?
+How have you been?
+How's it going?
+How's your day going?
+How was your day?
+How was your weekend?
+How was your trip?
+How is your family?
+I'm fine, thank you.
+I'm fine, thanks. And you?
+I'm doing well, thank you.
+I'm doing well, thanks for asking.
+I'm good, thanks.
+I'm good, how about you?
+Not bad, how about you?
+Not too bad.
+Pretty good, thanks.
+Good morning.
+Good morning, everyone.
+Good morning, how are you?
+Good afternoon.
+Good evening.
+Good night.
+Good night, sleep well.
+Good night and sweet dreams.
+Sweet dreams.
+Sleep well.
+Sleep tight.
+Have a good night.
+Have a good day.
+Have a nice day.
+Have a great day.
+Have a wonderful day.
+Have a good weekend.
+Have a great weekend.
+Have a nice weekend.
+Have a good time.
+Have a great time.
+Have a safe trip.
+Have a safe flight.
+Have fun.
+Have a good one.
+Nice to meet you.
+Nice to meet you too.
+It's nice to meet you.
+It was nice to meet you.
+It was nice meeting you.
+It was nice talking to you.
+It was great to see you.
+It's good to see you.
+It's good to see you again.
+It's been a long time.
+Long time no see.
+Pleased to meet you.
+What is your name?
+What's your name?
+Where are you from?
+What do you do?
+What do you do for a living?
+Thank you.
+Thank you very much.
+Thank you so much.
+Thank you for your help.
+Thank you for your time.
+Thank you for everything.
+Thank you for coming.
+Thank you for listening.
+Thank you for your patience.
+Thank you for your understanding.
+Thank you for the gift.
+Thank you for the invitation.
+Thank you for letting me know.
+Thank you for asking.
+Thanks.
+Thanks a lot.
+Thanks so much.
+Thanks for your help.
+Thanks for everything.
+Thanks for coming.
+Thanks for letting me know.
+Thanks again.
+Thanks anyway.
+You're welcome.
+You are welcome.
+No problem.
+No worries.
+My pleasure.
+It was my pleasure.
+Don't mention it.
+Anytime.
+I'm sorry.
+I'm so sorry.
+I'm very sorry.
+I'm sorry for being late.
+I'm sorry to hear that.
+I'm sorry for your loss.
+I'm sorry, I didn't mean it.
+I apologize for the inconvenience.
+I apologize for the delay.
+Sorry about that.
+Sorry I'm late.
+Sorry to bother you.
+Sorry for the late reply.
+Excuse me.
+Excuse me, can you help me?
+Excuse me, where is the bathroom?
+Pardon me.
+Please.
+Yes, please.
+No, thank you.
+No, thanks.
+See you later.
+See you soon.
+See you tomorrow.
+See you next week.
+See you around.
+See you then.
+Talk to you later.
+Talk to you soon.
+Catch you later.
+Take care.
+Take care of yourself.
+Goodbye.
+Bye for now.
+Bye, see you later.
+Welcome.
+Welcome back.
+Welcome home.
+Welcome to the team.
+Come on in.
+Please come in.
+Please have a seat.
+Make yourself at home.
+Happy birthday.
+Happy birthday to you.
+Happy birthday, have a great day.
+Wishing you a happy birthday.
+Many happy returns.
+Happy new year.
+Happy holidays.
+Merry Christmas.
+Merry Christmas and a happy new year.
+Happy anniversary.
+Happy Thanksgiving.
+Happy Easter.
+Happy Mother's Day.
+Happy Father's Day.
+Happy Valentine's Day.
+Congratulations.
+Congratulations on your new job.
+Congratulations on your graduation.
+Congratulations on your wedding.
+Congratulations on the new baby.
+Congratulations, you deserve it.
+Well done.
+Good job.
+Great job.
+Good luck.
+Good luck with your exam.
+Good luck with everything.
+Best of luck.
+Best wishes.
+Get well soon.
+I hope you feel better soon.
+I hope you have a great day.
+I hope you're doing well.
+I hope everything is okay.
+I hope to see you soon.
+I hope so.
+Cheers.
+Bless you.
+God bless you.
+Same to you.
+You too.
+And you?
+What about you?
+How about you?
+What's new?
+What's going on?
+What are you doing?
+What are you up to?
+What are you doing this weekend?
+Not much, just relaxing.
+Nothing much.
+Are you okay?
+Are you sure?
+Are you ready?
+Are you coming?
+Are you busy?
+Are you free tonight?
+Do you want to hang out?
+Do you want to grab lunch?
+Do you want to come with me?
+Let's get together soon.
+Let's keep in touch.
+Let's grab a coffee sometime.
+Keep in touch.
+Say hi to your family for me.
+Give my love to your family.
+Tell them I said hello.
+I'll text you later.
+I'll call you later.
+I'll call you tomorrow.
+Call me when you get home.
+Text me when you get home.
+Let me know when you get home.
+Let me know when you're here.
+I'm here.
+I'm on my way.
+I'm almost there.
+I'll be there soon.
+I'll be right back.
+Be right back.
+I'm home.
+Just checking in.
+Just wanted to say hi.
+Miss you.
+Love you.
+Love you too.
+Lol, that's so funny.
+That's so funny.
+That's hilarious.
+Oh my god.
+Oh my gosh.
+No way.
+Are you serious?
+Really?
+Wow, that's amazing.
+That's awesome.
+That's great.
+That's great news.
+That's too bad.
+That's a shame.
+What a surprise.
+What a nice surprise.
+What a beautiful day.
+It's a beautiful day.
+It's so nice out today.
+Enjoy your meal.
+Enjoy your day.
+Enjoy your weekend.
+Enjoy your vacation.
+Enjoy the show.
+Bon appetit.
+Cheers to that.
+After you.
+Ladies and gentlemen.
+Can I ask you something?
+Can I help you?
+May I help you?
+May I come in?
+How can I help you?
+Is everything okay?
+Is this seat taken?
+Nice weather today, isn't it?
+It's cold today, isn't it?

requirements.txt

@@ -0,0 +1,4 @@
+torch
+transformers>=4.45
+tokenizers
+safetensors

test_model.py

@@ -0,0 +1,103 @@
+"""Load the saved files exactly as a Hugging Face user would and check them.
+
+Run `python build_weights.py` first.
+"""
+
+import json
+import random
+import shutil
+import subprocess
+import unittest
+from pathlib import Path
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+
+import build_weights
+
+MODEL_DIR = Path(__file__).parent
+
+# prompt -> greedy completion (new text only)
+CASES = {
+    "Once upon a": "time.",
+    "The quick brown": "fox jumps over the lazy dog.",
+    "Thank you for your": "help.",
+    "I hope this email": "finds you well.",
+    "Can I have the": "check, please?",
+    "Looking forward to": "hearing from you.",
+    "Actions speak": "louder than words.",
+    "Where is the": "bathroom?",
+    "Happy birthday": ".",
+    "I'm so proud": "of you.",
+}
+
+
+class TestModel(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.tok = AutoTokenizer.from_pretrained(MODEL_DIR)
+        cls.model = AutoModelForCausalLM.from_pretrained(MODEL_DIR).eval()
+        _, cls.vocab, cls.ngram, _, _, cls.info = build_weights.compile_model()
+
+    def complete(self, prompt: str) -> str:
+        ids = self.tok(prompt, return_tensors="pt")
+        out = self.model.generate(**ids, max_new_tokens=16)
+        return self.tok.decode(out[0, ids["input_ids"].shape[1] :], skip_special_tokens=True).strip()
+
+    def test_parameter_count(self):
+        n = sum(p.numel() for p in self.model.parameters())
+        self.assertEqual(n, self.info["params"])
+        self.assertLessEqual(n, 1_000_000_000)
+
+    def test_greedy_completions(self):
+        for prompt, expected in CASES.items():
+            with self.subTest(prompt=prompt):
+                self.assertEqual(self.complete(prompt), expected)
+
+    def test_matches_ngram_reference(self):
+        """The transformer's next-token distribution equals the compiled n-gram's."""
+        index = {p: i for i, p in enumerate(self.vocab)}
+        rng = random.Random(0)
+        phrases = build_weights.load_phrases()
+        cases = []
+        for toks in rng.sample(phrases, 200):
+            ids = [0] + [index[p] for p in toks]
+            cases.append(ids[: rng.randint(1, len(ids))])
+        for _ in range(50):  # unseen word salad, up to 80 tokens
+            cases.append([0] + [rng.randrange(2, len(self.vocab)) for _ in range(rng.randint(1, 80))])
+        with torch.no_grad():
+            for ids in cases:
+                got = self.model(torch.tensor([ids])).logits[0, -1].double().log_softmax(-1)
+                ref = self.ngram.reference_logits(ids).log_softmax(-1)
+                self.assertLess((got - ref).abs().max().item(), 5e-3)
+
+    def test_unknown_words_back_off(self):
+        # "zebra" is out of vocabulary; the model backs off to the shorter context.
+        self.assertEqual(self.complete("Zebra, thank you for your"), "help.")
+
+    def test_pipeline(self):
+        gen = pipeline("text-generation", model=str(MODEL_DIR))
+        self.assertEqual(gen("Once upon a")[0]["generated_text"], "Once upon a time.")
+
+    @unittest.skipUnless(shutil.which("bun"), "bun not installed")
+    def test_typescript_matches(self):
+        prompts = ["once upon a", "how are", "zebra", "i hope this email"]
+        out = subprocess.run(
+            ["bun", "autocomplete.ts", "--json", *prompts],
+            cwd=MODEL_DIR, capture_output=True, text=True, check=True,
+        )
+        results = json.loads(out.stdout)
+        with torch.no_grad():
+            for prompt, res in zip(prompts, results):
+                with self.subTest(prompt=prompt):
+                    ids = self.tok(prompt, return_tensors="pt")
+                    logp = self.model(**ids).logits[0, -1].log_softmax(-1)
+                    top = logp.topk(3)
+                    self.assertEqual([t["id"] for t in res["top"]], top.indices.tolist())
+                    for t, lp in zip(res["top"], top.values.tolist()):
+                        self.assertAlmostEqual(t["logprob"], lp, places=3)
+                    self.assertEqual(res["completion"].strip(), self.complete(prompt))
+
+
+if __name__ == "__main__":
+    unittest.main()

tokenizer.json

@@ -0,0 +1,1149 @@
+{
+  "version": "1.0",
+  "truncation": null,
+  "padding": null,
+  "added_tokens": [
+    {
+      "id": 0,
+      "content": "<|endoftext|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    {
+      "id": 1,
+      "content": "<unk>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    }
+  ],
+  "normalizer": {
+    "type": "Sequence",
+    "normalizers": [
+      {
+        "type": "NFKC"
+      },
+      {
+        "type": "Lowercase"
+      }
+    ]
+  },
+  "pre_tokenizer": {
+    "type": "ByteLevel",
+    "add_prefix_space": true,
+    "trim_offsets": true,
+    "use_regex": true
+  },
+  "post_processor": {
+    "type": "TemplateProcessing",
+    "single": [
+      {
+        "SpecialToken": {
+          "id": "<|endoftext|>",
+          "type_id": 0
+        }
+      },
+      {
+        "Sequence": {
+          "id": "A",
+          "type_id": 0
+        }
+      }
+    ],
+    "pair": [
+      {
+        "Sequence": {
+          "id": "A",
+          "type_id": 0
+        }
+      },
+      {
+        "Sequence": {
+          "id": "B",
+          "type_id": 1
+        }
+      }
+    ],
+    "special_tokens": {
+      "<|endoftext|>": {
+        "id": "<|endoftext|>",
+        "ids": [
+          0
+        ],
+        "tokens": [
+          "<|endoftext|>"
+        ]
+      }
+    }
+  },
+  "decoder": {
+    "type": "ByteLevel",
+    "add_prefix_space": true,
+    "trim_offsets": true,
+    "use_regex": true
+  },
+  "model": {
+    "type": "WordLevel",
+    "vocab": {
+      "<|endoftext|>": 0,
+      "<unk>": 1,
+      ".": 2,
+      "Ġyou": 3,
+      "Ġthe": 4,
+      "Ġi": 5,
+      "?": 6,
+      "Ġa": 7,
+      "Ġto": 8,
+      "'s": 9,
+      "Ġit": 10,
+      ",": 11,
+      "Ġis": 12,
+      "Ġyour": 13,
+      "Ġfor": 14,
+      "Ġcan": 15,
+      "Ġme": 16,
+      "'t": 17,
+      "'m": 18,
+      "Ġthat": 19,
+      "Ġplease": 20,
+      "Ġas": 21,
+      "Ġdo": 22,
+      "Ġwhat": 23,
+      "Ġhave": 24,
+      "Ġin": 25,
+      "Ġof": 26,
+      "Ġgood": 27,
+      "Ġhow": 28,
+      "Ġlet": 29,
+      "Ġon": 30,
+      "Ġare": 31,
+      "Ġdon": 32,
+      "Ġtime": 33,
+      "Ġknow": 34,
+      "Ġthank": 35,
+      "Ġhelp": 36,
+      "'ll": 37,
+      "Ġday": 38,
+      "Ġlike": 39,
+      "Ġsee": 40,
+      "Ġand": 41,
+      "Ġget": 42,
+      "Ġgreat": 43,
+      "Ġhappy": 44,
+      "Ġneed": 45,
+      "Ġnot": 46,
+      "Ġthere": 47,
+      "Ġbe": 48,
+      "Ġso": 49,
+      "Ġwith": 50,
+      "Ġgo": 51,
+      "Ġno": 52,
+      "Ġthanks": 53,
+      "Ġwe": 54,
+      "Ġwhere": 55,
+      "Ġback": 56,
+      "Ġgoing": 57,
+      "Ġout": 58,
+      "Ġcall": 59,
+      "Ġmy": 60,
+      "Ġthis": 61,
+      "Ġup": 62,
+      "Ġwhen": 63,
+      "'re": 64,
+      "Ġsorry": 65,
+      "Ġan": 66,
+      "Ġmeeting": 67,
+      "Ġright": 68,
+      "Ġwell": 69,
+      "Ġcome": 70,
+      "Ġhere": 71,
+      "Ġnice": 72,
+      "Ġthink": 73,
+      "Ġtoday": 74,
+      "Ġall": 75,
+      "Ġat": 76,
+      "Ġmake": 77,
+      "Ġone": 78,
+      "Ġtoo": 79,
+      "Ġwould": 80,
+      "Ġabout": 81,
+      "Ġfeel": 82,
+      "Ġhome": 83,
+      "Ġkeep": 84,
+      "Ġlate": 85,
+      "Ġtake": 86,
+      "Ġmuch": 87,
+      "Ġthan": 88,
+      "Ġwork": 89,
+      "Ġbest": 90,
+      "Ġhope": 91,
+      "Ġlater": 92,
+      "Ġlook": 93,
+      "Ġlove": 94,
+      "Ġokay": 95,
+      "Ġsoon": 96,
+      "Ġwas": 97,
+      "Ġdoing": 98,
+      "Ġforward": 99,
+      "Ġidea": 100,
+      "Ġjust": 101,
+      "Ġmeet": 102,
+      "Ġnever": 103,
+      "Ġover": 104,
+      "Ġtomorrow": 105,
+      "Ġturn": 106,
+      "Ġwill": 107,
+      "Ġdid": 108,
+      "Ġdoes": 109,
+      "Ġfree": 110,
+      "Ġif": 111,
+      "Ġoff": 112,
+      "Ġtwo": 113,
+      "Ġwant": 114,
+      "Ġwater": 115,
+      "Ġway": 116,
+      "Ġbeen": 117,
+      "Ġcoffee": 118,
+      "Ġeverything": 119,
+      "Ġfrom": 120,
+      "Ġgive": 121,
+      "Ġjob": 122,
+      "Ġnew": 123,
+      "Ġnow": 124,
+      "Ġsure": 125,
+      "Ġtalk": 126,
+      "Ġweekend": 127,
+      "Ġwelcome": 128,
+      "Ġappreciate": 129,
+      "Ġbefore": 130,
+      "Ġbetter": 131,
+      "Ġbite": 132,
+      "Ġclose": 133,
+      "Ġcongratulations": 134,
+      "Ġcould": 135,
+      "Ġeat": 136,
+      "Ġfine": 137,
+      "Ġlong": 138,
+      "Ġlooking": 139,
+      "Ġmore": 140,
+      "Ġonce": 141,
+      "Ġrain": 142,
+      "Ġreally": 143,
+      "Ġsome": 144,
+      "Ġsounds": 145,
+      "Ġwait": 146,
+      "Ġagree": 147,
+      "Ġaround": 148,
+      "Ġbathroom": 149,
+      "Ġbreak": 150,
+      "Ġby": 151,
+      "Ġcheck": 152,
+      "Ġcoming": 153,
+      "Ġdoesn": 154,
+      "Ġdog": 155,
+      "Ġdoor": 156,
+      "Ġenjoy": 157,
+      "Ġeye": 158,
+      "Ġfire": 159,
+      "Ġhas": 160,
+      "Ġmakes": 161,
+      "Ġmean": 162,
+      "Ġmiss": 163,
+      "Ġput": 164,
+      "Ġquestion": 165,
+      "Ġsay": 166,
+      "Ġsend": 167,
+      "Ġstore": 168,
+      "Ġtell": 169,
+      "Ġus": 170,
+      "Ġany": 171,
+      "Ġanything": 172,
+      "Ġball": 173,
+      "Ġbed": 174,
+      "Ġbirthday": 175,
+      "Ġcold": 176,
+      "Ġcut": 177,
+      "Ġdown": 178,
+      "Ġeasy": 179,
+      "Ġevery": 180,
+      "Ġfall": 181,
+      "Ġfind": 182,
+      "Ġhi": 183,
+      "Ġits": 184,
+      "Ġkeys": 185,
+      "Ġlife": 186,
+      "Ġlight": 187,
+      "Ġlive": 188,
+      "Ġluck": 189,
+      "Ġman": 190,
+      "Ġmany": 191,
+      "Ġmay": 192,
+      "Ġmind": 193,
+      "Ġmoment": 194,
+      "Ġmoney": 195,
+      "Ġnext": 196,
+      "Ġnight": 197,
+      "Ġold": 198,
+      "Ġorder": 199,
+      "Ġphone": 200,
+      "Ġquick": 201,
+      "Ġsame": 202,
+      "Ġshould": 203,
+      "Ġsleep": 204,
+      "Ġspeak": 205,
+      "Ġtouch": 206,
+      "Ġvery": 207,
+      "Ġweather": 208,
+      "Ġworking": 209,
+      "Ġworth": 210,
+      "'d": 211,
+      "Ġagain": 212,
+      "Ġalways": 213,
+      "Ġanother": 214,
+      "Ġapologize": 215,
+      "Ġapple": 216,
+      "Ġask": 217,
+      "Ġattached": 218,
+      "Ġbad": 219,
+      "Ġbeautiful": 220,
+      "Ġbelieve": 221,
+      "Ġblind": 222,
+      "Ġburn": 223,
+      "Ġbusy": 224,
+      "Ġbut": 225,
+      "Ġcare": 226,
+      "Ġcat": 227,
+      "Ġcourse": 228,
+      "Ġcup": 229,
+      "Ġdevil": 230,
+      "Ġdinner": 231,
+      "Ġdoctor": 232,
+      "Ġemail": 233,
+      "Ġend": 234,
+      "Ġends": 235,
+      "Ġeveryone": 236,
+      "Ġexcuse": 237,
+      "Ġfair": 238,
+      "Ġfamily": 239,
+      "Ġfar": 240,
+      "Ġfeeling": 241,
+      "Ġfollow": 242,
+      "Ġforget": 243,
+      "Ġglad": 244,
+      "Ġglass": 245,
+      "Ġgold": 246,
+      "Ġhand": 247,
+      "Ġhard": 248,
+      "Ġhead": 249,
+      "Ġhear": 250,
+      "Ġhearing": 251,
+      "Ġheart": 252,
+      "Ġhello": 253,
+      "Ġhis": 254,
+      "Ġhit": 255,
+      "Ġhold": 256,
+      "Ġhorse": 257,
+      "Ġinconvenience": 258,
+      "Ġkill": 259,
+      "Ġkind": 260,
+      "Ġlost": 261,
+      "Ġmaybe": 262,
+      "Ġmile": 263,
+      "Ġminute": 264,
+      "Ġmorning": 265,
+      "Ġmouth": 266,
+      "Ġnews": 267,
+      "Ġnothing": 268,
+      "Ġopen": 269,
+      "Ġoutside": 270,
+      "Ġpatience": 271,
+      "Ġpay": 272,
+      "Ġpenny": 273,
+      "Ġpleasure": 274,
+      "Ġpossible": 275,
+      "Ġquestions": 276,
+      "Ġregards": 277,
+      "Ġrome": 278,
+      "Ġsafe": 279,
+      "Ġsaid": 280,
+      "Ġsense": 281,
+      "Ġshame": 282,
+      "Ġside": 283,
+      "Ġsomething": 284,
+      "Ġstation": 285,
+      "Ġtable": 286,
+      "Ġthings": 287,
+      "Ġtired": 288,
+      "Ġtogether": 289,
+      "Ġtonight": 290,
+      "Ġtrain": 291,
+      "Ġtwice": 292,
+      "Ġunderstand": 293,
+      "Ġupdate": 294,
+      "Ġwho": 295,
+      "Ġwhy": 296,
+      "Ġwithout": 297,
+      "Ġworry": 298,
+      "Ġwrong": 299,
+      "Ġyet": 300,
+      "Ġyourself": 301,
+      "!": 302,
+      "Ġahead": 303,
+      "Ġairport": 304,
+      "Ġamazing": 305,
+      "Ġasking": 306,
+      "Ġavailable": 307,
+      "Ġbark": 308,
+      "Ġbetween": 309,
+      "Ġbill": 310,
+      "Ġbird": 311,
+      "Ġbirds": 312,
+      "Ġbless": 313,
+      "Ġblue": 314,
+      "Ġboat": 315,
+      "Ġbook": 316,
+      "Ġboth": 317,
+      "Ġbridge": 318,
+      "Ġbucket": 319,
+      "Ġbush": 320,
+      "Ġbye": 321,
+      "Ġbygones": 322,
+      "Ġcake": 323,
+      "Ġcalling": 324,
+      "Ġcalm": 325,
+      "Ġcanceled": 326,
+      "Ġcats": 327,
+      "Ġcaught": 328,
+      "Ġchange": 329,
+      "Ġchase": 330,
+      "Ġcheers": 331,
+      "Ġchip": 332,
+      "Ġchristmas": 333,
+      "Ġcomes": 334,
+      "Ġcontact": 335,
+      "Ġcorner": 336,
+      "Ġcost": 337,
+      "Ġcry": 338,
+      "Ġdeal": 339,
+      "Ġdelay": 340,
+      "Ġdelicious": 341,
+      "Ġdeserve": 342,
+      "Ġdetails": 343,
+      "Ġdidn": 344,
+      "Ġdocument": 345,
+      "Ġdogs": 346,
+      "Ġdone": 347,
+      "Ġdreams": 348,
+      "Ġeggs": 349,
+      "Ġelse": 350,
+      "Ġenglish": 351,
+      "Ġenough": 352,
+      "Ġexcited": 353,
+      "Ġface": 354,
+      "Ġfault": 355,
+      "Ġfeather": 356,
+      "Ġfile": 357,
+      "Ġfirst": 358,
+      "Ġfly": 359,
+      "Ġfool": 360,
+      "Ġfox": 361,
+      "Ġfriend": 362,
+      "Ġfun": 363,
+      "Ġfunny": 364,
+      "Ġgets": 365,
+      "Ġgift": 366,
+      "Ġgod": 367,
+      "Ġgoes": 368,
+      "Ġgot": 369,
+      "Ġgrab": 370,
+      "Ġgrain": 371,
+      "Ġgrow": 372,
+      "Ġhang": 373,
+      "Ġhay": 374,
+      "Ġhey": 375,
+      "Ġhospital": 376,
+      "Ġhot": 377,
+      "Ġice": 378,
+      "Ġinto": 379,
+      "Ġisn": 380,
+      "Ġjoin": 381,
+      "Ġjump": 382,
+      "Ġkidding": 383,
+      "Ġlast": 384,
+      "Ġlearn": 385,
+      "Ġleft": 386,
+      "Ġleg": 387,
+      "Ġletting": 388,
+      "Ġlights": 389,
+      "Ġlot": 390,
+      "Ġlunch": 391,
+      "Ġmeans": 392,
+      "Ġmedicine": 393,
+      "Ġmerry": 394,
+      "Ġmonkey": 395,
+      "Ġmoon": 396,
+      "Ġmother": 397,
+      "Ġmove": 398,
+      "Ġmovie": 399,
+      "Ġmusic": 400,
+      "Ġname": 401,
+      "Ġnear": 402,
+      "Ġnine": 403,
+      "Ġoh": 404,
+      "Ġowe": 405,
+      "Ġown": 406,
+      "Ġpass": 407,
+      "Ġpen": 408,
+      "Ġpick": 409,
+      "Ġpie": 410,
+      "Ġplace": 411,
+      "Ġplay": 412,
+      "Ġpoint": 413,
+      "Ġpot": 414,
+      "Ġproblem": 415,
+      "Ġproud": 416,
+      "Ġpull": 417,
+      "Ġquiet": 418,
+      "Ġraining": 419,
+      "Ġreach": 420,
+      "Ġreaching": 421,
+      "Ġred": 422,
+      "Ġreservation": 423,
+      "Ġreview": 424,
+      "Ġrock": 425,
+      "Ġrolling": 426,
+      "Ġrule": 427,
+      "Ġsalt": 428,
+      "Ġschedule": 429,
+      "Ġscratch": 430,
+      "Ġseat": 431,
+      "Ġshort": 432,
+      "Ġshoulder": 433,
+      "Ġsight": 434,
+      "Ġsit": 435,
+      "Ġskin": 436,
+      "Ġsmoke": 437,
+      "Ġsomeone": 438,
+      "Ġspade": 439,
+      "Ġspoil": 440,
+      "Ġstone": 441,
+      "Ġstraight": 442,
+      "Ġsurprise": 443,
+      "Ġsweet": 444,
+      "Ġtakes": 445,
+      "Ġteam": 446,
+      "Ġtext": 447,
+      "Ġthey": 448,
+      "Ġthin": 449,
+      "Ġthing": 450,
+      "Ġthought": 451,
+      "Ġtough": 452,
+      "Ġtree": 453,
+      "Ġtrip": 454,
+      "Ġtrue": 455,
+      "Ġtry": 456,
+      "Ġunder": 457,
+      "Ġuse": 458,
+      "Ġwanted": 459,
+      "Ġwaste": 460,
+      "Ġwatch": 461,
+      "Ġwear": 462,
+      "Ġweek": 463,
+      "Ġwhile": 464,
+      "Ġwhole": 465,
+      "Ġwords": 466,
+      "Ġworks": 467,
+      "Ġworld": 468,
+      "Ġyear": 469,
+      "'ve": 470,
+      "-": 471,
+      "handed": 472,
+      "Ġabsence": 473,
+      "Ġabsolutely": 474,
+      "Ġaccept": 475,
+      "Ġactions": 476,
+      "Ġadd": 477,
+      "Ġadvance": 478,
+      "Ġadvocate": 479,
+      "Ġafraid": 480,
+      "Ġafter": 481,
+      "Ġafternoon": 482,
+      "Ġagainst": 483,
+      "Ġain": 484,
+      "Ġair": 485,
+      "Ġalike": 486,
+      "Ġalmost": 487,
+      "Ġam": 488,
+      "Ġambulance": 489,
+      "Ġamerican": 490,
+      "Ġanniversary": 491,
+      "Ġanymore": 492,
+      "Ġanyone": 493,
+      "Ġanytime": 494,
+      "Ġanyway": 495,
+      "Ġappetit": 496,
+      "Ġappointment": 497,
+      "Ġarm": 498,
+      "Ġattendance": 499,
+      "Ġavailability": 500,
+      "Ġaway": 501,
+      "Ġawesome": 502,
+      "Ġbaby": 503,
+      "Ġbackwards": 504,
+      "Ġbag": 505,
+      "Ġbandwagon": 506,
+      "Ġbank": 507,
+      "Ġbarking": 508,
+      "Ġbase": 509,
+      "Ġbasket": 510,
+      "Ġbat": 511,
+      "Ġbeans": 512,
+      "Ġbeat": 513,
+      "Ġbeaten": 514,
+      "Ġbeauty": 515,
+      "Ġbeaver": 516,
+      "Ġbee": 517,
+      "Ġbeggars": 518,
+      "Ġbegins": 519,
+      "Ġbeholder": 520,
+      "Ġbeing": 521,
+      "Ġbell": 522,
+      "Ġbend": 523,
+      "Ġbenefit": 524,
+      "Ġbeyond": 525,
+      "Ġbig": 526,
+      "Ġbitten": 527,
+      "Ġblack": 528,
+      "Ġblessing": 529,
+      "Ġbliss": 530,
+      "Ġblock": 531,
+      "Ġblood": 532,
+      "Ġblow": 533,
+      "Ġboard": 534,
+      "Ġboils": 535,
+      "Ġbold": 536,
+      "Ġbon": 537,
+      "Ġborrow": 538,
+      "Ġbother": 539,
+      "Ġbreakfast": 540,
+      "Ġbreaking": 541,
+      "Ġbreeds": 542,
+      "Ġbridges": 543,
+      "Ġbroke": 544,
+      "Ġbroth": 545,
+      "Ġbrown": 546,
+      "Ġbuck": 547,
+      "Ġbuilt": 548,
+      "Ġbull": 549,
+      "Ġbullet": 550,
+      "Ġbury": 551,
+      "Ġbus": 552,
+      "Ġbusiness": 553,
+      "Ġbutton": 554,
+      "Ġbuy": 555,
+      "Ġcaboodle": 556,
+      "Ġcandle": 557,
+      "Ġcard": 558,
+      "Ġcards": 559,
+      "Ġcareful": 560,
+      "Ġcart": 561,
+      "Ġcash": 562,
+      "Ġcatch": 563,
+      "Ġcatches": 564,
+      "Ġcause": 565,
+      "Ġcharity": 566,
+      "Ġchecking": 567,
+      "Ġcheek": 568,
+      "Ġcheer": 569,
+      "Ġchew": 570,
+      "Ġchicken": 571,
+      "Ġchickens": 572,
+      "Ġchild": 573,
+      "Ġchin": 574,
+      "Ġchips": 575,
+      "Ġchoosers": 576,
+      "Ġcigar": 577,
+      "Ġcircle": 578,
+      "Ġclam": 579,
+      "Ġclean": 580,
+      "Ġcleanliness": 581,
+      "Ġclear": 582,
+      "Ġclosed": 583,
+      "Ġcloser": 584,
+      "Ġcloses": 585,
+      "Ġcloset": 586,
+      "Ġclosing": 587,
+      "Ġcloud": 588,
+      "Ġclouds": 589,
+      "Ġcompany": 590,
+      "Ġcompletely": 591,
+      "Ġconfirm": 592,
+      "Ġconfusion": 593,
+      "Ġcontacting": 594,
+      "Ġcontempt": 595,
+      "Ġconvenience": 596,
+      "Ġconversation": 597,
+      "Ġcooks": 598,
+      "Ġcool": 599,
+      "Ġcorners": 600,
+      "Ġcouldn": 601,
+      "Ġcount": 602,
+      "Ġcounts": 603,
+      "Ġcourt": 604,
+      "Ġcover": 605,
+      "Ġcredit": 606,
+      "Ġcross": 607,
+      "Ġcrossed": 608,
+      "Ġcucumber": 609,
+      "Ġcure": 610,
+      "Ġcuriosity": 611,
+      "Ġcustomer": 612,
+      "Ġcute": 613,
+      "Ġdark": 614,
+      "Ġdate": 615,
+      "Ġdead": 616,
+      "Ġdeadline": 617,
+      "Ġdeep": 618,
+      "Ġdefinitely": 619,
+      "Ġdeserves": 620,
+      "Ġdiamond": 621,
+      "Ġdime": 622,
+      "Ġdisagree": 623,
+      "Ġdiscuss": 624,
+      "Ġdisguise": 625,
+      "Ġdivided": 626,
+      "Ġdoornail": 627,
+      "Ġdoubt": 628,
+      "Ġdozen": 629,
+      "Ġdraw": 630,
+      "Ġdrawing": 631,
+      "Ġdrink": 632,
+      "Ġdrive": 633,
+      "Ġdrop": 634,
+      "Ġdumps": 635,
+      "Ġdust": 636,
+      "Ġeach": 637,
+      "Ġeager": 638,
+      "Ġear": 639,
+      "Ġearliest": 640,
+      "Ġearly": 641,
+      "Ġearned": 642,
+      "Ġeasier": 643,
+      "Ġeaster": 644,
+      "Ġeaten": 645,
+      "Ġelephant": 646,
+      "Ġenemies": 647,
+      "Ġeven": 648,
+      "Ġevening": 649,
+      "Ġevil": 650,
+      "Ġexactly": 651,
+      "Ġexam": 652,
+      "Ġexception": 653,
+      "Ġexit": 654,
+      "Ġexpensive": 655,
+      "Ġextra": 656,
+      "Ġeyes": 657,
+      "Ġfamiliarity": 658,
+      "Ġfather": 659,
+      "Ġfavor": 660,
+      "Ġfavors": 661,
+      "Ġfeeds": 662,
+      "Ġfence": 663,
+      "Ġfiddle": 664,
+      "Ġfight": 665,
+      "Ġfinds": 666,
+      "Ġfingers": 667,
+      "Ġfinish": 668,
+      "Ġfish": 669,
+      "Ġfit": 670,
+      "Ġfits": 671,
+      "Ġfive": 672,
+      "Ġfix": 673,
+      "Ġflies": 674,
+      "Ġflight": 675,
+      "Ġflock": 676,
+      "Ġflow": 677,
+      "Ġfonder": 678,
+      "Ġfood": 679,
+      "Ġfoot": 680,
+      "Ġforgot": 681,
+      "Ġfortune": 682,
+      "Ġfriends": 683,
+      "Ġfrying": 684,
+      "Ġgain": 685,
+      "Ġgained": 686,
+      "Ġgathers": 687,
+      "Ġgentlemen": 688,
+      "Ġgetting": 689,
+      "Ġghost": 690,
+      "Ġgives": 691,
+      "Ġglitters": 692,
+      "Ġgodliness": 693,
+      "Ġgolden": 694,
+      "Ġgoodbye": 695,
+      "Ġgoose": 696,
+      "Ġgosh": 697,
+      "Ġgraduation": 698,
+      "Ġgrasping": 699,
+      "Ġgrass": 700,
+      "Ġgrateful": 701,
+      "Ġgrease": 702,
+      "Ġgreener": 703,
+      "Ġgun": 704,
+      "Ġgym": 705,
+      "Ġhad": 706,
+      "Ġhands": 707,
+      "Ġhappened": 708,
+      "Ġhappiness": 709,
+      "Ġhaste": 710,
+      "Ġhatch": 711,
+      "Ġhatchet": 712,
+      "Ġhatter": 713,
+      "Ġhaving": 714,
+      "Ġhaystack": 715,
+      "Ġhe": 716,
+      "Ġheadache": 717,
+      "Ġheads": 718,
+      "Ġheals": 719,
+      "Ġhealth": 720,
+      "Ġheat": 721,
+      "Ġheels": 722,
+      "Ġhell": 723,
+      "Ġhelping": 724,
+      "Ġherding": 725,
+      "Ġherring": 726,
+      "Ġhesitate": 727,
+      "Ġhilarious": 728,
+      "Ġhills": 729,
+      "Ġhim": 730,
+      "Ġhimself": 731,
+      "Ġhistory": 732,
+      "Ġholidays": 733,
+      "Ġhonesty": 734,
+      "Ġhook": 735,
+      "Ġhorns": 736,
+      "Ġhorses": 737,
+      "Ġhungry": 738,
+      "Ġhurry": 739,
+      "Ġhurts": 740,
+      "Ġiceberg": 741,
+      "Ġignorance": 742,
+      "Ġimportant": 743,
+      "Ġinch": 744,
+      "Ġincluded": 745,
+      "Ġindeed": 746,
+      "Ġinformation": 747,
+      "Ġinjury": 748,
+      "Ġinsult": 749,
+      "Ġintentions": 750,
+      "Ġinvention": 751,
+      "Ġinvitation": 752,
+      "Ġiron": 753,
+      "Ġisland": 754,
+      "Ġitself": 755,
+      "Ġjack": 756,
+      "Ġjudge": 757,
+      "Ġjumps": 758,
+      "Ġjustifies": 759,
+      "Ġkeeps": 760,
+      "Ġkettle": 761,
+      "Ġkick": 762,
+      "Ġkilled": 763,
+      "Ġkit": 764,
+      "Ġknocks": 765,
+      "Ġknot": 766,
+      "Ġknowledge": 767,
+      "Ġladies": 768,
+      "Ġlaughter": 769,
+      "Ġlazy": 770,
+      "Ġlead": 771,
+      "Ġleaf": 772,
+      "Ġleap": 773,
+      "Ġleave": 774,
+      "Ġleaving": 775,
+      "Ġlemonade": 776,
+      "Ġlemons": 777,
+      "Ġleopard": 778,
+      "Ġlie": 779,
+      "Ġliked": 780,
+      "Ġline": 781,
+      "Ġlines": 782,
+      "Ġlining": 783,
+      "Ġlistening": 784,
+      "Ġliving": 785,
+      "Ġlock": 786,
+      "Ġlol": 787,
+      "Ġlooks": 788,
+      "Ġlose": 789,
+      "Ġloss": 790,
+      "Ġlosses": 791,
+      "Ġlouder": 792,
+      "Ġloves": 793,
+      "Ġmad": 794,
+      "Ġmadness": 795,
+      "Ġmatter": 796,
+      "Ġmeal": 797,
+      "Ġmeasure": 798,
+      "Ġmention": 799,
+      "Ġmenu": 800,
+      "Ġmessage": 801,
+      "Ġmessenger": 802,
+      "Ġmethod": 803,
+      "Ġmidnight": 804,
+      "Ġmightier": 805,
+      "Ġmilk": 806,
+      "Ġminds": 807,
+      "Ġminutes": 808,
+      "Ġmisery": 809,
+      "Ġmolehill": 810,
+      "Ġmoss": 811,
+      "Ġmountain": 812,
+      "Ġmouse": 813,
+      "Ġmud": 814,
+      "Ġmule": 815,
+      "Ġmust": 816,
+      "Ġnail": 817,
+      "Ġnearest": 818,
+      "Ġnecessity": 819,
+      "Ġneedle": 820,
+      "Ġneither": 821,
+      "Ġnick": 822,
+      "Ġnoon": 823,
+      "Ġnose": 824,
+      "Ġnutshell": 825,
+      "Ġoffice": 826,
+      "Ġoil": 827,
+      "Ġomelet": 828,
+      "Ġopens": 829,
+      "Ġopportunity": 830,
+      "Ġor": 831,
+      "Ġother": 832,
+      "Ġounce": 833,
+      "Ġour": 834,
+      "Ġox": 835,
+      "Ġpage": 836,
+      "Ġpain": 837,
+      "Ġpale": 838,
+      "Ġpan": 839,
+      "Ġpar": 840,
+      "Ġparade": 841,
+      "Ġpardon": 842,
+      "Ġpassword": 843,
+      "Ġpath": 844,
+      "Ġpaved": 845,
+      "Ġpeace": 846,
+      "Ġpeople": 847,
+      "Ġperfect": 848,
+      "Ġpharmacy": 849,
+      "Ġpicture": 850,
+      "Ġpiece": 851,
+      "Ġpigs": 852,
+      "Ġpill": 853,
+      "Ġpizza": 854,
+      "Ġplain": 855,
+      "Ġplan": 856,
+      "Ġpleased": 857,
+      "Ġpolicy": 858,
+      "Ġposted": 859,
+      "Ġpound": 860,
+      "Ġpours": 861,
+      "Ġpower": 862,
+      "Ġpractice": 863,
+      "Ġprepare": 864,
+      "Ġpresent": 865,
+      "Ġpretty": 866,
+      "Ġprevention": 867,
+      "Ġpride": 868,
+      "Ġprobably": 869,
+      "Ġproof": 870,
+      "Ġproves": 871,
+      "Ġpudding": 872,
+      "Ġrace": 873,
+      "Ġrains": 874,
+      "Ġread": 875,
+      "Ġready": 876,
+      "Ġreap": 877,
+      "Ġreceive": 878,
+      "Ġrecommend": 879,
+      "Ġrelaxing": 880,
+      "Ġreminder": 881,
+      "Ġrepeat": 882,
+      "Ġrepeats": 883,
+      "Ġreply": 884,
+      "Ġreport": 885,
+      "Ġreschedule": 886,
+      "Ġresponse": 887,
+      "Ġrest": 888,
+      "Ġrestroom": 889,
+      "Ġreturns": 890,
+      "Ġride": 891,
+      "Ġrings": 892,
+      "Ġroad": 893,
+      "Ġroads": 894,
+      "Ġrod": 895,
+      "Ġromans": 896,
+      "Ġroom": 897,
+      "Ġroot": 898,
+      "Ġropes": 899,
+      "Ġrose": 900,
+      "Ġrough": 901,
+      "Ġrun": 902,
+      "Ġrunning": 903,
+      "Ġsack": 904,
+      "Ġsad": 905,
+      "Ġsafely": 906,
+      "Ġsaved": 907,
+      "Ġsaves": 908,
+      "Ġsaying": 909,
+      "Ġsecond": 910,
+      "Ġseeing": 911,
+      "Ġseen": 912,
+      "Ġserious": 913,
+      "Ġserved": 914,
+      "Ġshine": 915,
+      "Ġshines": 916,
+      "Ġshipped": 917,
+      "Ġshoe": 918,
+      "Ġshoes": 919,
+      "Ġshop": 920,
+      "Ġshopping": 921,
+      "Ġshot": 922,
+      "Ġshow": 923,
+      "Ġshy": 924,
+      "Ġsick": 925,
+      "Ġsilence": 926,
+      "Ġsilly": 927,
+      "Ġsilver": 928,
+      "Ġsincerely": 929,
+      "Ġskeletons": 930,
+      "Ġslate": 931,
+      "Ġsleeping": 932,
+      "Ġsleeve": 933,
+      "Ġslow": 934,
+      "Ġslowly": 935,
+      "Ġsly": 936,
+      "Ġsmall": 937,
+      "Ġsnowing": 938,
+      "Ġsometime": 939,
+      "Ġsore": 940,
+      "Ġsow": 941,
+      "Ġspare": 942,
+      "Ġspell": 943,
+      "Ġspice": 944,
+      "Ġspill": 945,
+      "Ġspilled": 946,
+      "Ġspots": 947,
+      "Ġsquare": 948,
+      "Ġsqueaky": 949,
+      "Ġstand": 950,
+      "Ġstart": 951,
+      "Ġstarted": 952,
+      "Ġsteady": 953,
+      "Ġsteal": 954,
+      "Ġsteam": 955,
+      "Ġstill": 956,
+      "Ġstitch": 957,
+      "Ġstop": 958,
+      "Ġstorm": 959,
+      "Ġstory": 960,
+      "Ġstraw": 961,
+      "Ġstraws": 962,
+      "Ġstrike": 963,
+      "Ġstrong": 964,
+      "Ġstronger": 965,
+      "Ġstubborn": 966,
+      "Ġsuch": 967,
+      "Ġsun": 968,
+      "Ġswallow": 969,
+      "Ġsword": 970,
+      "Ġtaken": 971,
+      "Ġtalking": 972,
+      "Ġtango": 973,
+      "Ġtaste": 974,
+      "Ġtea": 975,
+      "Ġteach": 976,
+      "Ġteeth": 977,
+      "Ġthanksgiving": 978,
+      "Ġthem": 979,
+      "Ġthen": 980,
+      "Ġthick": 981,
+      "Ġthicker": 982,
+      "Ġthirsty": 983,
+      "Ġthorn": 984,
+      "Ġthose": 985,
+      "Ġthoughts": 986,
+      "Ġthousand": 987,
+      "Ġthrough": 988,
+      "Ġthrow": 989,
+      "Ġthumb": 990,
+      "Ġthumbs": 991,
+      "Ġthunder": 992,
+      "Ġtie": 993,
+      "Ġtight": 994,
+      "Ġtip": 995,
+      "Ġtongue": 996,
+      "Ġtotally": 997,
+      "Ġtowel": 998,
+      "Ġtrades": 999,
+      "Ġtrash": 1000,
+      "Ġtreasure": 1001,
+      "Ġtrees": 1002,
+      "Ġtricks": 1003,
+      "Ġtrust": 1004,
+      "Ġtruth": 1005,
+      "Ġtunnel": 1006,
+      "Ġumbrella": 1007,
+      "Ġunderstanding": 1008,
+      "Ġunited": 1009,
+      "Ġuntil": 1010,
+      "Ġupdated": 1011,
+      "Ġupon": 1012,
+      "Ġvacation": 1013,
+      "Ġvalentine": 1014,
+      "Ġvariety": 1015,
+      "Ġventured": 1016,
+      "Ġvirtue": 1017,
+      "Ġwalk": 1018,
+      "Ġwall": 1019,
+      "Ġwar": 1020,
+      "Ġwarm": 1021,
+      "Ġwasn": 1022,
+      "Ġwatched": 1023,
+      "Ġwaters": 1024,
+      "Ġwealth": 1025,
+      "Ġwedding": 1026,
+      "Ġweight": 1027,
+      "Ġwheel": 1028,
+      "Ġwhite": 1029,
+      "Ġwicked": 1030,
+      "Ġwild": 1031,
+      "Ġwin": 1032,
+      "Ġwindow": 1033,
+      "Ġwins": 1034,
+      "Ġwishes": 1035,
+      "Ġwishing": 1036,
+      "Ġwolf": 1037,
+      "Ġwonderful": 1038,
+      "Ġword": 1039,
+      "Ġworlds": 1040,
+      "Ġworm": 1041,
+      "Ġworried": 1042,
+      "Ġworries": 1043,
+      "Ġworse": 1044,
+      "Ġworst": 1045,
+      "Ġwounds": 1046,
+      "Ġwow": 1047,
+      "Ġwriting": 1048,
+      "Ġwrongs": 1049,
+      "Ġyards": 1050,
+      "Ġyes": 1051,
+      "Ġyours": 1052
+    },
+    "unk_token": "<unk>"
+  }
+}

tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<|endoftext|>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "model_max_length": 128,
+  "pad_token": "<|endoftext|>",
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "unk_token": "<unk>",
+  "add_prefix_space": true,
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ]
+}

ui.html

@@ -0,0 +1,139 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>tiny-autocomplete</title>
+<style>
+  :root { --bg: #fafaf9; --fg: #1c1917; --muted: #78716c; --line: #e7e5e4; --accent: #2563eb; --ghost: #a8a29e; --card: #fff; }
+  @media (prefers-color-scheme: dark) {
+    :root { --bg: #0c0a09; --fg: #f5f5f4; --muted: #a8a29e; --line: #292524; --accent: #60a5fa; --ghost: #57534e; --card: #1c1917; }
+  }
+  * { box-sizing: border-box; }
+  body { margin: 0; font: 16px/1.5 system-ui, -apple-system, sans-serif; background: var(--bg); color: var(--fg); }
+  main { max-width: 720px; margin: 0 auto; padding: 48px 20px; }
+  h1 { font-size: 24px; margin: 0 0 4px; }
+  .sub { color: var(--muted); margin: 0 0 28px; font-size: 14px; }
+  .editor { position: relative; background: var(--card); border: 1px solid var(--line); border-radius: 12px; }
+  .editor:focus-within { border-color: var(--accent); }
+  .layer { font: 20px/1.5 system-ui, -apple-system, sans-serif; padding: 16px 18px; margin: 0; white-space: pre-wrap; word-wrap: break-word; }
+  #ghost { position: absolute; inset: 0; pointer-events: none; color: transparent; }
+  #ghost span { color: var(--ghost); }
+  #prompt { position: relative; width: 100%; min-height: 64px; border: 0; outline: 0; resize: none; background: transparent; color: var(--fg); overflow: hidden; }
+  .hint { display: flex; justify-content: space-between; color: var(--muted); font-size: 13px; margin: 8px 2px 24px; }
+  kbd { border: 1px solid var(--line); border-radius: 4px; padding: 0 5px; font-size: 12px; background: var(--card); }
+  h2 { font-size: 13px; text-transform: uppercase; letter-spacing: .06em; color: var(--muted); margin: 0 0 10px; font-weight: 600; }
+  #next { display: grid; gap: 6px; margin-bottom: 28px; min-height: 40px; }
+  .cand { display: grid; grid-template-columns: 140px 1fr 56px; align-items: center; gap: 12px; padding: 6px 10px; border: 1px solid var(--line); border-radius: 8px; background: var(--card); cursor: pointer; text-align: left; font: inherit; color: inherit; }
+  .cand:hover { border-color: var(--accent); }
+  .bar { height: 6px; border-radius: 3px; background: var(--line); overflow: hidden; }
+  .bar i { display: block; height: 100%; background: var(--accent); }
+  .pct { text-align: right; color: var(--muted); font-variant-numeric: tabular-nums; font-size: 14px; }
+  .tok { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 14px; white-space: pre; overflow: hidden; text-overflow: ellipsis; }
+  .examples { display: flex; flex-wrap: wrap; gap: 8px; }
+  .ex { border: 1px solid var(--line); background: var(--card); color: inherit; border-radius: 999px; padding: 4px 12px; font: inherit; font-size: 14px; cursor: pointer; }
+  .ex:hover { border-color: var(--accent); }
+  .empty { color: var(--muted); font-size: 14px; }
+</style>
+</head>
+<body>
+<main>
+  <h1>tiny-autocomplete</h1>
+  <p class="sub" id="info">A compiled (not trained) Llama-format model, running in plain TypeScript.</p>
+
+  <div class="editor">
+    <pre class="layer" id="ghost" aria-hidden="true"></pre>
+    <textarea class="layer" id="prompt" rows="1" placeholder="Start typing, e.g. Once upon a" autofocus spellcheck="false"></textarea>
+  </div>
+  <div class="hint">
+    <span><kbd>Tab</kbd> accept completion &nbsp; <kbd>Enter</kbd> accept next word</span>
+    <span id="status"></span>
+  </div>
+
+  <h2>Next word</h2>
+  <div id="next"><div class="empty">Type a prompt to see predictions.</div></div>
+
+  <h2>Try</h2>
+  <div class="examples" id="examples"></div>
+</main>
+<script>
+  var EXAMPLES = ["Once upon a", "The quick brown", "Thank you for", "I hope this email", "Can I have the",
+                  "Actions speak", "How are", "Looking forward to", "Where is the", "Don't worry"];
+  var promptEl = document.getElementById("prompt");
+  var ghostEl = document.getElementById("ghost");
+  var nextEl = document.getElementById("next");
+  var statusEl = document.getElementById("status");
+  var latest = { completion: "", top: [] };
+  var seq = 0, timer = null;
+
+  function esc(s) { return s.replace(/[&<>]/g, function (c) { return { "&": "&amp;", "<": "&lt;", ">": "&gt;" }[c]; }); }
+
+  function render() {
+    var text = promptEl.value;
+    ghostEl.innerHTML = esc(text) + "<span>" + esc(text ? latest.completion : "") + "</span>";
+    promptEl.style.height = "auto";
+    promptEl.style.height = Math.max(promptEl.scrollHeight, ghostEl.scrollHeight) + "px";
+    if (!text.trim() || !latest.top.length) {
+      nextEl.innerHTML = '<div class="empty">Type a prompt to see predictions.</div>';
+      return;
+    }
+    nextEl.innerHTML = "";
+    latest.top.forEach(function (t) {
+      var p = Math.exp(t.logprob) * 100;
+      var b = document.createElement("button");
+      b.className = "cand";
+      b.innerHTML = '<span class="tok"></span><span class="bar"><i style="width:' + p.toFixed(1) + '%"></i></span><span class="pct">' + p.toFixed(1) + "%</span>";
+      b.querySelector(".tok").textContent = t.id === 0 ? "<end>" : JSON.stringify(t.token);
+      b.onclick = function () { if (t.id !== 0) append(t.token); promptEl.focus(); };
+      nextEl.appendChild(b);
+    });
+  }
+
+  function append(s) { promptEl.value += s; latest = { completion: "", top: latest.top }; render(); schedule(0); }
+
+  function schedule(delay) {
+    clearTimeout(timer);
+    timer = setTimeout(run, delay);
+  }
+
+  function run() {
+    var id = ++seq, text = promptEl.value;
+    if (!text.trim()) { latest = { completion: "", top: [] }; statusEl.textContent = ""; render(); return; }
+    statusEl.textContent = "thinking...";
+    fetch("/api/complete", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ prompt: text, topK: 5 }) })
+      .then(function (r) { return r.json(); })
+      .then(function (r) {
+        if (id !== seq || promptEl.value !== text) return; // stale
+        if (r.error) { statusEl.textContent = r.error; return; }
+        latest = r;
+        statusEl.textContent = r.ms + " ms";
+        render();
+      })
+      .catch(function (e) { statusEl.textContent = String(e); });
+  }
+
+  promptEl.addEventListener("input", function () { latest = { completion: "", top: [] }; render(); schedule(200); });
+  promptEl.addEventListener("keydown", function (e) {
+    if (e.key === "Tab" && latest.completion) { e.preventDefault(); append(latest.completion); }
+    else if (e.key === "Enter") {
+      e.preventDefault();
+      var t = latest.top[0];
+      if (t && t.id !== 0) append(t.token);
+    }
+  });
+
+  EXAMPLES.forEach(function (ex) {
+    var b = document.createElement("button");
+    b.className = "ex"; b.textContent = ex;
+    b.onclick = function () { promptEl.value = ex; latest = { completion: "", top: [] }; render(); schedule(0); promptEl.focus(); };
+    document.getElementById("examples").appendChild(b);
+  });
+
+  fetch("/api/info").then(function (r) { return r.json(); }).then(function (i) {
+    document.getElementById("info").textContent = "A compiled (not trained) Llama-format model: " + i.params.toLocaleString() +
+      " parameters, " + i.vocab.toLocaleString() + " words, " + i.neurons.toLocaleString() + " n-gram neurons. Running in plain TypeScript.";
+  });
+  render();
+</script>
+</body>
+</html>

ui.ts

@@ -0,0 +1,56 @@
+// Browser UI for trying prompts (zero dependencies).
+//
+//   bun ui.ts          then open http://localhost:3000
+//   PORT=8080 node ui.ts
+//
+// Serves ui.html and a JSON endpoint backed by the plain-TypeScript model in model.ts.
+
+import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { Autocompleter } from "./model.ts";
+
+const DIR = import.meta.dirname ?? new URL(".", import.meta.url).pathname;
+const PORT = Number(process.env.PORT ?? 3000);
+
+console.log("Loading model...");
+const ac = new Autocompleter(DIR);
+const html = readFileSync(join(DIR, "ui.html"));
+const cfg = ac.model.cfg;
+const info = {
+  params: ac.model.numParams,
+  vocab: cfg.vocab_size,
+  layers: cfg.num_hidden_layers,
+  hidden: cfg.hidden_size,
+  neurons: cfg.intermediate_size,
+};
+
+function json(res: import("node:http").ServerResponse, status: number, body: unknown): void {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+createServer((req, res) => {
+  if (req.method === "GET" && (req.url === "/" || req.url === "/index.html")) {
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(html);
+  } else if (req.method === "GET" && req.url === "/api/info") {
+    json(res, 200, info);
+  } else if (req.method === "POST" && req.url === "/api/complete") {
+    let body = "";
+    req.on("data", (chunk) => (body += chunk));
+    req.on("end", () => {
+      try {
+        const { prompt, topK } = JSON.parse(body || "{}");
+        if (typeof prompt !== "string" || prompt.length > 1000) return json(res, 400, { error: "prompt must be a string under 1000 chars" });
+        const t0 = performance.now();
+        const result = prompt.trim() ? ac.complete(prompt, Math.min(Number(topK) || 5, 20)) : { prompt, completion: "", top: [] };
+        json(res, 200, { ...result, ms: Math.round(performance.now() - t0) });
+      } catch (e) {
+        json(res, 400, { error: String(e) });
+      }
+    });
+  } else {
+    res.writeHead(404).end();
+  }
+}).listen(PORT, "127.0.0.1", () => console.log(`tiny-autocomplete UI: http://localhost:${PORT}`));