web updates

Entire-Checkpoint: c46fc6ba87b8

.gitignore

···
 
 # Model weights
 weights/
+QwenTheBard/
 *.bin
+*.safetensors
+*.gguf
 
 # Distribution
 dist/
···
 .gemini/
 .opencode/
 .claude/
+
+FANTASMA-PRD.md
 
 # OS
 .DS_Store

dist.sh

···
 set -euo pipefail
 
 ROOT="$(cd "$(dirname "$0")" && pwd)"
-DIST="$ROOT/dist"
+DIST="$ROOT/web/dist"
 
 echo "=== Fantasma dist ==="
 
···
 zig build wasm
 echo "      fantasma.wasm: $(du -h zig-out/bin/fantasma.wasm | cut -f1)"
 
-# Assemble dist/
-echo "[2/3] Assembling dist/..."
-rm -rf "$DIST"
-mkdir -p "$DIST"
+# Copy WASM to public/ so Vite can serve it
+cp zig-out/bin/fantasma.wasm "$ROOT/web/public/"
 
-cp zig-out/bin/fantasma.wasm "$DIST/"
-cp web/index.html "$DIST/"
-cp web/style.css "$DIST/"
-cp web/app.js "$DIST/"
-cp web/oat.min.css "$DIST/"
-cp web/oat.min.js "$DIST/"
-cp web/sw.js "$DIST/"
-cp web/manifest.json "$DIST/"
-cp web/favicon.svg "$DIST/"
+# Build frontend with Vite
+echo "[2/3] Building frontend..."
+cd "$ROOT/web"
+bun run build
 
-echo "      $(ls "$DIST" | wc -l) files -> dist/"
+echo "      $(find "$DIST" -type f | wc -l) files -> web/dist/"
 echo ""
 ls -lh "$DIST"
 echo ""

docs/plans/2026-03-06-int4-simd-inference-wiring.md

···
+# INT4 Quantization + WASM SIMD + Inference Wiring
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Shrink model from 1.75GB BF16 to ~400MB INT4, add WASM SIMD128 dot products, and wire the inference engine into the rewrite pipeline so `neutralize()` actually calls the model.
+
+**Architecture:** Python script converts BF16 safetensors to a custom Q4MF binary format (group_size=128, asymmetric quantization). Zig loads Q4MF and dequantizes on-the-fly in `Tensor.dot()`. SIMD128 via `@Vector(4, f32)` accelerates dot products for all data formats. An adapter function bridges the inference engine to `rewrite.zig`'s `InferenceFn` interface using file-level globals for model state.
+
+**Tech Stack:** Python 3 + numpy + safetensors (converter), Zig 0.15.2 (engine), WASM SIMD128 (browser perf)
+
+---
+
+### Task 1: Python Q4MF Converter Script
+
+**Files:**
+- Create: `scripts/convert_q4.py`
+
+**Context:** The Q4MF binary format packs weights as INT4 with per-group (128 elements) f16 scale and f16 zero point. Small tensors (numel <= 1024 or 1D) stay BF16/F32. Only `model.language_model.*` tensors are included (skip `mtp.*` tensors — those are multi-token prediction heads, unused for inference).
+
+Q4MF format:
+```
+Header (16 bytes):
+  magic: u32 LE = 0x46344D51 ("Q4MF")
+  version: u32 LE = 1
+  num_tensors: u32 LE
+  group_size: u32 LE = 128
+
+Per tensor:
+  name_len: u16 LE
+  name: [name_len] bytes (UTF-8)
+  ndim: u8
+  shape: [ndim] u32 LE
+  dtype: u8 (0=Q4_GROUP, 1=F32, 2=BF16)
+  data_len: u32 LE
+  data: [data_len] bytes
+
+Q4_GROUP data layout (per group of 128 weights):
+  scale: f16 LE (2 bytes)
+  zero:  f16 LE (2 bytes)
+  packed: 64 bytes (128 nibbles, 2 per byte, low nibble first)
+  Total: 68 bytes per group
+
+Asymmetric quantization:
+  scale = (max - min) / 15.0
+  zero = min
+  quantized = clamp(round((val - zero) / scale), 0, 15)
+  dequantized = quantized * scale + zero
+```
+
+**Step 1: Write the converter script**
+
+```python
+#!/usr/bin/env python3
+"""Convert BF16 safetensors to INT4 group-quantized Q4MF format."""
+import struct
+import sys
+import json
+import numpy as np
+
+MAGIC = 0x46344D51
+VERSION = 1
+GROUP_SIZE = 128
+DTYPE_Q4 = 0
+DTYPE_F32 = 1
+DTYPE_BF16 = 2
+MIN_QUANTIZE_NUMEL = 1024
+
+
+def bf16_to_f32(raw: bytes) -> np.ndarray:
+    u16 = np.frombuffer(raw, dtype=np.uint16)
+    u32 = u16.astype(np.uint32) << 16
+    return u32.view(np.float32)
+
+
+def quantize_group(values: np.ndarray) -> tuple[np.float16, np.float16, bytes]:
+    vmin, vmax = values.min(), values.max()
+    if vmax == vmin:
+        return np.float16(0.0), np.float16(vmin), bytes(len(values) // 2)
+
+    scale = np.float16((vmax - vmin) / 15.0)
+    zero = np.float16(vmin)
+    scale_f32, zero_f32 = float(scale), float(zero)
+
+    if scale_f32 == 0.0:
+        return scale, zero, bytes(len(values) // 2)
+
+    q = np.clip(np.round((values - zero_f32) / scale_f32), 0, 15).astype(np.uint8)
+    packed = q[0::2] | (q[1::2] << 4)
+    return scale, zero, packed.tobytes()
+
+
+def convert(input_path: str, output_path: str):
+    with open(input_path, "rb") as f:
+        header_len = struct.unpack("<Q", f.read(8))[0]
+        header = json.loads(f.read(header_len))
+        data_start = 8 + header_len
+
+    tensor_meta = {k: v for k, v in header.items() if k != "__metadata__"}
+
+    # Only keep model.language_model.* tensors (skip mtp.*)
+    model_tensors = {
+        k: v for k, v in tensor_meta.items() if k.startswith("model.language_model.")
+    }
+
+    tensors = []
+    with open(input_path, "rb") as f:
+        for name in sorted(model_tensors):
+            info = model_tensors[name]
+            shape = info["shape"]
+            dtype_str = info["dtype"]
+            offsets = info["data_offsets"]
+            data_len = offsets[1] - offsets[0]
+
+            f.seek(data_start + offsets[0])
+            raw = f.read(data_len)
+
+            numel = 1
+            for s in shape:
+                numel *= s
+
+            if dtype_str == "F32":
+                tensors.append((name, shape, DTYPE_F32, raw))
+                print(f"  F32   {name}: {shape}")
+            elif numel > MIN_QUANTIZE_NUMEL and len(shape) >= 2:
+                values = bf16_to_f32(raw)
+                # Pad to multiple of GROUP_SIZE
+                remainder = len(values) % GROUP_SIZE
+                if remainder != 0:
+                    values = np.concatenate(
+                        [values, np.zeros(GROUP_SIZE - remainder, dtype=np.float32)]
+                    )
+
+                num_groups = len(values) // GROUP_SIZE
+                q4_data = bytearray()
+                for g in range(num_groups):
+                    group = values[g * GROUP_SIZE : (g + 1) * GROUP_SIZE]
+                    scale, zero, packed = quantize_group(group)
+                    q4_data += struct.pack("<e", scale)
+                    q4_data += struct.pack("<e", zero)
+                    q4_data += packed
+
+                tensors.append((name, shape, DTYPE_Q4, bytes(q4_data)))
+                ratio = len(q4_data) / data_len * 100
+                print(f"  Q4    {name}: {shape} ({ratio:.0f}% of original)")
+            else:
+                tensors.append((name, shape, DTYPE_BF16, raw))
+                print(f"  BF16  {name}: {shape}")
+
+    with open(output_path, "wb") as f:
+        f.write(struct.pack("<IIII", MAGIC, VERSION, len(tensors), GROUP_SIZE))
+
+        for name, shape, dtype, data in tensors:
+            name_bytes = name.encode("utf-8")
+            f.write(struct.pack("<H", len(name_bytes)))
+            f.write(name_bytes)
+            f.write(struct.pack("<B", len(shape)))
+            for s in shape:
+                f.write(struct.pack("<I", s))
+            f.write(struct.pack("<B", dtype))
+            f.write(struct.pack("<I", len(data)))
+            f.write(data)
+
+    import os
+
+    size_mb = os.path.getsize(output_path) / 1e6
+    print(f"\nWrote {output_path}: {len(tensors)} tensors, {size_mb:.1f} MB")
+
+
+if __name__ == "__main__":
+    input_path = (
+        sys.argv[1]
+        if len(sys.argv) > 1
+        else "QwenTheBard/model.safetensors-00001-of-00001.safetensors"
+    )
+    output_path = sys.argv[2] if len(sys.argv) > 2 else "QwenTheBard/model.q4"
+    convert(input_path, output_path)
+```
+
+**Step 2: Run the converter and verify output**
+
+```bash
+python3 scripts/convert_q4.py
+# Expected: prints each tensor with Q4/BF16/F32 label
+# Expected: "Wrote QwenTheBard/model.q4: ~200 tensors, ~400 MB"
+ls -lh QwenTheBard/model.q4
+# Expected: ~400M file
+```
+
+**Step 3: Verify Q4MF header is parseable**
+
+```bash
+python3 -c "
+import struct
+with open('QwenTheBard/model.q4', 'rb') as f:
+    magic, version, num_tensors, group_size = struct.unpack('<IIII', f.read(16))
+    assert magic == 0x46344D51, f'Bad magic: {hex(magic)}'
+    assert version == 1
+    assert group_size == 128
+    print(f'Q4MF v{version}: {num_tensors} tensors, group_size={group_size}')
+    # Read first tensor to verify structure
+    name_len = struct.unpack('<H', f.read(2))[0]
+    name = f.read(name_len).decode()
+    ndim = struct.unpack('<B', f.read(1))[0]
+    shape = [struct.unpack('<I', f.read(4))[0] for _ in range(ndim)]
+    dtype = struct.unpack('<B', f.read(1))[0]
+    data_len = struct.unpack('<I', f.read(4))[0]
+    dtypes = ['Q4', 'F32', 'BF16']
+    print(f'First tensor: {name} shape={shape} dtype={dtypes[dtype]} data={data_len} bytes')
+"
+# Expected: valid header, first tensor name matches model.language_model.*
+```
+
+**Step 4: Commit**
+
+```bash
+git add scripts/convert_q4.py
+git commit -m "feat: add Python Q4MF converter for INT4 quantization"
+```
+
+---
+
+### Task 2: Q4 Data Structures and Dequantization in Zig
+
+**Files:**
+- Modify: `src/inference/quantized.zig`
+
+**Context:** Add `Q4Data` struct to `Tensor` and implement element-wise and group-wise dequantization. The `get()` and `dot()` methods must transparently handle Q4 data alongside existing BF16/F32 paths.
+
+**Step 1: Write failing test for Q4 dequantization**
+
+Add at the bottom of `src/inference/quantized.zig`:
+
+```zig
+test "q4 dequantization" {
+    // Manually construct a single group of 128 elements:
+    // scale = 1.0 (f16), zero = 0.0 (f16), nibbles all encode their index mod 16
+    var group_data: [68]u8 = undefined;
+
+    // scale = 1.0 as f16 = 0x3C00
+    group_data[0] = 0x00;
+    group_data[1] = 0x3C;
+    // zero = 0.0 as f16 = 0x0000
+    group_data[2] = 0x00;
+    group_data[3] = 0x00;
+
+    // Pack nibbles: element 2i = i%16, element 2i+1 = (i+1)%16
+    // Actually, simpler: set all nibbles to known values
+    // byte[j] = low_nibble | (high_nibble << 4)
+    // elements 0,1 → byte 0; elements 2,3 → byte 1; etc.
+    for (0..64) |j| {
+        const low: u8 = @intCast((j * 2) % 16);
+        const high: u8 = @intCast((j * 2 + 1) % 16);
+        group_data[4 + j] = low | (high << 4);
+    }
+
+    const q4 = Q4Data{
+        .raw = &group_data,
+        .num_elements = 128,
+        .group_size = 128,
+    };
+
+    // Element 0: nibble=0, dequant = 0 * 1.0 + 0.0 = 0.0
+    try std.testing.expectApproxEqAbs(@as(f32, 0.0), q4.get(0), 1e-3);
+    // Element 1: nibble=1, dequant = 1 * 1.0 + 0.0 = 1.0
+    try std.testing.expectApproxEqAbs(@as(f32, 1.0), q4.get(1), 1e-3);
+    // Element 14: nibble=14, dequant = 14.0
+    try std.testing.expectApproxEqAbs(@as(f32, 14.0), q4.get(14), 1e-3);
+    // Element 15: nibble=15, dequant = 15.0
+    try std.testing.expectApproxEqAbs(@as(f32, 15.0), q4.get(15), 1e-3);
+    // Element 16: nibble=0 (wraps mod 16), dequant = 0.0
+    try std.testing.expectApproxEqAbs(@as(f32, 0.0), q4.get(16), 1e-3);
+}
+
+test "q4 dequantization with offset" {
+    // Two groups: second group has scale=2.0, zero=10.0
+    var data: [68 * 2]u8 = undefined;
+
+    // Group 0: scale=1.0, zero=0.0, all nibbles=5
+    data[0] = 0x00;
+    data[1] = 0x3C; // f16 1.0
+    data[2] = 0x00;
+    data[3] = 0x00; // f16 0.0
+    @memset(data[4..68], 0x55); // nibble 5 in both low and high
+
+    // Group 1: scale=2.0 (0x4000), zero=10.0 (0x4900)
+    data[68] = 0x00;
+    data[69] = 0x40; // f16 2.0
+    data[70] = 0x00;
+    data[71] = 0x49; // f16 10.0
+    @memset(data[72..136], 0x33); // nibble 3 in both low and high
+
+    const q4 = Q4Data{
+        .raw = &data,
+        .num_elements = 256,
+        .group_size = 128,
+    };
+
+    // Group 0, element 0: 5 * 1.0 + 0.0 = 5.0
+    try std.testing.expectApproxEqAbs(@as(f32, 5.0), q4.get(0), 1e-2);
+    // Group 1, element 128: 3 * 2.0 + 10.0 = 16.0
+    try std.testing.expectApproxEqAbs(@as(f32, 16.0), q4.get(128), 1e-1);
+}
+```
+
+**Step 2: Run test to verify it fails**
+
+```bash
+cd /home/christian/dev/klearu/klearu-sdc/fantasma-zig && zig build test 2>&1 | tail -20
+# Expected: FAIL — Q4Data not defined
+```
+
+**Step 3: Implement Q4Data struct and update Tensor**
+
+Add `Q4Data` struct after the `Tensor` struct in `quantized.zig`, then add the `data_q4` field to `Tensor`, and update `get()` and `dot()`:
+
+```zig
+// Add to Tensor struct:
+pub const Tensor = struct {
+    data_bf16: ?[]const u16 = null,
+    data_f32: ?[]const f32 = null,
+    data_q4: ?Q4Data = null,       // ADD THIS FIELD
+    shape: [4]u32 = .{ 0, 0, 0, 0 },
+    ndim: u8 = 0,
+
+    // ... numel() unchanged ...
+
+    pub inline fn get(self: *const Tensor, idx: usize) f32 {
+        if (self.data_f32) |f| return f[idx];
+        if (self.data_bf16) |b| return bf16ToF32(b[idx]);
+        if (self.data_q4) |*q| return q.get(idx);   // ADD THIS LINE
+        return 0.0;
+    }
+
+    pub fn dot(self: *const Tensor, offset: usize, other: []const f32) f32 {
+        const n = other.len;
+
+        if (self.data_f32) |f| {
+            return simdDotF32(f[offset .. offset + n], other);
+        }
+
+        if (self.data_bf16) |b| {
+            return simdDotBf16(b[offset .. offset + n], other);
+        }
+
+        if (self.data_q4) |*q| {
+            return q.dot(offset, other);
+        }
+
+        return 0.0;
+    }
+};
+
+// Add after Tensor struct:
+pub const Q4Data = struct {
+    raw: []const u8,
+    num_elements: u32,
+    group_size: u32,
+
+    const GROUP_HEADER: usize = 4; // 2 bytes scale + 2 bytes zero
+    const NIBBLES_PER_BYTE: usize = 2;
+
+    fn groupBytes(self: *const Q4Data) usize {
+        return GROUP_HEADER + self.group_size / NIBBLES_PER_BYTE;
+    }
+
+    pub inline fn get(self: *const Q4Data, idx: usize) f32 {
+        const gb = self.groupBytes();
+        const group_idx = idx / self.group_size;
+        const within = idx % self.group_size;
+        const group_offset = group_idx * gb;
+
+        const scale = f16ToF32(std.mem.readInt(u16, self.raw[group_offset..][0..2], .little));
+        const zero = f16ToF32(std.mem.readInt(u16, self.raw[group_offset + 2 ..][0..2], .little));
+
+        const byte_idx = within / 2;
+        const packed_byte = self.raw[group_offset + GROUP_HEADER + byte_idx];
+        const nibble: u8 = if (within % 2 == 0) packed_byte & 0x0F else packed_byte >> 4;
+
+        return @as(f32, @floatFromInt(nibble)) * scale + zero;
+    }
+
+    pub fn dot(self: *const Q4Data, offset: usize, other: []const f32) f32 {
+        const n = other.len;
+        const gs = self.group_size;
+        const gb = self.groupBytes();
+        var sum: f32 = 0.0;
+
+        var elem_idx = offset;
+        var other_idx: usize = 0;
+
+        while (other_idx < n) {
+            const group_idx = elem_idx / gs;
+            const within_start = elem_idx % gs;
+            const group_offset = group_idx * gb;
+            const remaining_in_group = gs - within_start;
+            const chunk = @min(remaining_in_group, n - other_idx);
+
+            const scale = f16ToF32(std.mem.readInt(u16, self.raw[group_offset..][0..2], .little));
+            const zero = f16ToF32(std.mem.readInt(u16, self.raw[group_offset + 2 ..][0..2], .little));
+            const packed = self.raw[group_offset + GROUP_HEADER ..][0 .. gs / 2];
+
+            // Dequantize chunk into stack buffer and SIMD dot
+            var deq_buf: [256]f32 = undefined; // max group_size=256
+            const deq = deq_buf[0..chunk];
+
+            for (0..chunk) |i| {
+                const wi = within_start + i;
+                const byte_idx = wi / 2;
+                const b = packed[byte_idx];
+                const nibble: u8 = if (wi % 2 == 0) b & 0x0F else b >> 4;
+                deq[i] = @as(f32, @floatFromInt(nibble)) * scale + zero;
+            }
+
+            sum += simdDotF32(deq, other[other_idx .. other_idx + chunk]);
+
+            elem_idx += chunk;
+            other_idx += chunk;
+        }
+
+        return sum;
+    }
+};
+```
+
+Also add the `f16ToF32` helper near the top of the file:
+
+```zig
+/// Convert a single F16 value (u16 bits) to F32.
+pub inline fn f16ToF32(bits: u16) f32 {
+    return @floatCast(@as(f16, @bitCast(bits)));
+}
+```
+
+**Step 4: Run tests to verify they pass**
+
+```bash
+cd /home/christian/dev/klearu/klearu-sdc/fantasma-zig && zig build test 2>&1 | tail -5
+# Expected: All tests pass including q4 dequantization tests
+```
+
+**Step 5: Commit**
+
+```bash
+git add src/inference/quantized.zig
+git commit -m "feat: add Q4Data struct with INT4 group dequantization"
+```
+
+---
+
+### Task 3: SIMD Dot Products
+
+**Files:**
+- Modify: `src/inference/quantized.zig`
+
+**Context:** Replace the scalar dot product loops with `@Vector(4, f32)` SIMD. This compiles to WASM SIMD128 on wasm32 and SSE/AVX on x86. Three functions: `simdDotF32` (for F32 tensors), `simdDotBf16` (for BF16 tensors, dequantizes then SIMD), and the Q4 path already uses `simdDotF32` via the dequantize-then-dot approach from Task 2.
+
+**Step 1: Write failing test for SIMD dot product**
+
+Add at the bottom of `src/inference/quantized.zig`:
+
+```zig
+test "simd dot f32" {
+    const a = [_]f32{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
+    const b = [_]f32{ 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 };
+    const result = simdDotF32(&a, &b);
+    // 9+16+21+24+25+24+21+16+9 = 165
+    try std.testing.expectApproxEqAbs(@as(f32, 165.0), result, 1e-4);
+}
+
+test "simd dot bf16" {
+    // 1.0 in bf16 = 0x3F80, 2.0 = 0x4000
+    const a = [_]u16{ 0x3F80, 0x4000, 0x3F80, 0x4000 };
+    const b = [_]f32{ 1.0, 1.0, 1.0, 1.0 };
+    const result = simdDotBf16(&a, &b);
+    // 1*1 + 2*1 + 1*1 + 2*1 = 6.0
+    try std.testing.expectApproxEqAbs(@as(f32, 6.0), result, 1e-4);
+}
+```
+
+**Step 2: Run test to verify it fails**
+
+```bash
+cd /home/christian/dev/klearu/klearu-sdc/fantasma-zig && zig build test 2>&1 | tail -10
+# Expected: FAIL — simdDotF32/simdDotBf16 not defined
+```
+
+**Step 3: Implement SIMD dot product functions**
+
+Add these functions in `quantized.zig` before the `matVec` function:
+
+```zig
+/// SIMD-accelerated dot product for two f32 slices.
+/// Uses @Vector(4, f32) which compiles to WASM SIMD128 or SSE/AVX.
+pub fn simdDotF32(a: []const f32, b: []const f32) f32 {
+    const n = a.len;
+    const VF32x4 = @Vector(4, f32);
+    var acc: VF32x4 = @splat(0.0);
+
+    var i: usize = 0;
+    while (i + 4 <= n) : (i += 4) {
+        const va: VF32x4 = a[i..][0..4].*;
+        const vb: VF32x4 = b[i..][0..4].*;
+        acc += va * vb;
+    }
+
+    var sum = @reduce(.Add, acc);
+
+    // Scalar tail
+    while (i < n) : (i += 1) {
+        sum += a[i] * b[i];
+    }
+
+    return sum;
+}
+
+/// SIMD-accelerated dot product for BF16 weights against f32 input.
+/// Dequantizes BF16 in chunks of 4, then SIMD multiplies.
+pub fn simdDotBf16(a_bf16: []const u16, b: []const f32) f32 {
+    const n = a_bf16.len;
+    const VF32x4 = @Vector(4, f32);
+    var acc: VF32x4 = @splat(0.0);
+
+    var i: usize = 0;
+    while (i + 4 <= n) : (i += 4) {
+        const va = VF32x4{
+            bf16ToF32(a_bf16[i]),
+            bf16ToF32(a_bf16[i + 1]),
+            bf16ToF32(a_bf16[i + 2]),
+            bf16ToF32(a_bf16[i + 3]),
+        };
+        const vb: VF32x4 = b[i..][0..4].*;
+        acc += va * vb;
+    }
+
+    var sum = @reduce(.Add, acc);
+
+    while (i < n) : (i += 1) {
+        sum += bf16ToF32(a_bf16[i]) * b[i];
+    }
+
+    return sum;
+}
+```
+
+**Step 4: Update `Tensor.dot()` to use SIMD helpers**
+
+Replace the existing `Tensor.dot()` method with the version from Task 2 Step 3 (which calls `simdDotF32` and `simdDotBf16`). The full replacement:
+
+```zig
+    pub fn dot(self: *const Tensor, offset: usize, other: []const f32) f32 {
+        const n = other.len;
+
+        if (self.data_f32) |f| {
+            return simdDotF32(f[offset .. offset + n], other);
+        }
+
+        if (self.data_bf16) |b| {
+            return simdDotBf16(b[offset .. offset + n], other);
+        }
+
+        if (self.data_q4) |*q| {
+            return q.dot(offset, other);
+        }
+
+        return 0.0;
+    }
+```
+
+**Step 5: Run all tests**
+
+```bash
+cd /home/christian/dev/klearu/klearu-sdc/fantasma-zig && zig build test 2>&1 | tail -5
+# Expected: All tests pass including SIMD dot tests
+```
+
+**Step 6: Commit**
+
+```bash
+git add src/inference/quantized.zig
+git commit -m "feat: add SIMD128 dot products for f32, bf16, and q4 tensors"
+```
+
+---
+
+### Task 4: Q4MF Loader in model.zig
+
+**Files:**
+- Modify: `src/inference/model.zig`
+- Modify: `src/inference/quantized.zig` (add Q4MF parser)
+
+**Context:** Parse the Q4MF binary format and construct `ModelWeights` with `Tensor` views pointing into the loaded data. For BF16/F32 tensors in the Q4MF file, copy to aligned allocations since the packed file has no alignment guarantees. For Q4 tensors, store as `Q4Data` pointing directly into the file buffer.
+
+**Step 1: Add Q4MF format constants and parser to `quantized.zig`**
+
+Add at the bottom of `quantized.zig` before the tests:
+
+```zig
+// ============================================================
+// Q4MF format parser
+// ============================================================
+
+pub const Q4MF_MAGIC: u32 = 0x46344D51;
+pub const Q4MF_VERSION: u32 = 1;
+
+pub const Q4MFTensorInfo = struct {
+    name: []const u8,
+    shape: [4]u32,
+    ndim: u8,
+    dtype: u8, // 0=Q4, 1=F32, 2=BF16
+    data: []const u8,
+};
+
+pub const Q4MFHeader = struct {
+    num_tensors: u32,
+    group_size: u32,
+    tensors: []Q4MFTensorInfo,
+};
+
+/// Parse a Q4MF file buffer and return tensor metadata.
+/// The returned tensor infos point into file_data (zero-copy for data).
+pub fn parseQ4MF(
+    allocator: std.mem.Allocator,
+    file_data: []const u8,
+) !Q4MFHeader {
+    if (file_data.len < 16) return SafetensorsError.InvalidFormat;
+
+    const magic = std.mem.readInt(u32, file_data[0..4], .little);
+    if (magic != Q4MF_MAGIC) return SafetensorsError.InvalidFormat;
+
+    const version = std.mem.readInt(u32, file_data[4..8], .little);
+    if (version != Q4MF_VERSION) return SafetensorsError.InvalidFormat;
+
+    const num_tensors = std.mem.readInt(u32, file_data[8..12], .little);
+    const group_size = std.mem.readInt(u32, file_data[12..16], .little);
+
+    const tensors = try allocator.alloc(Q4MFTensorInfo, num_tensors);
+
+    var pos: usize = 16;
+    for (0..num_tensors) |ti| {
+        if (pos + 2 > file_data.len) return SafetensorsError.InvalidFormat;
+        const name_len = std.mem.readInt(u16, file_data[pos..][0..2], .little);
+        pos += 2;
+
+        const name = file_data[pos .. pos + name_len];
+        pos += name_len;
+
+        const ndim = file_data[pos];
+        pos += 1;
+
+        var shape: [4]u32 = .{ 0, 0, 0, 0 };
+        for (0..ndim) |d| {
+            shape[d] = std.mem.readInt(u32, file_data[pos..][0..4], .little);
+            pos += 4;
+        }
+
+        const dtype = file_data[pos];
+        pos += 1;
+
+        const data_len = std.mem.readInt(u32, file_data[pos..][0..4], .little);
+        pos += 4;
+
+        const data = file_data[pos .. pos + data_len];
+        pos += data_len;
+
+        tensors[ti] = .{
+            .name = name,
+            .shape = shape,
+            .ndim = ndim,
+            .dtype = dtype,
+            .data = data,
+        };
+    }
+
+    return .{
+        .num_tensors = num_tensors,
+        .group_size = group_size,
+        .tensors = tensors,
+    };
+}
+
+/// Create a Tensor from Q4MF tensor info.
+/// For Q4 data, creates a Q4Data view. For F32/BF16, copies to aligned allocation.
+pub fn tensorFromQ4MF(info: *const Q4MFTensorInfo, group_size: u32, allocator: std.mem.Allocator) !Tensor {
+    var t = Tensor{
+        .shape = info.shape,
+        .ndim = info.ndim,
+    };
+
+    var numel: u32 = 1;
+    for (info.shape[0..info.ndim]) |s| numel *= s;
+
+    switch (info.dtype) {
+        0 => {
+            // Q4 — zero-copy view into file data
+            t.data_q4 = .{
+                .raw = info.data,
+                .num_elements = numel,
+                .group_size = group_size,
+            };
+        },
+        1 => {
+            // F32 — copy to aligned allocation
+            const f32_data = try allocator.alloc(f32, numel);
+            for (0..numel) |i| {
+                const bits = std.mem.readInt(u32, info.data[i * 4 ..][0..4], .little);
+                f32_data[i] = @bitCast(bits);
+            }
+            t.data_f32 = f32_data;
+        },
+        2 => {
+            // BF16 — copy to aligned allocation
+            const bf16_data = try allocator.alloc(u16, numel);
+            for (0..numel) |i| {
+                bf16_data[i] = std.mem.readInt(u16, info.data[i * 2 ..][0..2], .little);
+            }
+            t.data_bf16 = bf16_data;
+        },
+        else => return SafetensorsError.UnsupportedDtype,
+    }
+
+    return t;
+}
+```
+
+**Step 2: Add `loadWeightsQ4` to `model.zig`**
+
+Add this function after `loadWeights` in `model.zig`:
+
+```zig
+/// Load model weights from Q4MF format (INT4 quantized).
+/// file_data must remain valid for the lifetime of the returned ModelWeights.
+pub fn loadWeightsQ4(allocator: std.mem.Allocator, file_data: []const u8, max_seq_len: u32) !ModelWeights {
+    const header = try q.parseQ4MF(allocator, file_data);
+    // Note: header.tensors is allocated but we don't free it — small and needed during loading
+
+    var weights: ModelWeights = undefined;
+    weights.allocator = allocator;
+
+    // Embedding
+    weights.embed_tokens = try findAndLoadQ4(header, "model.language_model.embed_tokens.weight", allocator);
+    weights.norm = try findAndLoadQ4(header, "model.language_model.norm.weight", allocator);
+
+    // Layers
+    for (0..Config.num_layers) |layer_idx| {
+        var lw: LayerWeights = undefined;
+
+        lw.input_layernorm = try findAndLoadLayerQ4(header, layer_idx, "input_layernorm.weight", allocator);
+        lw.post_attention_layernorm = try findAndLoadLayerQ4(header, layer_idx, "post_attention_layernorm.weight", allocator);
+
+        lw.gate_proj = try findAndLoadLayerQ4(header, layer_idx, "mlp.gate_proj.weight", allocator);
+        lw.up_proj = try findAndLoadLayerQ4(header, layer_idx, "mlp.up_proj.weight", allocator);
+        lw.down_proj = try findAndLoadLayerQ4(header, layer_idx, "mlp.down_proj.weight", allocator);
+
+        if (Config.layer_is_full_attn[layer_idx]) {
+            lw.full_attn = FullAttentionWeights{
+                .q_proj = try findAndLoadLayerQ4(header, layer_idx, "self_attn.q_proj.weight", allocator),
+                .k_proj = try findAndLoadLayerQ4(header, layer_idx, "self_attn.k_proj.weight", allocator),
+                .v_proj = try findAndLoadLayerQ4(header, layer_idx, "self_attn.v_proj.weight", allocator),
+                .o_proj = try findAndLoadLayerQ4(header, layer_idx, "self_attn.o_proj.weight", allocator),
+                .q_norm = try findAndLoadLayerQ4(header, layer_idx, "self_attn.q_norm.weight", allocator),
+                .k_norm = try findAndLoadLayerQ4(header, layer_idx, "self_attn.k_norm.weight", allocator),
+            };
+            lw.delta_net = null;
+        } else {
+            lw.delta_net = DeltaNetWeights{
+                .in_proj_qkv = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.in_proj_qkv.weight", allocator),
+                .in_proj_z = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.in_proj_z.weight", allocator),
+                .in_proj_a = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.in_proj_a.weight", allocator),
+                .in_proj_b = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.in_proj_b.weight", allocator),
+                .conv1d = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.conv1d.weight", allocator),
+                .A_log = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.A_log", allocator),
+                .dt_bias = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.dt_bias", allocator),
+                .norm = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.norm.weight", allocator),
+                .out_proj = try findAndLoadLayerQ4(header, layer_idx, "linear_attn.out_proj.weight", allocator),
+            };
+            lw.full_attn = null;
+        }
+
+        weights.layers[layer_idx] = lw;
+    }
+
+    // Precompute RoPE cos/sin tables (identical to loadWeights)
+    const rotary_dim = Config.rotary_dim;
+    weights.rope_cos = try allocator.alloc(f32, max_seq_len * rotary_dim);
+    weights.rope_sin = try allocator.alloc(f32, max_seq_len * rotary_dim);
+
+    const half_dim = rotary_dim / 2;
+    for (0..max_seq_len) |pos| {
+        for (0..half_dim) |i| {
+            const freq = 1.0 / std.math.pow(f32, Config.rope_theta, @as(f32, @floatFromInt(2 * i)) / @as(f32, @floatFromInt(rotary_dim)));
+            const angle = @as(f32, @floatFromInt(pos)) * freq;
+            const cos_val = @cos(angle);
+            const sin_val = @sin(angle);
+            weights.rope_cos[pos * rotary_dim + i] = cos_val;
+            weights.rope_cos[pos * rotary_dim + half_dim + i] = cos_val;
+            weights.rope_sin[pos * rotary_dim + i] = sin_val;
+            weights.rope_sin[pos * rotary_dim + half_dim + i] = sin_val;
+        }
+    }
+
+    return weights;
+}
+
+fn findAndLoadQ4(header: q.Q4MFHeader, name: []const u8, allocator: std.mem.Allocator) !Tensor {
+    for (header.tensors) |*info| {
+        if (std.mem.eql(u8, info.name, name)) {
+            return try q.tensorFromQ4MF(info, header.group_size, allocator);
+        }
+    }
+    return q.SafetensorsError.TensorNotFound;
+}
+
+fn findAndLoadLayerQ4(header: q.Q4MFHeader, layer_idx: usize, suffix: []const u8, allocator: std.mem.Allocator) !Tensor {
+    var name_buf: [256]u8 = undefined;
+    const name = std.fmt.bufPrint(&name_buf, "model.language_model.layers.{d}.{s}", .{ layer_idx, suffix }) catch return error.PathTooLong;
+    return findAndLoadQ4(header, name, allocator);
+}
+```
+
+**Step 3: Update CLI to auto-detect Q4MF**
+
+In `src/main.zig`, in the `generate` command, replace the weight loading section (around lines 307-316) with auto-detection:
+
+```zig
+        // Try Q4 first, fall back to BF16 safetensors
+        var q4_path_buf: [1024]u8 = undefined;
+        const q4_path = std.fmt.bufPrint(&q4_path_buf, "{s}/model.q4", .{model_dir}) catch "QwenTheBard/model.q4";
+
+        const max_seq_len: u32 = 512;
+        var weights: inference_model.ModelWeights = undefined;
+
+        if (std.fs.cwd().openFile(q4_path, .{})) |q4_file| {
+            const q4_size = try q4_file.getEndPos();
+            const q4_data = try allocator.alloc(u8, q4_size);
+            const q4_read = try q4_file.readAll(q4_data);
+            q4_file.close();
+            if (q4_read != q4_size) {
+                try stderr.print("Incomplete Q4 read\n", .{});
+                try stderr.flush();
+                return;
+            }
+            weights = inference_model.loadWeightsQ4(allocator, q4_data, max_seq_len) catch |e| {
+                try stderr.print("Failed to load Q4 weights: {}\n", .{e});
+                try stderr.flush();
+                return;
+            };
+            try stderr.print("Loaded Q4 model from {s}\n", .{q4_path});
+            try stderr.flush();
+        } else |_| {
+            try stderr.print("Loading BF16 model from {s}...\n", .{model_dir});
+            try stderr.flush();
+            weights = inference_model.loadWeights(allocator, model_dir, max_seq_len) catch |e| {
+                try stderr.print("Failed to load weights: {}\n", .{e});
+                try stderr.flush();
+                return;
+            };
+        }
+```
+
+Also remove the `_ = &weights;` line that follows the old weight loading.
+
+**Step 4: Build and test with Q4 model**
+
+```bash
+cd /home/christian/dev/klearu/klearu-sdc/fantasma-zig && zig build test 2>&1 | tail -5
+# Expected: all tests pass (unit tests don't load actual model)
+
+zig build
+./zig-out/bin/fantasma generate QwenTheBard "What is the capital of France?"
+# Expected: loads Q4 model (if model.q4 exists), generates coherent text
+# Compare output quality with BF16: should be similar but not identical
+```
+
+**Step 5: Commit**
+
+```bash
+git add src/inference/quantized.zig src/inference/model.zig src/main.zig
+git commit -m "feat: add Q4MF loader with auto-detection (Q4 vs BF16)"
+```
+
+---
+
+### Task 5: Wire Inference into Rewrite Pipeline
+
+**Files:**
+- Modify: `src/main.zig` (add globals, adapter function, update WASM exports)
+- Modify: `src/neutralizer/rewrite.zig` (no changes needed — InferenceFn interface is ready)
+
+**Context:** Create an inference adapter function that matches the `InferenceFn = *const fn (prompt: []const u8, output_buf: []u8) usize` signature. It uses file-level globals for model state. Remove `wasm32` guards so inference compiles for both targets. Update WASM `init()` to accept both weights and tokenizer data, and `neutralize()` to call the real pipeline.
+
+**Step 1: Remove wasm32 conditional imports**
+
+In `src/main.zig`, replace lines 17-21:
+
+```zig
+// OLD:
+pub const inference_model = if (builtin.target.cpu.arch != .wasm32) @import("inference/model.zig") else struct {};
+// ... etc
+
+// NEW:
+pub const inference_model = @import("inference/model.zig");
+pub const inference_tokenizer = @import("inference/tokenizer.zig");
+pub const inference_sampler = @import("inference/sampler.zig");
+pub const inference_kv_cache = @import("inference/kv_cache.zig");
+pub const inference_quantized = @import("inference/quantized.zig");
+```
+
+Also remove the `if (@import("builtin").target.cpu.arch != .wasm32)` guard around the comptime test block at the bottom.
+
+**Step 2: Add global model state and inference adapter**
+
+Add after the `output_buf`/`output_len` declarations in `main.zig`:
+
+```zig
+// ============================================================
+// Global model state (for inference adapter)
+// ============================================================
+
+var g_weights: ?inference_model.ModelWeights = null;
+var g_tokenizer: ?inference_tokenizer.Tokenizer = null;
+var g_cache: ?inference_kv_cache.ModelCache = null;
+var g_fwd_state: ?inference_model.ForwardState = null;
+var g_sampler: inference_sampler.Sampler = inference_sampler.Sampler.init(0.7, 40, 42);
+
+const MAX_SEQ_LEN: u32 = 512;
+const MAX_NEW_TOKENS: u32 = 256;
+
+/// Inference adapter matching InferenceFn signature.
+/// Takes a plain text prompt (already formatted with MARKERS + TEXT),
+/// wraps in ChatML, tokenizes, runs forward passes, returns decoded bytes.
+fn inferenceAdapter(prompt: []const u8, out_buf: []u8) usize {
+    const allocator = getAllocator();
+    const tokenizer = &(g_tokenizer orelse return 0);
+    const weights = &(g_weights orelse return 0);
+    var model_cache = &(g_cache orelse return 0);
+    var fwd_state = &(g_fwd_state orelse return 0);
+
+    // Reset cache for each independent neutralization
+    model_cache.reset();
+
+    // Tokenize with ChatML wrapping
+    var token_buf: [2048]u32 = undefined;
+    const prompt_len = tokenizer.encodeChatML(
+        "/no_think\nYou are a stylometric neutralizer. Rewrite the text to remove authorship markers while preserving meaning exactly.",
+        prompt,
+        allocator,
+        &token_buf,
+    ) catch return 0;
+
+    const Config = inference_kv_cache.Config;
+
+    // Prefill
+    var pos: u32 = 0;
+    for (token_buf[0..prompt_len]) |tok| {
+        _ = inference_model.forward(weights, model_cache, fwd_state, tok, pos);
+        pos += 1;
+    }
+
+    // Decode
+    var out_pos: usize = 0;
+    var generated: u32 = 0;
+    var decode_tmp: [512]u8 = undefined;
+
+    while (generated < MAX_NEW_TOKENS and pos < MAX_SEQ_LEN) {
+        const logits_copy = allocator.alloc(f32, Config.vocab_size) catch return out_pos;
+        defer allocator.free(logits_copy);
+        @memcpy(logits_copy, fwd_state.logits);
+        const next_token = g_sampler.sample(logits_copy);
+
+        if (next_token == Config.eos_token_id or next_token == Config.im_end_id) break;
+
+        // Decode token to bytes
+        const byte_len = tokenizer.decodeToBytes(next_token, &decode_tmp);
+        if (byte_len > 0 and out_pos + byte_len <= out_buf.len) {
+            @memcpy(out_buf[out_pos .. out_pos + byte_len], decode_tmp[0..byte_len]);
+            out_pos += byte_len;
+        }
+
+        _ = inference_model.forward(weights, model_cache, fwd_state, next_token, pos);
+        pos += 1;
+        generated += 1;
+    }
+
+    return out_pos;
+}
+```
+
+**Step 3: Update WASM exports**
+
+Replace the `init` export:
+
+```zig
+/// Initialize model from Q4MF weight data and tokenizer JSON.
+/// For WASM: JS passes pointers from IndexedDB blobs.
+/// For native: called from CLI after reading files.
+export fn init(weights_ptr: [*]const u8, weights_len: u32) bool {
+    return initFromData(weights_ptr[0..weights_len], null, null);
+}
+
+/// Extended init that also loads tokenizer from raw JSON bytes.
+export fn init_with_tokenizer(
+    weights_ptr: [*]const u8,
+    weights_len: u32,
+    tok_ptr: [*]const u8,
+    tok_len: u32,
+) bool {
+    return initFromData(weights_ptr[0..weights_len], tok_ptr, tok_len);
+}
+
+fn initFromData(weights_data: []const u8, tok_ptr: ?[*]const u8, tok_len: ?u32) bool {
+    const allocator = getAllocator();
+
+    // Load tokenizer
+    if (tok_ptr) |tp| {
+        if (tok_len) |tl| {
+            g_tokenizer = inference_tokenizer.Tokenizer.loadFromJson(allocator, tp[0..tl]) catch return false;
+        }
+    }
+
+    // Load Q4 weights
+    g_weights = inference_model.loadWeightsQ4(allocator, weights_data, MAX_SEQ_LEN) catch return false;
+
+    // Initialize cache and forward state
+    g_cache = inference_kv_cache.ModelCache.init(allocator, MAX_SEQ_LEN) catch return false;
+    g_fwd_state = inference_model.ForwardState.init(allocator) catch return false;
+
+    return true;
+}
+```
+
+Replace the `neutralize` export:
+
+```zig
+/// Full neutralization: extract markers, run model, verify.
+export fn neutralize(text_ptr: [*]const u8, text_len: u32) bool {
+    const text = text_ptr[0..text_len];
+    const allocator = getAllocator();
+
+    // If model not loaded, fall back to profile-only
+    if (g_weights == null or g_tokenizer == null) {
+        return profile(text_ptr, text_len);
+    }
+
+    const result = rewrite.neutralize(text, inferenceAdapter, allocator) catch {
+        // Fall back to profile on error
+        return profile(text_ptr, text_len);
+    };
+
+    // Serialize result to JSON
+    var jw = json.JsonWriter.init(&output_buf);
+    jw.objectBegin();
+
+    jw.key("clean_text");
+    jw.stringValue(result.clean_text);
+    jw.key("markers_found");
+    jw.intValue(result.markers_found);
+    jw.key("markers_fixed");
+    jw.intValue(result.markers_fixed);
+    jw.key("deviation_before");
+    jw.floatValue(result.deviation_before);
+    jw.key("deviation_after");
+    jw.floatValue(result.deviation_after);
+
+    jw.objectEnd();
+    output_len = @intCast(jw.written().len);
+    return true;
+}
+```
+
+**Step 4: Build both targets**
+
+```bash
+cd /home/christian/dev/klearu/klearu-sdc/fantasma-zig
+zig build test 2>&1 | tail -5
+# Expected: all tests pass
+
+zig build 2>&1 | tail -5
+# Expected: native build succeeds
+
+zig build wasm 2>&1 | tail -5
+# Expected: WASM build succeeds (inference now compiles for wasm32)
+```
+
+**Step 5: Integration test with native CLI**
+
+```bash
+# Generate with Q4 model through the full pipeline
+./zig-out/bin/fantasma generate QwenTheBard "The quick brown fox jumps over the lazy dog."
+# Expected: generates text (verifies Q4 + SIMD + inference works end-to-end)
+```
+
+**Step 6: Commit**
+
+```bash
+git add src/main.zig
+git commit -m "feat: wire inference into rewrite pipeline, enable WASM inference"
+```
+
+---
+
+### Task 6: Verify WASM Build Size and Update .gitignore
+
+**Files:**
+- Modify: `.gitignore`
+
+**Step 1: Check WASM binary size**
+
+```bash
+cd /home/christian/dev/klearu/klearu-sdc/fantasma-zig
+zig build wasm
+ls -lh zig-out/bin/fantasma.wasm
+# Expected: larger than before (~27KB) but reasonable (< 200KB without weights)
+```
+
+**Step 2: Update .gitignore for Q4 weights**
+
+Add to `.gitignore`:
+
+```
+# Model weights
+QwenTheBard/model.q4
+*.q4
+```
+
+**Step 3: Commit**
+
+```bash
+git add .gitignore
+git commit -m "chore: add Q4 weights to gitignore"
+```
+
+---
+
+## Verification Checklist
+
+After all tasks are complete, verify:
+
+1. `python3 scripts/convert_q4.py` produces `QwenTheBard/model.q4` (~400MB)
+2. `zig build test` — all unit tests pass
+3. `zig build` — native build succeeds
+4. `zig build wasm` — WASM build succeeds with inference included
+5. `./zig-out/bin/fantasma generate QwenTheBard "Hello"` — generates with Q4 model
+6. Compare Q4 vs BF16 output: run same prompt with both, outputs should be similar quality

src/inference/kv_cache.zig

···
+const std = @import("std");
+
+// ============================================================
+// Model configuration constants (Qwen3.5-0.8B)
+// ============================================================
+pub const Config = struct {
+    pub const vocab_size: u32 = 248320;
+    pub const hidden_size: u32 = 1024;
+    pub const num_layers: u32 = 24;
+    pub const rms_norm_eps: f32 = 1e-6;
+
+    // Full attention config
+    pub const num_attention_heads: u32 = 8; // query heads (actual, not including gate)
+    pub const num_kv_heads: u32 = 2;
+    pub const head_dim: u32 = 256;
+    pub const attn_output_dim: u32 = num_attention_heads * head_dim; // 2048
+
+    // RoPE
+    pub const partial_rotary_factor: f32 = 0.25;
+    pub const rotary_dim: u32 = @intFromFloat(@as(f32, head_dim) * partial_rotary_factor); // 64
+    pub const rope_theta: f32 = 10_000_000.0;
+    pub const mrope_section: [3]u32 = .{ 11, 11, 10 }; // total = 32 = rotary_dim/2
+
+    // GatedDeltaNet (linear attention) config
+    pub const linear_num_heads: u32 = 16;
+    pub const linear_key_head_dim: u32 = 128;
+    pub const linear_value_head_dim: u32 = 128;
+    pub const linear_key_dim: u32 = linear_num_heads * linear_key_head_dim; // 2048
+    pub const linear_value_dim: u32 = linear_num_heads * linear_value_head_dim; // 2048
+    pub const linear_conv_dim: u32 = linear_key_dim * 2 + linear_value_dim; // 6144
+    pub const linear_conv_kernel: u32 = 4;
+
+    // MLP
+    pub const intermediate_size: u32 = 3584;
+
+    // Special tokens
+    pub const eos_token_id: u32 = 248046; // <|im_end|>
+    pub const im_start_id: u32 = 248045;
+    pub const im_end_id: u32 = 248046;
+
+    // Layer types: false = linear_attention, true = full_attention
+    pub const layer_is_full_attn: [num_layers]bool = .{
+        false, false, false, true,  // 0-3
+        false, false, false, true,  // 4-7
+        false, false, false, true,  // 8-11
+        false, false, false, true,  // 12-15
+        false, false, false, true,  // 16-19
+        false, false, false, true,  // 20-23
+    };
+};
+
+// ============================================================
+// Cache for autoregressive generation
+// ============================================================
+
+/// KV cache for full attention layers.
+/// Stores key and value vectors for all past positions.
+pub const KVCache = struct {
+    /// [max_seq_len][num_kv_heads * head_dim]
+    keys: []f32,
+    /// [max_seq_len][num_kv_heads * head_dim]
+    values: []f32,
+    len: u32,
+    max_len: u32,
+
+    pub fn init(allocator: std.mem.Allocator, max_seq_len: u32) !KVCache {
+        const kv_dim = Config.num_kv_heads * Config.head_dim;
+        return .{
+            .keys = try allocator.alloc(f32, max_seq_len * kv_dim),
+            .values = try allocator.alloc(f32, max_seq_len * kv_dim),
+            .len = 0,
+            .max_len = max_seq_len,
+        };
+    }
+
+    pub fn deinit(self: *KVCache, allocator: std.mem.Allocator) void {
+        allocator.free(self.keys);
+        allocator.free(self.values);
+    }
+
+    /// Append a new key/value pair for the current position.
+    pub fn append(self: *KVCache, key: []const f32, value: []const f32) void {
+        const kv_dim = Config.num_kv_heads * Config.head_dim;
+        const offset = self.len * kv_dim;
+        @memcpy(self.keys[offset .. offset + kv_dim], key);
+        @memcpy(self.values[offset .. offset + kv_dim], value);
+        self.len += 1;
+    }
+
+    /// Get the key vector at a given position.
+    pub fn getKey(self: *const KVCache, pos: u32) []const f32 {
+        const kv_dim = Config.num_kv_heads * Config.head_dim;
+        const offset = pos * kv_dim;
+        return self.keys[offset .. offset + kv_dim];
+    }
+
+    /// Get the value vector at a given position.
+    pub fn getValue(self: *const KVCache, pos: u32) []const f32 {
+        const kv_dim = Config.num_kv_heads * Config.head_dim;
+        const offset = pos * kv_dim;
+        return self.values[offset .. offset + kv_dim];
+    }
+
+    pub fn reset(self: *KVCache) void {
+        self.len = 0;
+    }
+};
+
+/// Recurrent state for GatedDeltaNet (linear attention) layers.
+/// Stores the recurrent state matrix S[num_heads][key_dim][value_dim]
+/// and the conv1d state buffer.
+pub const DeltaNetState = struct {
+    /// Recurrent state: [num_heads * key_dim * value_dim]
+    recurrent: []f32,
+    /// Conv1d state: [conv_dim * (kernel_size - 1)]
+    conv_state: []f32,
+
+    pub fn init(allocator: std.mem.Allocator) !DeltaNetState {
+        const state_size = Config.linear_num_heads * Config.linear_key_head_dim * Config.linear_value_head_dim;
+        const conv_size = Config.linear_conv_dim * (Config.linear_conv_kernel - 1);
+        const recurrent = try allocator.alloc(f32, state_size);
+        const conv_state = try allocator.alloc(f32, conv_size);
+        @memset(recurrent, 0.0);
+        @memset(conv_state, 0.0);
+        return .{
+            .recurrent = recurrent,
+            .conv_state = conv_state,
+        };
+    }
+
+    pub fn deinit(self: *DeltaNetState, allocator: std.mem.Allocator) void {
+        allocator.free(self.recurrent);
+        allocator.free(self.conv_state);
+    }
+
+    pub fn reset(self: *DeltaNetState) void {
+        @memset(self.recurrent, 0.0);
+        @memset(self.conv_state, 0.0);
+    }
+
+    /// Get a mutable slice of the recurrent state for a given head.
+    /// Returns [key_dim][value_dim] as a flat slice of length key_dim * value_dim.
+    pub fn getHeadState(self: *DeltaNetState, head: u32) []f32 {
+        const head_state_size = Config.linear_key_head_dim * Config.linear_value_head_dim;
+        const offset = head * head_state_size;
+        return self.recurrent[offset .. offset + head_state_size];
+    }
+};
+
+/// Combined cache for all layers.
+pub const ModelCache = struct {
+    kv_caches: [Config.num_layers]?KVCache,
+    delta_states: [Config.num_layers]?DeltaNetState,
+
+    pub fn init(allocator: std.mem.Allocator, max_seq_len: u32) !ModelCache {
+        var cache = ModelCache{
+            .kv_caches = .{null} ** Config.num_layers,
+            .delta_states = .{null} ** Config.num_layers,
+        };
+
+        for (0..Config.num_layers) |i| {
+            if (Config.layer_is_full_attn[i]) {
+                cache.kv_caches[i] = try KVCache.init(allocator, max_seq_len);
+            } else {
+                cache.delta_states[i] = try DeltaNetState.init(allocator);
+            }
+        }
+
+        return cache;
+    }
+
+    pub fn deinit(self: *ModelCache, allocator: std.mem.Allocator) void {
+        for (0..Config.num_layers) |i| {
+            if (self.kv_caches[i]) |*kv| kv.deinit(allocator);
+            if (self.delta_states[i]) |*ds| ds.deinit(allocator);
+        }
+    }
+
+    pub fn reset(self: *ModelCache) void {
+        for (0..Config.num_layers) |i| {
+            if (self.kv_caches[i]) |*kv| kv.reset();
+            if (self.delta_states[i]) |*ds| ds.reset();
+        }
+    }
+};
+
+test "kv cache append and retrieve" {
+    const allocator = std.testing.allocator;
+    var kv = try KVCache.init(allocator, 16);
+    defer kv.deinit(allocator);
+
+    var key: [Config.num_kv_heads * Config.head_dim]f32 = undefined;
+    var value: [Config.num_kv_heads * Config.head_dim]f32 = undefined;
+    @memset(&key, 1.0);
+    @memset(&value, 2.0);
+
+    kv.append(&key, &value);
+    try std.testing.expectEqual(@as(u32, 1), kv.len);
+
+    const retrieved_k = kv.getKey(0);
+    try std.testing.expectEqual(@as(f32, 1.0), retrieved_k[0]);
+}

src/inference/model.zig

···
+const std = @import("std");
+const q = @import("quantized.zig");
+const cache = @import("kv_cache.zig");
+const Config = cache.Config;
+const Tensor = q.Tensor;
+
+// ============================================================
+// Model weight structure
+// ============================================================
+
+/// Weights for a full attention layer
+const FullAttentionWeights = struct {
+    q_proj: Tensor, // [num_heads * head_dim * 2, hidden_size] (includes gate)
+    k_proj: Tensor, // [num_kv_heads * head_dim, hidden_size]
+    v_proj: Tensor, // [num_kv_heads * head_dim, hidden_size]
+    o_proj: Tensor, // [hidden_size, num_heads * head_dim]
+    q_norm: Tensor, // [head_dim]
+    k_norm: Tensor, // [head_dim]
+};
+
+/// Weights for a GatedDeltaNet (linear attention) layer
+const DeltaNetWeights = struct {
+    in_proj_qkv: Tensor, // [conv_dim, hidden_size]
+    in_proj_z: Tensor, // [value_dim, hidden_size]
+    in_proj_a: Tensor, // [num_heads, hidden_size]
+    in_proj_b: Tensor, // [num_heads, hidden_size]
+    conv1d: Tensor, // [conv_dim, 1, kernel_size]
+    A_log: Tensor, // [num_heads] (F32)
+    dt_bias: Tensor, // [num_heads]
+    norm: Tensor, // [value_head_dim] (F32)
+    out_proj: Tensor, // [hidden_size, value_dim]
+};
+
+/// Weights for a single decoder layer
+const LayerWeights = struct {
+    input_layernorm: Tensor, // [hidden_size]
+    post_attention_layernorm: Tensor, // [hidden_size]
+
+    // Attention (one of these is active)
+    full_attn: ?FullAttentionWeights,
+    delta_net: ?DeltaNetWeights,
+
+    // MLP
+    gate_proj: Tensor, // [intermediate_size, hidden_size]
+    up_proj: Tensor, // [intermediate_size, hidden_size]
+    down_proj: Tensor, // [hidden_size, intermediate_size]
+};
+
+/// Complete model weights
+pub const ModelWeights = struct {
+    embed_tokens: Tensor, // [vocab_size, hidden_size]
+    norm: Tensor, // [hidden_size]
+    layers: [Config.num_layers]LayerWeights,
+
+    // RoPE precomputed cos/sin tables
+    rope_cos: []f32, // [max_seq_len, rotary_dim]
+    rope_sin: []f32, // [max_seq_len, rotary_dim]
+
+    allocator: std.mem.Allocator,
+};
+
+// ============================================================
+// Weight loading from safetensors
+// ============================================================
+
+pub fn loadWeights(allocator: std.mem.Allocator, model_dir: []const u8, max_seq_len: u32) !ModelWeights {
+    // Build path to safetensors file
+    var path_buf: [1024]u8 = undefined;
+    const path = std.fmt.bufPrint(&path_buf, "{s}/model.safetensors-00001-of-00001.safetensors", .{model_dir}) catch return error.PathTooLong;
+
+    // Memory-map the file
+    const file = try std.fs.cwd().openFile(path, .{});
+    defer file.close();
+    const file_size = try file.getEndPos();
+
+    // Read entire file into memory (mmap would be better but this works cross-platform)
+    const file_data = try allocator.alloc(u8, file_size);
+    // Note: we don't free file_data — it backs all tensor views for the model lifetime
+    const bytes_read = try file.readAll(file_data);
+    if (bytes_read != file_size) return error.IncompleteRead;
+
+    // Parse safetensors header
+    var tensor_infos: [512]q.TensorInfo = undefined;
+    const header = try q.parseSafetensorsHeader(file_data, &tensor_infos);
+
+    // Helper: find tensor by name
+    const infos = tensor_infos[0..header.count];
+
+    var weights: ModelWeights = undefined;
+    weights.allocator = allocator;
+
+    // Embedding
+    weights.embed_tokens = try findAndLoad(infos, "model.language_model.embed_tokens.weight", file_data);
+    weights.norm = try findAndLoad(infos, "model.language_model.norm.weight", file_data);
+
+    // Layers
+    for (0..Config.num_layers) |layer_idx| {
+        var lw: LayerWeights = undefined;
+
+        // Layer norms
+        lw.input_layernorm = try findAndLoadLayer(infos, layer_idx, "input_layernorm.weight", file_data);
+        lw.post_attention_layernorm = try findAndLoadLayer(infos, layer_idx, "post_attention_layernorm.weight", file_data);
+
+        // MLP
+        lw.gate_proj = try findAndLoadLayer(infos, layer_idx, "mlp.gate_proj.weight", file_data);
+        lw.up_proj = try findAndLoadLayer(infos, layer_idx, "mlp.up_proj.weight", file_data);
+        lw.down_proj = try findAndLoadLayer(infos, layer_idx, "mlp.down_proj.weight", file_data);
+
+        if (Config.layer_is_full_attn[layer_idx]) {
+            lw.full_attn = FullAttentionWeights{
+                .q_proj = try findAndLoadLayer(infos, layer_idx, "self_attn.q_proj.weight", file_data),
+                .k_proj = try findAndLoadLayer(infos, layer_idx, "self_attn.k_proj.weight", file_data),
+                .v_proj = try findAndLoadLayer(infos, layer_idx, "self_attn.v_proj.weight", file_data),
+                .o_proj = try findAndLoadLayer(infos, layer_idx, "self_attn.o_proj.weight", file_data),
+                .q_norm = try findAndLoadLayer(infos, layer_idx, "self_attn.q_norm.weight", file_data),
+                .k_norm = try findAndLoadLayer(infos, layer_idx, "self_attn.k_norm.weight", file_data),
+            };
+            lw.delta_net = null;
+        } else {
+            lw.delta_net = DeltaNetWeights{
+                .in_proj_qkv = try findAndLoadLayer(infos, layer_idx, "linear_attn.in_proj_qkv.weight", file_data),
+                .in_proj_z = try findAndLoadLayer(infos, layer_idx, "linear_attn.in_proj_z.weight", file_data),
+                .in_proj_a = try findAndLoadLayer(infos, layer_idx, "linear_attn.in_proj_a.weight", file_data),
+                .in_proj_b = try findAndLoadLayer(infos, layer_idx, "linear_attn.in_proj_b.weight", file_data),
+                .conv1d = try findAndLoadLayer(infos, layer_idx, "linear_attn.conv1d.weight", file_data),
+                .A_log = try findAndLoadLayer(infos, layer_idx, "linear_attn.A_log", file_data),
+                .dt_bias = try findAndLoadLayer(infos, layer_idx, "linear_attn.dt_bias", file_data),
+                .norm = try findAndLoadLayer(infos, layer_idx, "linear_attn.norm.weight", file_data),
+                .out_proj = try findAndLoadLayer(infos, layer_idx, "linear_attn.out_proj.weight", file_data),
+            };
+            lw.full_attn = null;
+        }
+
+        weights.layers[layer_idx] = lw;
+    }
+
+    // Precompute RoPE cos/sin tables
+    const rotary_dim = Config.rotary_dim;
+    weights.rope_cos = try allocator.alloc(f32, max_seq_len * rotary_dim);
+    weights.rope_sin = try allocator.alloc(f32, max_seq_len * rotary_dim);
+
+    // inv_freq = 1 / (theta ^ (2i / dim)) for i in 0..dim/2
+    // HuggingFace layout: emb = cat(freqs, freqs) → [f0,f1,...,f31,f0,f1,...,f31]
+    const half_dim = rotary_dim / 2;
+    for (0..max_seq_len) |pos| {
+        for (0..half_dim) |i| {
+            const freq = 1.0 / std.math.pow(f32, Config.rope_theta, @as(f32, @floatFromInt(2 * i)) / @as(f32, @floatFromInt(rotary_dim)));
+            const angle = @as(f32, @floatFromInt(pos)) * freq;
+            const cos_val = @cos(angle);
+            const sin_val = @sin(angle);
+            // First half and second half are identical (cat(freqs, freqs))
+            weights.rope_cos[pos * rotary_dim + i] = cos_val;
+            weights.rope_cos[pos * rotary_dim + half_dim + i] = cos_val;
+            weights.rope_sin[pos * rotary_dim + i] = sin_val;
+            weights.rope_sin[pos * rotary_dim + half_dim + i] = sin_val;
+        }
+    }
+
+    return weights;
+}
+
+fn findAndLoad(infos: []const q.TensorInfo, name: []const u8, file_data: []const u8) !Tensor {
+    for (infos) |*info| {
+        if (std.mem.eql(u8, info.name, name)) {
+            return try q.tensorFromInfo(info, file_data);
+        }
+    }
+    return q.SafetensorsError.TensorNotFound;
+}
+
+fn findAndLoadLayer(infos: []const q.TensorInfo, layer_idx: usize, suffix: []const u8, file_data: []const u8) !Tensor {
+    var name_buf: [256]u8 = undefined;
+    const name = std.fmt.bufPrint(&name_buf, "model.language_model.layers.{d}.{s}", .{ layer_idx, suffix }) catch return error.PathTooLong;
+    return findAndLoad(infos, name, file_data);
+}
+
+// ============================================================
+// Forward pass - single token
+// ============================================================
+
+/// Scratch buffers for a single forward pass
+pub const ForwardState = struct {
+    hidden: [Config.hidden_size]f32,
+    residual: [Config.hidden_size]f32,
+    normed: [Config.hidden_size]f32,
+
+    // Attention temporaries
+    q_buf: [Config.num_attention_heads * Config.head_dim * 2]f32, // includes gate
+    k_buf: [Config.num_kv_heads * Config.head_dim]f32,
+    v_buf: [Config.num_kv_heads * Config.head_dim]f32,
+    attn_out: [Config.attn_output_dim]f32,
+
+    // DeltaNet temporaries
+    dn_qkv: [Config.linear_conv_dim]f32,
+    dn_z: [Config.linear_value_dim]f32,
+    dn_a: [Config.linear_num_heads]f32,
+    dn_b: [Config.linear_num_heads]f32,
+    dn_out: [Config.linear_value_dim]f32,
+
+    // MLP temporaries
+    mlp_gate: [Config.intermediate_size]f32,
+    mlp_up: [Config.intermediate_size]f32,
+    mlp_down: [Config.hidden_size]f32,
+
+    // Logits (reuses space since it's only needed at the end)
+    logits: []f32,
+
+    allocator: std.mem.Allocator,
+
+    pub fn init(allocator: std.mem.Allocator) !ForwardState {
+        var state: ForwardState = undefined;
+        state.allocator = allocator;
+        state.logits = try allocator.alloc(f32, Config.vocab_size);
+        return state;
+    }
+
+    pub fn deinit(self: *ForwardState) void {
+        self.allocator.free(self.logits);
+    }
+};
+
+/// Run a single forward pass for one token.
+/// Returns logits over the vocabulary.
+pub fn forward(
+    weights: *const ModelWeights,
+    model_cache: *cache.ModelCache,
+    state: *ForwardState,
+    token: u32,
+    pos: u32,
+) []f32 {
+    // 1. Embedding lookup
+    const embed_offset = @as(usize, token) * Config.hidden_size;
+    for (0..Config.hidden_size) |i| {
+        state.hidden[i] = weights.embed_tokens.get(embed_offset + i);
+    }
+
+    // 2. Process each layer
+    for (0..Config.num_layers) |layer_idx| {
+        const lw = &weights.layers[layer_idx];
+
+        // Save residual
+        @memcpy(&state.residual, &state.hidden);
+
+        // Pre-attention RMSNorm
+        q.rmsNorm(&state.normed, &state.hidden, &lw.input_layernorm, Config.rms_norm_eps);
+
+        // Attention (full or delta)
+        if (Config.layer_is_full_attn[layer_idx]) {
+            fullAttentionForward(weights, lw, &model_cache.kv_caches[layer_idx].?, state, pos);
+        } else {
+            deltaNetForward(lw, &model_cache.delta_states[layer_idx].?, state);
+        }
+
+        // Residual connection
+        for (0..Config.hidden_size) |i| {
+            state.hidden[i] = state.residual[i] + state.hidden[i];
+        }
+
+        // Save residual for MLP
+        @memcpy(&state.residual, &state.hidden);
+
+        // Pre-MLP RMSNorm
+        q.rmsNorm(&state.normed, &state.hidden, &lw.post_attention_layernorm, Config.rms_norm_eps);
+
+        // MLP (SwiGLU)
+        mlpForward(lw, state);
+
+        // Residual connection
+        for (0..Config.hidden_size) |i| {
+            state.hidden[i] = state.residual[i] + state.hidden[i];
+        }
+    }
+
+    // 3. Final RMSNorm
+    q.rmsNorm(&state.normed, &state.hidden, &weights.norm, Config.rms_norm_eps);
+
+    // 4. LM head (tied weights: logits = embed_tokens^T @ normed)
+    // embed_tokens is [vocab_size, hidden_size], so each row is a token embedding
+    for (0..Config.vocab_size) |i| {
+        state.logits[i] = weights.embed_tokens.dot(i * Config.hidden_size, &state.normed);
+    }
+
+    return state.logits;
+}
+
+// ============================================================
+// Full Attention (GQA with output gate + QK-norm + partial RoPE)
+// ============================================================
+
+fn fullAttentionForward(
+    weights: *const ModelWeights,
+    lw: *const LayerWeights,
+    kv: *cache.KVCache,
+    state: *ForwardState,
+    pos: u32,
+) void {
+    const attn = &lw.full_attn.?;
+    const num_heads = Config.num_attention_heads;
+    const num_kv_heads = Config.num_kv_heads;
+    const head_dim = Config.head_dim;
+    const kv_groups = num_heads / num_kv_heads;
+    const rotary_dim = Config.rotary_dim;
+
+    // Project Q (includes gate), K, V
+    q.matVec(&attn.q_proj, &state.normed, &state.q_buf);
+    q.matVec(&attn.k_proj, &state.normed, &state.k_buf);
+    q.matVec(&attn.v_proj, &state.normed, &state.v_buf);
+
+    // Split Q into query and gate: q_buf has [num_heads * head_dim * 2]
+    // Organized as [num_heads][head_dim * 2], split each head's output into q and gate
+    var gate_buf: [Config.attn_output_dim]f32 = undefined;
+    for (0..num_heads) |h| {
+        const src_offset = h * head_dim * 2;
+        const dst_offset = h * head_dim;
+        // First head_dim elements are query, second head_dim are gate
+        for (0..head_dim) |d| {
+            state.attn_out[dst_offset + d] = state.q_buf[src_offset + d]; // query
+            gate_buf[dst_offset + d] = state.q_buf[src_offset + head_dim + d]; // gate
+        }
+    }
+    // Now state.attn_out[0..num_heads*head_dim] = query, gate_buf = gate
+    // Copy query back (we'll use attn_out for the final output later)
+    var query: [Config.attn_output_dim]f32 = undefined;
+    @memcpy(&query, &state.attn_out);
+
+    // QK-norm: normalize each head's Q and K with RMSNorm
+    for (0..num_heads) |h| {
+        const offset = h * head_dim;
+        q.rmsNorm(
+            query[offset .. offset + head_dim],
+            query[offset .. offset + head_dim],
+            &attn.q_norm,
+            Config.rms_norm_eps,
+        );
+    }
+    for (0..num_kv_heads) |h| {
+        const offset = h * head_dim;
+        q.rmsNorm(
+            state.k_buf[offset .. offset + head_dim],
+            state.k_buf[offset .. offset + head_dim],
+            &attn.k_norm,
+            Config.rms_norm_eps,
+        );
+    }
+
+    // Apply partial RoPE to query and key
+    const cos = weights.rope_cos[pos * rotary_dim .. (pos + 1) * rotary_dim];
+    const sin = weights.rope_sin[pos * rotary_dim .. (pos + 1) * rotary_dim];
+
+    for (0..num_heads) |h| {
+        applyRope(query[h * head_dim ..][0..head_dim], cos, sin, rotary_dim);
+    }
+    for (0..num_kv_heads) |h| {
+        applyRope(state.k_buf[h * head_dim ..][0..head_dim], cos, sin, rotary_dim);
+    }
+
+    // Store K, V in cache
+    kv.append(&state.k_buf, &state.v_buf);
+
+    // Compute attention for each query head
+    const scale = 1.0 / @sqrt(@as(f32, @floatFromInt(head_dim)));
+    const seq_len = kv.len;
+
+    for (0..num_heads) |h| {
+        const kv_h = h / kv_groups; // which KV head this query head uses
+        const q_offset = h * head_dim;
+
+        // Dot product with all cached keys
+        var max_score: f32 = -std.math.inf(f32);
+
+        // We need a temporary for attention scores
+        // Use mlp_gate as scratch (it's big enough for seq_len <= intermediate_size)
+        const scores = state.mlp_gate[0..seq_len];
+
+        for (0..seq_len) |t| {
+            const cached_k = kv.getKey(@intCast(t));
+            const k_head = cached_k[kv_h * head_dim .. (kv_h + 1) * head_dim];
+
+            var score: f32 = 0.0;
+            for (0..head_dim) |d| {
+                score += query[q_offset + d] * k_head[d];
+            }
+            score *= scale;
+            scores[t] = score;
+            if (score > max_score) max_score = score;
+        }
+
+        // Softmax
+        var sum_exp: f32 = 0.0;
+        for (scores) |*s| {
+            s.* = @exp(s.* - max_score);
+            sum_exp += s.*;
+        }
+        if (sum_exp > 0.0) {
+            const inv_sum = 1.0 / sum_exp;
+            for (scores) |*s| {
+                s.* *= inv_sum;
+            }
+        }
+
+        // Weighted sum of values
+        const out_offset = h * head_dim;
+        @memset(state.attn_out[out_offset .. out_offset + head_dim], 0.0);
+        for (0..seq_len) |t| {
+            const cached_v = kv.getValue(@intCast(t));
+            const v_head = cached_v[kv_h * head_dim .. (kv_h + 1) * head_dim];
+            const w = scores[t];
+            for (0..head_dim) |d| {
+                state.attn_out[out_offset + d] += w * v_head[d];
+            }
+        }
+    }
+
+    // Apply output gate: attn_out *= sigmoid(gate)
+    for (0..Config.attn_output_dim) |i| {
+        state.attn_out[i] *= q.sigmoid(gate_buf[i]);
+    }
+
+    // Flatten gate to [batch, seq, num_heads * head_dim] and reshape as needed
+    // Already in the right shape. The gate_buf reshape in Python is:
+    //   gate = gate.reshape(*input_shape, -1)  # flatten across heads
+    // Our gate_buf is already [num_heads * head_dim] = [2048]
+
+    // Output projection: hidden = o_proj @ attn_out
+    q.matVec(&attn.o_proj, &state.attn_out, &state.hidden);
+}
+
+/// Apply rotary position embedding to the first rotary_dim elements of x.
+/// x is [head_dim], only first rotary_dim elements are rotated.
+fn applyRope(x: []f32, cos: []const f32, sin: []const f32, rotary_dim: u32) void {
+    // RoPE: for pairs (x[2i], x[2i+1]):
+    //   x'[2i]   = x[2i] * cos[2i]   - x[2i+1] * sin[2i]
+    //   x'[2i+1] = x[2i] * sin[2i+1] + x[2i+1] * cos[2i+1]
+    // Wait — HuggingFace uses rotate_half style: split in half, not interleaved.
+    // rotate_half: x1 = x[..dim//2], x2 = x[dim//2..], return cat(-x2, x1)
+    // So: x_embed = x * cos + rotate_half(x) * sin
+    const half = rotary_dim / 2;
+    var i: usize = 0;
+    while (i < half) : (i += 1) {
+        const x0 = x[i];
+        const x1 = x[i + half];
+        // cos/sin are [rotary_dim], duplicated as [cos0,cos0,cos1,cos1,...]
+        // But with rotate_half convention:
+        // x_embed[i] = x[i] * cos[i] + (-x[i+half]) * sin[i]
+        // x_embed[i+half] = x[i+half] * cos[i+half] + x[i] * sin[i+half]
+        x[i] = x0 * cos[i] - x1 * sin[i];
+        x[i + half] = x1 * cos[i + half] + x0 * sin[i + half];
+    }
+}
+
+// ============================================================
+// GatedDeltaNet (linear attention) - recurrent mode
+// ============================================================
+
+fn deltaNetForward(
+    lw: *const LayerWeights,
+    delta_state: *cache.DeltaNetState,
+    state: *ForwardState,
+) void {
+    const dn = &lw.delta_net.?;
+    const num_heads = Config.linear_num_heads;
+    const key_dim = Config.linear_key_head_dim;
+    const value_dim = Config.linear_value_head_dim;
+    const conv_dim = Config.linear_conv_dim;
+    const kernel_size = Config.linear_conv_kernel;
+
+    // 1. Project QKV
+    q.matVec(&dn.in_proj_qkv, &state.normed, &state.dn_qkv);
+
+    // 2. Project Z (gate), A, B
+    q.matVec(&dn.in_proj_z, &state.normed, &state.dn_z);
+    q.matVec(&dn.in_proj_a, &state.normed, &state.dn_a);
+    q.matVec(&dn.in_proj_b, &state.normed, &state.dn_b);
+
+    // 3. Causal conv1d update (single step)
+    // conv_state is [conv_dim, kernel_size - 1], stored as [conv_dim][state_cols]
+    // Full window = [conv_state..., new_input] = kernel_size values
+    // Must compute conv BEFORE updating state
+    const state_cols = kernel_size - 1;
+    for (0..conv_dim) |ch| {
+        const cs_base = ch * state_cols;
+
+        // Compute depthwise convolution: dot(window, weight)
+        // window = [conv_state[0], conv_state[1], conv_state[2], new_input]
+        var conv_out: f32 = 0.0;
+        for (0..state_cols) |k| {
+            conv_out += delta_state.conv_state[cs_base + k] * dn.conv1d.get(ch * kernel_size + k);
+        }
+        conv_out += state.dn_qkv[ch] * dn.conv1d.get(ch * kernel_size + state_cols);
+
+        // Update state: shift left and append new input
+        var j: usize = 0;
+        while (j + 1 < state_cols) : (j += 1) {
+            delta_state.conv_state[cs_base + j] = delta_state.conv_state[cs_base + j + 1];
+        }
+        delta_state.conv_state[cs_base + state_cols - 1] = state.dn_qkv[ch];
+
+        // Apply SiLU activation
+        state.dn_qkv[ch] = q.silu(conv_out);
+    }
+
+    // 4. Split QKV: [key_dim, key_dim, value_dim]
+    const key_total = Config.linear_key_dim; // 2048
+    const q_start: usize = 0;
+    const k_start = key_total;
+    const v_start = key_total * 2;
+
+    // 5. Compute decay g and write gate beta per head
+    // g = -exp(A_log) * softplus(a + dt_bias)
+    // beta = sigmoid(b)
+    var g_vals: [Config.linear_num_heads]f32 = undefined;
+    var beta_vals: [Config.linear_num_heads]f32 = undefined;
+    for (0..num_heads) |h| {
+        const a_log = dn.A_log.get(h);
+        const a_val = state.dn_a[h];
+        const dt_b = dn.dt_bias.get(h);
+        g_vals[h] = -@exp(a_log) * q.softplus(a_val + dt_b);
+        beta_vals[h] = q.sigmoid(state.dn_b[h]);
+    }
+
+    // 6. Recurrent delta rule (single step per head)
+    // For each head h:
+    //   q_t = l2norm(qkv[q_start + h*key_dim .. + key_dim])
+    //   k_t = l2norm(qkv[k_start + h*key_dim .. + key_dim])
+    //   v_t = qkv[v_start + h*value_dim .. + value_dim]
+    //   decay = exp(g[h])
+    //   S = S * decay + k_t * (v_t - S^T @ k_t)^T * beta[h]
+    //   output[h] = S^T @ q_t
+    const scale = 1.0 / @sqrt(@as(f32, @floatFromInt(key_dim)));
+
+    for (0..num_heads) |h| {
+        const state_matrix = delta_state.getHeadState(@intCast(h));
+
+        // Extract and L2-normalize Q and K for this head
+        var q_head: [Config.linear_key_head_dim]f32 = undefined;
+        var k_head: [Config.linear_key_head_dim]f32 = undefined;
+
+        @memcpy(&q_head, state.dn_qkv[q_start + h * key_dim ..][0..key_dim]);
+        @memcpy(&k_head, state.dn_qkv[k_start + h * key_dim ..][0..key_dim]);
+
+        q.l2Norm(&q_head);
+        q.l2Norm(&k_head);
+
+        // Scale query
+        for (&q_head) |*qv| {
+            qv.* *= scale;
+        }
+
+        const v_head = state.dn_qkv[v_start + h * value_dim ..][0..value_dim];
+
+        // Decay the state: S *= exp(g)
+        const decay = @exp(g_vals[h]);
+        for (state_matrix) |*s| {
+            s.* *= decay;
+        }
+
+        // Compute kv_mem = S @ k_t (matrix-vector product, S is [key_dim x value_dim])
+        // S is stored as [key_dim][value_dim], so S @ k means: for each value dim v,
+        // sum over key_dim d: S[d][v] * k[d]
+        // Actually, looking at the Python code:
+        //   kv_mem = (last_recurrent_state * k_t.unsqueeze(-1)).sum(dim=-2)
+        // This means: kv_mem[v] = sum_d(S[d,v] * k[d])
+        var kv_mem: [Config.linear_value_head_dim]f32 = undefined;
+        for (0..value_dim) |v| {
+            var sum: f32 = 0.0;
+            for (0..key_dim) |d| {
+                sum += state_matrix[d * value_dim + v] * k_head[d];
+            }
+            kv_mem[v] = sum;
+        }
+
+        // delta = (v_t - kv_mem) * beta
+        var delta: [Config.linear_value_head_dim]f32 = undefined;
+        for (0..value_dim) |v| {
+            delta[v] = (v_head[v] - kv_mem[v]) * beta_vals[h];
+        }
+
+        // Update state: S += k_t * delta^T
+        // S[d,v] += k[d] * delta[v]
+        for (0..key_dim) |d| {
+            for (0..value_dim) |v| {
+                state_matrix[d * value_dim + v] += k_head[d] * delta[v];
+            }
+        }
+
+        // Output: out[v] = sum_d(S[d,v] * q[d])
+        for (0..value_dim) |v| {
+            var sum: f32 = 0.0;
+            for (0..key_dim) |d| {
+                sum += state_matrix[d * value_dim + v] * q_head[d];
+            }
+            state.dn_out[h * value_dim + v] = sum;
+        }
+    }
+
+    // 7. Gated RMS norm: out = rmsNorm(dn_out) * silu(z)
+    // Applied per-head (norm weight is [value_head_dim])
+    for (0..num_heads) |h| {
+        const offset = h * value_dim;
+        q.rmsNormGated(
+            state.dn_out[offset .. offset + value_dim],
+            state.dn_out[offset .. offset + value_dim],
+            state.dn_z[offset .. offset + value_dim],
+            &dn.norm,
+            Config.rms_norm_eps,
+        );
+    }
+
+    // 8. Output projection: hidden = out_proj @ dn_out
+    q.matVec(&dn.out_proj, &state.dn_out, &state.hidden);
+}
+
+// ============================================================
+// SwiGLU MLP
+// ============================================================
+
+fn mlpForward(lw: *const LayerWeights, state: *ForwardState) void {
+    // gate = silu(gate_proj @ normed)
+    // up = up_proj @ normed
+    // hidden = down_proj @ (gate * up)
+    q.matVec(&lw.gate_proj, &state.normed, &state.mlp_gate);
+    q.matVec(&lw.up_proj, &state.normed, &state.mlp_up);
+
+    // gate = silu(gate) * up
+    for (0..Config.intermediate_size) |i| {
+        state.mlp_gate[i] = q.silu(state.mlp_gate[i]) * state.mlp_up[i];
+    }
+
+    // hidden = down_proj @ gate
+    q.matVec(&lw.down_proj, state.mlp_gate[0..Config.intermediate_size], &state.hidden);
+}

src/inference/quantized.zig

···
+const std = @import("std");
+
+/// BF16 to F32 conversion and tensor utilities for weight loading.
+/// Weights are stored as BF16 (u16) and converted to F32 on the fly.
+
+/// Convert a single BF16 value (u16) to F32.
+pub inline fn bf16ToF32(v: u16) f32 {
+    // BF16 is the upper 16 bits of F32
+    const bits: u32 = @as(u32, v) << 16;
+    return @bitCast(bits);
+}
+
+/// Convert a single F32 to BF16 (truncation, no rounding).
+pub inline fn f32ToBf16(v: f32) u16 {
+    const bits: u32 = @bitCast(v);
+    return @intCast(bits >> 16);
+}
+
+/// A view into a weight tensor stored as BF16.
+/// Does not own the data — points into the mmap'd safetensors buffer.
+pub const Tensor = struct {
+    /// Raw BF16 data (u16 elements)
+    data_bf16: ?[]const u16 = null,
+    /// Raw F32 data (some tensors like A_log are stored as F32)
+    data_f32: ?[]const f32 = null,
+    /// Shape dimensions
+    shape: [4]u32 = .{ 0, 0, 0, 0 },
+    /// Number of dimensions
+    ndim: u8 = 0,
+
+    pub fn numel(self: *const Tensor) usize {
+        if (self.ndim == 0) return 0;
+        var n: usize = 1;
+        for (self.shape[0..self.ndim]) |d| {
+            n *= d;
+        }
+        return n;
+    }
+
+    /// Get a single F32 value from the tensor by flat index.
+    pub inline fn get(self: *const Tensor, idx: usize) f32 {
+        if (self.data_f32) |f| return f[idx];
+        if (self.data_bf16) |b| return bf16ToF32(b[idx]);
+        return 0.0;
+    }
+
+    /// Perform dot product: sum(self[offset..offset+len] * other[0..len])
+    /// where self is the weight tensor and other is an f32 slice.
+    pub fn dot(self: *const Tensor, offset: usize, other: []const f32) f32 {
+        const n = other.len;
+        var sum: f32 = 0.0;
+
+        if (self.data_f32) |f| {
+            const slice = f[offset .. offset + n];
+            for (slice, other) |a, b| {
+                sum += a * b;
+            }
+            return sum;
+        }
+
+        if (self.data_bf16) |b| {
+            const slice = b[offset .. offset + n];
+            // Unroll by 4 for performance
+            const n4 = n & ~@as(usize, 3);
+            var i: usize = 0;
+            while (i < n4) : (i += 4) {
+                sum += bf16ToF32(slice[i]) * other[i] +
+                    bf16ToF32(slice[i + 1]) * other[i + 1] +
+                    bf16ToF32(slice[i + 2]) * other[i + 2] +
+                    bf16ToF32(slice[i + 3]) * other[i + 3];
+            }
+            while (i < n) : (i += 1) {
+                sum += bf16ToF32(slice[i]) * other[i];
+            }
+            return sum;
+        }
+
+        return 0.0;
+    }
+};
+
+/// Matrix-vector multiply: out = weight @ input
+/// weight shape: [out_dim, in_dim], input shape: [in_dim], out shape: [out_dim]
+pub fn matVec(weight: *const Tensor, input: []const f32, out: []f32) void {
+    const out_dim = out.len;
+    for (0..out_dim) |i| {
+        out[i] = weight.dot(i * input.len, input);
+    }
+}
+
+/// Matrix-vector multiply and accumulate: out += weight @ input
+pub fn matVecAdd(weight: *const Tensor, input: []const f32, out: []f32) void {
+    const out_dim = out.len;
+    for (0..out_dim) |i| {
+        out[i] += weight.dot(i * input.len, input);
+    }
+}
+
+/// RMS normalization: out = x * rsqrt(mean(x^2) + eps) * (1 + weight)
+/// Qwen3.5 uses (1+weight) scaling since weights are initialized to 0.
+pub fn rmsNorm(out: []f32, x: []const f32, weight: *const Tensor, eps: f32) void {
+    const n = x.len;
+    var sum_sq: f32 = 0.0;
+    for (x) |v| {
+        sum_sq += v * v;
+    }
+    const rms = 1.0 / @sqrt(sum_sq / @as(f32, @floatFromInt(n)) + eps);
+    for (0..n) |i| {
+        out[i] = x[i] * rms * (1.0 + weight.get(i));
+    }
+}
+
+/// RMS normalization with gating: out = rmsNorm(x) * silu(gate)
+/// Used in GatedDeltaNet for the output normalization.
+pub fn rmsNormGated(out: []f32, x: []const f32, gate: []const f32, weight: *const Tensor, eps: f32) void {
+    const n = x.len;
+    var sum_sq: f32 = 0.0;
+    for (x) |v| {
+        sum_sq += v * v;
+    }
+    const rms = 1.0 / @sqrt(sum_sq / @as(f32, @floatFromInt(n)) + eps);
+    for (0..n) |i| {
+        const normed = x[i] * rms * weight.get(i);
+        const g = gate[i];
+        const silu_g = g * sigmoid(g);
+        out[i] = normed * silu_g;
+    }
+}
+
+pub inline fn silu(x: f32) f32 {
+    return x * sigmoid(x);
+}
+
+pub inline fn sigmoid(x: f32) f32 {
+    return 1.0 / (1.0 + @exp(-x));
+}
+
+pub inline fn softplus(x: f32) f32 {
+    return @log(1.0 + @exp(x));
+}
+
+/// L2 normalization of a vector (in-place). Returns the same slice.
+pub fn l2Norm(x: []f32) void {
+    const eps: f32 = 1e-6;
+    var sum_sq: f32 = 0.0;
+    for (x) |v| {
+        sum_sq += v * v;
+    }
+    const inv_norm = 1.0 / @sqrt(sum_sq + eps);
+    for (x) |*v| {
+        v.* *= inv_norm;
+    }
+}
+
+// ============================================================
+// Safetensors parser
+// ============================================================
+
+pub const SafetensorsError = error{
+    InvalidFormat,
+    UnsupportedDtype,
+    TensorNotFound,
+};
+
+pub const TensorInfo = struct {
+    name: []const u8,
+    dtype: []const u8,
+    shape: [4]u32,
+    ndim: u8,
+    data_offset: usize,
+    data_len: usize,
+};
+
+/// Parse safetensors header and return tensor metadata.
+/// The file format is: [8 bytes: header_len LE u64] [header_len bytes: JSON] [raw tensor data]
+pub fn parseSafetensorsHeader(
+    file_data: []const u8,
+    out_tensors: []TensorInfo,
+) SafetensorsError!struct { count: usize, data_start: usize } {
+    if (file_data.len < 8) return SafetensorsError.InvalidFormat;
+
+    const header_len = std.mem.readInt(u64, file_data[0..8], .little);
+    if (8 + header_len > file_data.len) return SafetensorsError.InvalidFormat;
+
+    const data_start = 8 + @as(usize, @intCast(header_len));
+    const header_json = file_data[8..data_start];
+
+    // Parse the JSON header manually (avoid std.json for WASM compat)
+    var count: usize = 0;
+    var pos: usize = 0;
+
+    while (pos < header_json.len and count < out_tensors.len) {
+        // Find next key (tensor name) - skip __metadata__
+        const key_start = findChar(header_json, pos, '"') orelse break;
+        const key_end = findChar(header_json, key_start + 1, '"') orelse break;
+        const key = header_json[key_start + 1 .. key_end];
+        pos = key_end + 1;
+
+        if (std.mem.eql(u8, key, "__metadata__")) {
+            // Skip metadata object
+            pos = skipJsonValue(header_json, pos);
+            continue;
+        }
+
+        // Parse tensor info object
+        const obj_start = findChar(header_json, pos, '{') orelse break;
+        pos = obj_start + 1;
+
+        var info = TensorInfo{
+            .name = key,
+            .dtype = "",
+            .shape = .{ 0, 0, 0, 0 },
+            .ndim = 0,
+            .data_offset = 0,
+            .data_len = 0,
+        };
+
+        // Parse fields within the tensor info object
+        var brace_depth: u32 = 1;
+        while (pos < header_json.len and brace_depth > 0) {
+            if (header_json[pos] == '}') {
+                brace_depth -= 1;
+                pos += 1;
+                continue;
+            }
+
+            const fk_start = findChar(header_json, pos, '"') orelse break;
+            const fk_end = findChar(header_json, fk_start + 1, '"') orelse break;
+            const field_key = header_json[fk_start + 1 .. fk_end];
+            pos = fk_end + 1;
+
+            // Skip colon
+            while (pos < header_json.len and header_json[pos] != ':') pos += 1;
+            pos += 1;
+            while (pos < header_json.len and header_json[pos] == ' ') pos += 1;
+
+            if (std.mem.eql(u8, field_key, "dtype")) {
+                const ds = findChar(header_json, pos, '"') orelse break;
+                const de = findChar(header_json, ds + 1, '"') orelse break;
+                info.dtype = header_json[ds + 1 .. de];
+                pos = de + 1;
+            } else if (std.mem.eql(u8, field_key, "shape")) {
+                // Parse array of ints
+                const arr_start = findChar(header_json, pos, '[') orelse break;
+                const arr_end = findChar(header_json, arr_start, ']') orelse break;
+                var dim_pos = arr_start + 1;
+                while (dim_pos < arr_end and info.ndim < 4) {
+                    while (dim_pos < arr_end and !isDigit(header_json[dim_pos])) dim_pos += 1;
+                    if (dim_pos >= arr_end) break;
+                    var num: u32 = 0;
+                    while (dim_pos < arr_end and isDigit(header_json[dim_pos])) {
+                        num = num * 10 + @as(u32, header_json[dim_pos] - '0');
+                        dim_pos += 1;
+                    }
+                    info.shape[info.ndim] = num;
+                    info.ndim += 1;
+                }
+                pos = arr_end + 1;
+            } else if (std.mem.eql(u8, field_key, "data_offsets")) {
+                // Parse [start, end]
+                const arr_start = findChar(header_json, pos, '[') orelse break;
+                const arr_end = findChar(header_json, arr_start, ']') orelse break;
+                var dim_pos = arr_start + 1;
+                var offsets: [2]usize = .{ 0, 0 };
+                var oi: usize = 0;
+                while (dim_pos < arr_end and oi < 2) {
+                    while (dim_pos < arr_end and !isDigit(header_json[dim_pos])) dim_pos += 1;
+                    if (dim_pos >= arr_end) break;
+                    var num: usize = 0;
+                    while (dim_pos < arr_end and isDigit(header_json[dim_pos])) {
+                        num = num * 10 + @as(usize, header_json[dim_pos] - '0');
+                        dim_pos += 1;
+                    }
+                    offsets[oi] = num;
+                    oi += 1;
+                }
+                info.data_offset = offsets[0];
+                info.data_len = offsets[1] - offsets[0];
+                pos = arr_end + 1;
+            } else {
+                pos = skipJsonValue(header_json, pos);
+            }
+        }
+
+        // Adjust offset relative to data section
+        info.data_offset += data_start;
+
+        out_tensors[count] = info;
+        count += 1;
+    }
+
+    return .{ .count = count, .data_start = data_start };
+}
+
+/// Create a Tensor view from a TensorInfo and the raw file data.
+pub fn tensorFromInfo(info: *const TensorInfo, file_data: []const u8) SafetensorsError!Tensor {
+    var t = Tensor{
+        .shape = info.shape,
+        .ndim = info.ndim,
+    };
+
+    const raw = file_data[info.data_offset .. info.data_offset + info.data_len];
+
+    if (std.mem.eql(u8, info.dtype, "BF16") or std.mem.eql(u8, info.dtype, "bf16")) {
+        const aligned: []align(@alignOf(u16)) const u8 = @alignCast(raw);
+        t.data_bf16 = std.mem.bytesAsSlice(u16, aligned);
+    } else if (std.mem.eql(u8, info.dtype, "F32") or std.mem.eql(u8, info.dtype, "f32")) {
+        const aligned: []align(@alignOf(f32)) const u8 = @alignCast(raw);
+        t.data_f32 = std.mem.bytesAsSlice(f32, aligned);
+    } else {
+        return SafetensorsError.UnsupportedDtype;
+    }
+
+    return t;
+}
+
+fn findChar(buf: []const u8, start: usize, c: u8) ?usize {
+    var i = start;
+    while (i < buf.len) : (i += 1) {
+        if (buf[i] == c and (i == 0 or buf[i - 1] != '\\')) return i;
+    }
+    return null;
+}
+
+fn isDigit(c: u8) bool {
+    return c >= '0' and c <= '9';
+}
+
+fn skipJsonValue(buf: []const u8, start: usize) usize {
+    var pos = start;
+    while (pos < buf.len and (buf[pos] == ' ' or buf[pos] == ':' or buf[pos] == ',')) pos += 1;
+    if (pos >= buf.len) return pos;
+
+    return switch (buf[pos]) {
+        '"' => {
+            // Skip string
+            pos += 1;
+            while (pos < buf.len) : (pos += 1) {
+                if (buf[pos] == '"' and buf[pos - 1] != '\\') return pos + 1;
+            }
+            return pos;
+        },
+        '{' => {
+            var depth: u32 = 1;
+            pos += 1;
+            while (pos < buf.len and depth > 0) : (pos += 1) {
+                if (buf[pos] == '{') depth += 1;
+                if (buf[pos] == '}') depth -= 1;
+            }
+            return pos;
+        },
+        '[' => {
+            var depth: u32 = 1;
+            pos += 1;
+            while (pos < buf.len and depth > 0) : (pos += 1) {
+                if (buf[pos] == '[') depth += 1;
+                if (buf[pos] == ']') depth -= 1;
+            }
+            return pos;
+        },
+        else => {
+            // Number, bool, null
+            while (pos < buf.len and buf[pos] != ',' and buf[pos] != '}' and buf[pos] != ']') pos += 1;
+            return pos;
+        },
+    };
+}
+
+test "bf16 conversion" {
+    // 1.0 in f32 is 0x3F800000, in bf16 is 0x3F80
+    const one = bf16ToF32(0x3F80);
+    try std.testing.expectEqual(@as(f32, 1.0), one);
+
+    const back = f32ToBf16(1.0);
+    try std.testing.expectEqual(@as(u16, 0x3F80), back);
+
+    // 0.0
+    const zero = bf16ToF32(0x0000);
+    try std.testing.expectEqual(@as(f32, 0.0), zero);
+}
+
+test "rms norm" {
+    var x = [_]f32{ 1.0, 2.0, 3.0, 4.0 };
+    var out: [4]f32 = undefined;
+
+    // Weight of all zeros means (1+0)=1 scaling (identity weight)
+    var w_data = [_]f32{ 0.0, 0.0, 0.0, 0.0 };
+    const w = Tensor{ .data_f32 = &w_data, .shape = .{ 4, 0, 0, 0 }, .ndim = 1 };
+
+    rmsNorm(&out, &x, &w, 1e-6);
+
+    // RMS of [1,2,3,4] = sqrt((1+4+9+16)/4) = sqrt(30/4) = sqrt(7.5)
+    const rms_val = @sqrt(30.0 / 4.0);
+    const expected_0 = 1.0 / rms_val;
+    try std.testing.expectApproxEqAbs(expected_0, out[0], 1e-5);
+}

src/inference/sampler.zig

···
+const std = @import("std");
+
+/// Temperature + top-k sampling for autoregressive generation.
+pub const Sampler = struct {
+    temperature: f32,
+    top_k: u32,
+    xoshiro: std.Random.Xoshiro256,
+
+    pub fn init(temperature: f32, top_k: u32, seed: u64) Sampler {
+        return .{
+            .temperature = temperature,
+            .top_k = top_k,
+            .xoshiro = std.Random.Xoshiro256.init(seed),
+        };
+    }
+
+    /// Sample a token index from logits.
+    /// Applies temperature scaling, then top-k filtering, then categorical sampling.
+    pub fn sample(self: *Sampler, logits: []f32) u32 {
+        const n = logits.len;
+        if (n == 0) return 0;
+
+        // Temperature scaling
+        if (self.temperature != 1.0 and self.temperature > 0.0) {
+            const inv_temp = 1.0 / self.temperature;
+            for (logits) |*l| {
+                l.* *= inv_temp;
+            }
+        }
+
+        // Greedy (temperature ~0)
+        if (self.temperature <= 0.0 or self.top_k == 1) {
+            return argmax(logits);
+        }
+
+        // Top-k: find the k-th largest value and zero out everything below
+        const k = @min(self.top_k, @as(u32, @intCast(n)));
+
+        // Find k-th largest using partial sort via repeated max finding
+        // For small k this is efficient enough
+        var threshold: f32 = -std.math.inf(f32);
+        if (k < n) {
+            // Use a simple approach: find the k-th largest value
+            // by maintaining the minimum of the top-k seen so far
+            var top_k_min: f32 = std.math.inf(f32);
+            var top_k_vals: [256]f32 = undefined;
+            const actual_k: usize = @min(k, 256);
+            var count: usize = 0;
+
+            for (logits) |l| {
+                if (count < actual_k) {
+                    top_k_vals[count] = l;
+                    count += 1;
+                    if (count == actual_k) {
+                        // Find min of top_k_vals
+                        top_k_min = top_k_vals[0];
+                        for (top_k_vals[1..actual_k]) |v| {
+                            if (v < top_k_min) top_k_min = v;
+                        }
+                    }
+                } else if (l > top_k_min) {
+                    // Replace the min
+                    for (&top_k_vals, 0..) |*v, i| {
+                        _ = i;
+                        if (v.* == top_k_min) {
+                            v.* = l;
+                            break;
+                        }
+                    }
+                    top_k_min = top_k_vals[0];
+                    for (top_k_vals[1..actual_k]) |v| {
+                        if (v < top_k_min) top_k_min = v;
+                    }
+                }
+            }
+            threshold = top_k_min;
+        }
+
+        // Softmax with top-k filtering
+        var max_val: f32 = -std.math.inf(f32);
+        for (logits) |l| {
+            if (l >= threshold and l > max_val) max_val = l;
+        }
+
+        var sum: f32 = 0.0;
+        for (logits) |*l| {
+            if (l.* >= threshold) {
+                l.* = @exp(l.* - max_val);
+                sum += l.*;
+            } else {
+                l.* = 0.0;
+            }
+        }
+
+        if (sum <= 0.0) return argmax(logits);
+
+        // Normalize
+        const inv_sum = 1.0 / sum;
+        for (logits) |*l| {
+            l.* *= inv_sum;
+        }
+
+        // Categorical sampling
+        var r = self.xoshiro.random().float(f32);
+        for (logits, 0..) |p, i| {
+            r -= p;
+            if (r <= 0.0) return @intCast(i);
+        }
+
+        return @intCast(n - 1);
+    }
+};
+
+fn argmax(vals: []const f32) u32 {
+    var best: u32 = 0;
+    var best_val: f32 = -std.math.inf(f32);
+    for (vals, 0..) |v, i| {
+        if (v > best_val) {
+            best_val = v;
+            best = @intCast(i);
+        }
+    }
+    return best;
+}
+
+test "sampler greedy" {
+    var logits = [_]f32{ 1.0, 3.0, 2.0, 0.5 };
+    var s = Sampler.init(0.0, 1, 42);
+    const token = s.sample(&logits);
+    try std.testing.expectEqual(@as(u32, 1), token);
+}
+
+test "sampler top_k" {
+    var logits = [_]f32{ 1.0, 10.0, 9.0, 0.5 };
+    var s = Sampler.init(1.0, 2, 42);
+    const token = s.sample(&logits);
+    // Should be either 1 or 2 (top-2)
+    try std.testing.expect(token == 1 or token == 2);
+}

src/inference/tokenizer.zig

···
+const std = @import("std");
+
+/// BPE tokenizer for Qwen3.5 models.
+/// Loads from HuggingFace tokenizer.json format.
+/// Uses byte-level BPE (GPT-2 style): bytes are mapped to unicode chars before BPE.
+pub const Tokenizer = struct {
+    /// Token ID → string mapping for decoding
+    vocab: [][]const u8,
+    vocab_size: u32,
+    /// BPE merge rules: pair → merged token. Stored as a sorted list for lookup.
+    merges: []Merge,
+    merge_count: u32,
+    /// String → Token ID mapping for encoding (sorted for binary search)
+    token_to_id: []TokenEntry,
+    token_count: u32,
+    /// Special token IDs
+    eos_id: u32,
+    im_start_id: u32,
+    im_end_id: u32,
+    /// Allocator used for loading
+    allocator: std.mem.Allocator,
+    /// Backing memory for all strings
+    string_pool: []u8,
+
+    const Merge = struct {
+        first: u32,
+        second: u32,
+        result: u32,
+        rank: u32, // lower = higher priority
+    };
+
+    const TokenEntry = struct {
+        text: []const u8,
+        id: u32,
+    };
+
+    pub fn deinit(self: *Tokenizer) void {
+        self.allocator.free(self.vocab);
+        self.allocator.free(self.merges);
+        self.allocator.free(self.token_to_id);
+        self.allocator.free(self.string_pool);
+    }
+
+    /// Load tokenizer from a tokenizer.json file using std.json.
+    pub fn loadFromFile(allocator: std.mem.Allocator, path: []const u8) !Tokenizer {
+        const file = try std.fs.cwd().openFile(path, .{});
+        defer file.close();
+
+        const file_size = try file.getEndPos();
+        const data = try allocator.alloc(u8, file_size);
+        defer allocator.free(data);
+        const bytes_read = try file.readAll(data);
+        if (bytes_read != file_size) return error.IncompleteRead;
+
+        return loadFromJson(allocator, data[0..bytes_read]);
+    }
+
+    pub fn loadFromJson(allocator: std.mem.Allocator, json_data: []const u8) !Tokenizer {
+        // Parse using std.json
+        var parsed = try std.json.parseFromSlice(std.json.Value, allocator, json_data, .{
+            .allocate = .alloc_always,
+            .max_value_len = std.json.default_max_value_len,
+        });
+        defer parsed.deinit();
+
+        const root = parsed.value;
+
+        // Extract model section
+        const model = root.object.get("model") orelse return error.InvalidFormat;
+        const vocab_obj = model.object.get("vocab") orelse return error.InvalidFormat;
+        const merges_arr = model.object.get("merges") orelse return error.InvalidFormat;
+
+        // Count vocab entries
+        const vocab_map = vocab_obj.object;
+        const num_vocab_entries: u32 = @intCast(vocab_map.count());
+
+        // Find max token ID to size the vocab array
+        var max_id: u32 = 0;
+        var it = vocab_map.iterator();
+        while (it.next()) |entry| {
+            const id: u32 = @intCast(entry.value_ptr.integer);
+            if (id > max_id) max_id = id;
+        }
+
+        // Also check added_tokens
+        var num_added: u32 = 0;
+        if (root.object.get("added_tokens")) |added| {
+            for (added.array.items) |tok| {
+                const id: u32 = @intCast(tok.object.get("id").?.integer);
+                if (id > max_id) max_id = id;
+                num_added += 1;
+            }
+        }
+
+        const total_vocab: u32 = max_id + 1;
+
+        // Allocate string pool - estimate size
+        var pool_size: usize = 0;
+        it = vocab_map.iterator();
+        while (it.next()) |entry| {
+            pool_size += entry.key_ptr.len + 1;
+        }
+        if (root.object.get("added_tokens")) |added| {
+            for (added.array.items) |tok| {
+                const content = tok.object.get("content").?.string;
+                pool_size += content.len + 1;
+            }
+        }
+
+        var string_pool = try allocator.alloc(u8, pool_size);
+        var pool_pos: usize = 0;
+
+        // Allocate vocab and token_to_id arrays
+        const vocab = try allocator.alloc([]const u8, total_vocab);
+        for (vocab) |*v| v.* = "";
+
+        const total_entries = num_vocab_entries + num_added;
+        const token_to_id = try allocator.alloc(TokenEntry, total_entries);
+        var entry_count: u32 = 0;
+
+        // Fill vocab from model.vocab
+        it = vocab_map.iterator();
+        while (it.next()) |entry| {
+            const text = entry.key_ptr.*;
+            const id: u32 = @intCast(entry.value_ptr.integer);
+
+            // Copy string to pool
+            const str_start = pool_pos;
+            @memcpy(string_pool[pool_pos .. pool_pos + text.len], text);
+            pool_pos += text.len;
+            const pooled = string_pool[str_start..pool_pos];
+
+            vocab[id] = pooled;
+            token_to_id[entry_count] = .{ .text = pooled, .id = id };
+            entry_count += 1;
+        }
+
+        // Add special/added tokens
+        var eos_id: u32 = 248046;
+        var im_start_id: u32 = 248045;
+        var im_end_id: u32 = 248046;
+
+        if (root.object.get("added_tokens")) |added| {
+            for (added.array.items) |tok| {
+                const id: u32 = @intCast(tok.object.get("id").?.integer);
+                const content = tok.object.get("content").?.string;
+
+                // Copy to pool
+                const str_start = pool_pos;
+                @memcpy(string_pool[pool_pos .. pool_pos + content.len], content);
+                pool_pos += content.len;
+                const pooled = string_pool[str_start..pool_pos];
+
+                if (id < total_vocab) {
+                    vocab[id] = pooled;
+                }
+                token_to_id[entry_count] = .{ .text = pooled, .id = id };
+                entry_count += 1;
+
+                // Detect special tokens
+                if (std.mem.eql(u8, content, "<|im_start|>")) im_start_id = id;
+                if (std.mem.eql(u8, content, "<|im_end|>")) im_end_id = id;
+                if (std.mem.eql(u8, content, "<|endoftext|>")) eos_id = id;
+            }
+        }
+
+        // Sort token_to_id by text for binary search
+        std.mem.sort(TokenEntry, token_to_id[0..entry_count], {}, struct {
+            fn lessThan(_: void, a: TokenEntry, b: TokenEntry) bool {
+                return std.mem.order(u8, a.text, b.text) == .lt;
+            }
+        }.lessThan);
+
+        // Parse merges
+        const merges_items = merges_arr.array.items;
+        const num_merges: u32 = @intCast(merges_items.len);
+        const merges = try allocator.alloc(Merge, num_merges);
+        var merge_count: u32 = 0;
+
+        for (merges_items, 0..) |merge_val, rank| {
+            // Merges can be either "token1 token2" (string) or ["token1", "token2"] (array)
+            var first_str: []const u8 = undefined;
+            var second_str: []const u8 = undefined;
+
+            switch (merge_val) {
+                .string => |merge_str| {
+                    const space_idx = std.mem.indexOf(u8, merge_str, " ") orelse continue;
+                    first_str = merge_str[0..space_idx];
+                    second_str = merge_str[space_idx + 1 ..];
+                },
+                .array => |arr| {
+                    if (arr.items.len != 2) continue;
+                    first_str = arr.items[0].string;
+                    second_str = arr.items[1].string;
+                },
+                else => continue,
+            }
+
+            const first_id = lookupTokenId(token_to_id[0..entry_count], first_str) orelse continue;
+            const second_id = lookupTokenId(token_to_id[0..entry_count], second_str) orelse continue;
+
+            // The merged result is the concatenation
+            const merged_str_buf = [_]u8{0} ** 0;
+            _ = merged_str_buf;
+
+            // Look up merged token
+            var merged_buf: [512]u8 = undefined;
+            if (first_str.len + second_str.len > merged_buf.len) continue;
+            @memcpy(merged_buf[0..first_str.len], first_str);
+            @memcpy(merged_buf[first_str.len .. first_str.len + second_str.len], second_str);
+            const merged_key = merged_buf[0 .. first_str.len + second_str.len];
+
+            const result_id = lookupTokenId(token_to_id[0..entry_count], merged_key) orelse continue;
+
+            merges[merge_count] = .{
+                .first = first_id,
+                .second = second_id,
+                .result = result_id,
+                .rank = @intCast(rank),
+            };
+            merge_count += 1;
+        }
+
+        return Tokenizer{
+            .vocab = vocab,
+            .vocab_size = total_vocab,
+            .merges = merges,
+            .merge_count = merge_count,
+            .token_to_id = token_to_id,
+            .token_count = entry_count,
+            .eos_id = eos_id,
+            .im_start_id = im_start_id,
+            .im_end_id = im_end_id,
+            .allocator = allocator,
+            .string_pool = string_pool,
+        };
+    }
+
+    /// Encode text to token IDs using BPE.
+    pub fn encode(self: *const Tokenizer, text: []const u8, allocator: std.mem.Allocator, out: []u32) !u32 {
+        // Step 1: Convert text bytes to byte-level BPE characters
+        var byte_tokens = std.ArrayListUnmanaged(u32){};
+        defer byte_tokens.deinit(allocator);
+
+        // Map each byte to its corresponding single-byte token
+        for (text) |byte| {
+            const ch = byteToBpeChar(byte);
+            var buf: [4]u8 = undefined;
+            const len = std.unicode.utf8Encode(ch, &buf) catch continue;
+            const char_str = buf[0..len];
+
+            if (lookupTokenId(self.token_to_id[0..self.token_count], char_str)) |id| {
+                try byte_tokens.append(allocator, id);
+            }
+        }
+
+        if (byte_tokens.items.len == 0) return 0;
+
+        // Step 2: Apply BPE merges greedily
+        // Repeatedly find the highest-priority merge and apply it
+        var tokens = byte_tokens.items;
+        var len: u32 = @intCast(tokens.len);
+
+        var changed = true;
+        while (changed) {
+            changed = false;
+            var best_rank: u32 = std.math.maxInt(u32);
+            var best_pos: u32 = 0;
+            var best_result: u32 = 0;
+
+            // Find the best merge
+            var i: u32 = 0;
+            while (i + 1 < len) : (i += 1) {
+                if (self.findMerge(tokens[i], tokens[i + 1])) |merge| {
+                    if (merge.rank < best_rank) {
+                        best_rank = merge.rank;
+                        best_pos = i;
+                        best_result = merge.result;
+                    }
+                }
+            }
+
+            if (best_rank < std.math.maxInt(u32)) {
+                // Apply merge: replace tokens[best_pos] and tokens[best_pos+1] with best_result
+                tokens[best_pos] = best_result;
+                // Shift remaining tokens left
+                var j: u32 = best_pos + 1;
+                while (j + 1 < len) : (j += 1) {
+                    tokens[j] = tokens[j + 1];
+                }
+                len -= 1;
+                changed = true;
+            }
+        }
+
+        // Copy to output
+        const out_len = @min(len, @as(u32, @intCast(out.len)));
+        @memcpy(out[0..out_len], tokens[0..out_len]);
+        return out_len;
+    }
+
+    /// Encode a ChatML-wrapped prompt.
+    /// Format: <|im_start|>system\n{system}<|im_end|>\n<|im_start|>user\n{user}<|im_end|>\n<|im_start|>assistant\n
+    pub fn encodeChatML(
+        self: *const Tokenizer,
+        system_prompt: ?[]const u8,
+        user_prompt: []const u8,
+        allocator: std.mem.Allocator,
+        out: []u32,
+    ) !u32 {
+        var pos: u32 = 0;
+
+        if (system_prompt) |sys| {
+            out[pos] = self.im_start_id;
+            pos += 1;
+            pos += try self.encode("system\n", allocator, out[pos..]);
+            pos += try self.encode(sys, allocator, out[pos..]);
+            out[pos] = self.im_end_id;
+            pos += 1;
+            pos += try self.encode("\n", allocator, out[pos..]);
+        }
+
+        out[pos] = self.im_start_id;
+        pos += 1;
+        pos += try self.encode("user\n", allocator, out[pos..]);
+        pos += try self.encode(user_prompt, allocator, out[pos..]);
+        out[pos] = self.im_end_id;
+        pos += 1;
+        pos += try self.encode("\n", allocator, out[pos..]);
+
+        out[pos] = self.im_start_id;
+        pos += 1;
+        pos += try self.encode("assistant\n", allocator, out[pos..]);
+
+        return pos;
+    }
+
+    /// Decode a single token ID to its text representation.
+    pub fn decode(self: *const Tokenizer, token_id: u32) []const u8 {
+        if (token_id >= self.vocab_size) return "";
+        return self.vocab[token_id];
+    }
+
+    /// Decode a token and convert byte-level BPE chars back to actual bytes.
+    pub fn decodeToBytes(self: *const Tokenizer, token_id: u32, out: []u8) u32 {
+        const text = self.decode(token_id);
+        var pos: u32 = 0;
+
+        var i: usize = 0;
+        while (i < text.len) {
+            const cp_len = std.unicode.utf8ByteSequenceLength(text[i]) catch {
+                if (pos < out.len) {
+                    out[pos] = text[i];
+                    pos += 1;
+                }
+                i += 1;
+                continue;
+            };
+            if (i + cp_len > text.len) break;
+            const cp = std.unicode.utf8Decode(text[i .. i + cp_len]) catch {
+                if (pos < out.len) {
+                    out[pos] = text[i];
+                    pos += 1;
+                }
+                i += 1;
+                continue;
+            };
+
+            if (bpeCharToByte(cp)) |byte| {
+                if (pos < out.len) {
+                    out[pos] = byte;
+                    pos += 1;
+                }
+            }
+            i += cp_len;
+        }
+
+        return pos;
+    }
+
+    fn findMerge(self: *const Tokenizer, first: u32, second: u32) ?*const Merge {
+        // Linear scan (could use hash map for speed, but this is simple)
+        for (self.merges[0..self.merge_count]) |*m| {
+            if (m.first == first and m.second == second) return m;
+        }
+        return null;
+    }
+};
+
+fn lookupTokenId(entries: []const Tokenizer.TokenEntry, text: []const u8) ?u32 {
+    // Binary search
+    var lo: usize = 0;
+    var hi: usize = entries.len;
+    while (lo < hi) {
+        const mid = lo + (hi - lo) / 2;
+        const cmp = std.mem.order(u8, entries[mid].text, text);
+        switch (cmp) {
+            .lt => lo = mid + 1,
+            .gt => hi = mid,
+            .eq => return entries[mid].id,
+        }
+    }
+    return null;
+}
+
+// ============================================================
+// GPT-2 byte-level BPE character mapping
+// ============================================================
+
+/// Map a byte value to the corresponding unicode codepoint used in GPT-2 BPE.
+/// Printable ASCII bytes map to themselves; others map to a range starting at U+0100.
+fn byteToBpeChar(byte: u8) u21 {
+    return byte_to_unicode_table[byte];
+}
+
+/// Reverse mapping: unicode codepoint back to byte.
+fn bpeCharToByte(cp: u21) ?u8 {
+    if (cp < 256) {
+        // Check if this is a direct-mapped printable char
+        if (byte_to_unicode_table[cp] == cp) return @intCast(cp);
+    }
+    // Search in the table for mapped values
+    for (byte_to_unicode_table, 0..) |mapped, byte| {
+        if (mapped == cp) return @intCast(byte);
+    }
+    return null;
+}
+
+/// GPT-2 byte_to_unicode mapping table.
+/// Printable chars (33-126, 161-172, 174-255) map to themselves.
+/// Other bytes (0-32, 127-160, 173) map to U+0100 onwards.
+const byte_to_unicode_table: [256]u21 = blk: {
+    var table: [256]u21 = undefined;
+    var n: u21 = 0x100; // Start of remapped range
+
+    for (0..256) |i| {
+        const b: u8 = @intCast(i);
+        if ((b >= 33 and b <= 126) or (b >= 161 and b <= 172) or (b >= 174 and b <= 255)) {
+            table[i] = b;
+        } else {
+            table[i] = n;
+            n += 1;
+        }
+    }
+    break :blk table;
+};
+
+test "byte to bpe char roundtrip" {
+    // Space (0x20 = 32) should map to Ġ (U+0120)
+    const space_char = byteToBpeChar(' ');
+    try std.testing.expectEqual(@as(u21, 0x0120), space_char);
+    const back = bpeCharToByte(0x0120);
+    try std.testing.expectEqual(@as(?u8, ' '), back);
+
+    // 'A' (65) should map to itself
+    const a_char = byteToBpeChar('A');
+    try std.testing.expectEqual(@as(u21, 'A'), a_char);
+    const a_back = bpeCharToByte('A');
+    try std.testing.expectEqual(@as(?u8, 'A'), a_back);
+}

src/main.zig

···
 pub const json = @import("utils/json.zig");
 const alloc_utils = @import("utils/allocator.zig");
 
+// Inference engine (native only — not compiled for WASM yet)
+pub const inference_model = if (builtin.target.cpu.arch != .wasm32) @import("inference/model.zig") else struct {};
+pub const inference_tokenizer = if (builtin.target.cpu.arch != .wasm32) @import("inference/tokenizer.zig") else struct {};
+pub const inference_sampler = if (builtin.target.cpu.arch != .wasm32) @import("inference/sampler.zig") else struct {};
+pub const inference_kv_cache = if (builtin.target.cpu.arch != .wasm32) @import("inference/kv_cache.zig") else struct {};
+pub const inference_quantized = if (builtin.target.cpu.arch != .wasm32) @import("inference/quantized.zig") else struct {};
+
 // ============================================================
 // Shared state
 // ============================================================
···
     _ = args.next();
 
     const command = args.next() orelse {
-        try stderr.print("Usage: fantasma <profile|verify> [args...]\n", .{});
+        try stderr.print("Usage: fantasma <profile|verify|generate> [args...]\n", .{});
         try stderr.flush();
         return;
     };
···
             }
         }
         try stdout.flush();
+    } else if (std.mem.eql(u8, command, "generate")) {
+        const model_dir = args.next() orelse "QwenTheBard";
+        const prompt_text = args.next() orelse "Hello, how are you?";
+
+        try stderr.print("Loading tokenizer...\n", .{});
+        try stderr.flush();
+
+        var tok_path_buf: [1024]u8 = undefined;
+        const tok_path = std.fmt.bufPrint(&tok_path_buf, "{s}/tokenizer.json", .{model_dir}) catch "QwenTheBard/tokenizer.json";
+
+        var tokenizer = inference_tokenizer.Tokenizer.loadFromFile(allocator, tok_path) catch |e| {
+            try stderr.print("Failed to load tokenizer: {}\n", .{e});
+            try stderr.flush();
+            return;
+        };
+        defer tokenizer.deinit();
+
+        try stderr.print("Loading model weights from {s}...\n", .{model_dir});
+        try stderr.flush();
+
+        const max_seq_len: u32 = 512;
+        var weights = inference_model.loadWeights(allocator, model_dir, max_seq_len) catch |e| {
+            try stderr.print("Failed to load weights: {}\n", .{e});
+            try stderr.flush();
+            return;
+        };
+        _ = &weights;
+
+        try stderr.print("Model loaded. Generating...\n", .{});
+        try stderr.flush();
+
+        // Tokenize prompt with ChatML wrapping
+        var token_buf: [2048]u32 = undefined;
+        const prompt_len = tokenizer.encodeChatML(
+            "/no_think",
+            prompt_text,
+            allocator,
+            &token_buf,
+        ) catch |e| {
+            try stderr.print("Failed to tokenize: {}\n", .{e});
+            try stderr.flush();
+            return;
+        };
+
+        try stderr.print("Prompt tokens: {d}\n", .{prompt_len});
+        try stderr.flush();
+
+        // Initialize cache and forward state
+        const Config = inference_kv_cache.Config;
+        var model_cache = inference_kv_cache.ModelCache.init(allocator, max_seq_len) catch |e| {
+            try stderr.print("Failed to init cache: {}\n", .{e});
+            try stderr.flush();
+            return;
+        };
+        defer model_cache.deinit(allocator);
+
+        var fwd_state = inference_model.ForwardState.init(allocator) catch |e| {
+            try stderr.print("Failed to init state: {}\n", .{e});
+            try stderr.flush();
+            return;
+        };
+        defer fwd_state.deinit();
+
+        var sampler = inference_sampler.Sampler.init(0.7, 40, 42);
+
+        // Prefill: process prompt tokens
+        var pos: u32 = 0;
+        for (token_buf[0..prompt_len], 0..) |tok, ti| {
+            _ = inference_model.forward(&weights, &model_cache, &fwd_state, tok, pos);
+            pos += 1;
+            try stderr.print("\rPrefill: {d}/{d}", .{ ti + 1, prompt_len });
+            try stderr.flush();
+        }
+        try stderr.print(" done\n", .{});
+        try stderr.flush();
+
+        // Decode: generate new tokens
+        const max_new_tokens: u32 = 256;
+        var decode_buf: [512]u8 = undefined;
+        var generated: u32 = 0;
+        while (generated < max_new_tokens and pos < max_seq_len) {
+            // Sample next token from current logits
+            const logits_copy = try allocator.alloc(f32, Config.vocab_size);
+            defer allocator.free(logits_copy);
+            @memcpy(logits_copy, fwd_state.logits);
+            const next_token = sampler.sample(logits_copy);
+
+            if (next_token == Config.eos_token_id) break;
+
+            // Decode and print the token
+            const byte_len = tokenizer.decodeToBytes(next_token, &decode_buf);
+            if (byte_len > 0) {
+                try stdout.writeAll(decode_buf[0..byte_len]);
+                try stdout.flush();
+            }
+
+            // Forward pass for next token
+            _ = inference_model.forward(&weights, &model_cache, &fwd_state, next_token, pos);
+            pos += 1;
+            generated += 1;
+        }
+
+        try stdout.print("\n", .{});
+        try stdout.flush();
+        try stderr.print("\n[Generated {d} tokens]\n", .{generated});
+        try stderr.flush();
     } else {
         try stderr.print("Unknown command: {s}\n", .{command});
         try stderr.flush();
···
     _ = chunker;
     _ = unicode;
     _ = json;
+    if (@import("builtin").target.cpu.arch != .wasm32) {
+        _ = inference_model;
+        _ = inference_tokenizer;
+        _ = inference_sampler;
+        _ = inference_kv_cache;
+        _ = inference_quantized;
+    }
 }

web/.gitignore

···
+node_modules
+dist
+*.wasm

web/app.js

···
-// Fantasma — client-side stylometric neutralizer
-// WASM profiler loads directly on page load (~27KB).
-// Model weights are downloaded on demand and stored in IndexedDB.
-
-(function () {
-  "use strict";
-
-  const $ = (sel) => document.querySelector(sel);
-
-  // Elements
-  const inputEl = $("#input-text");
-  const btnAnalyze = $("#btn-analyze");
-  const btnRetry = $("#btn-retry");
-  const resultsSection = $("#results");
-  const resultsSummary = $("#results-summary");
-  const markerCount = $("#marker-count");
-  const markersContainer = $("#markers-container");
-  const wordCount = $("#word-count");
-  const statusIndicator = $("#status-indicator");
-  const forensicToggle = $("#forensic-toggle");
-  const forensicPanel = $("#forensic-panel");
-  const forensicBody = $("#forensic-table-body");
-  const rewriterSection = $("#rewriter-section");
-  const btnDownload = $("#btn-download-model");
-  const downloadProgress = $("#download-progress");
-  const progressFill = $("#progress-fill");
-  const progressText = $("#progress-text");
-  const btnNeutralize = $("#btn-neutralize");
-  const btnPanic = $("#btn-panic");
-
-  let wasmInstance = null;
-  let modelLoaded = false;
-
-  const DB_NAME = "fantasma";
-  const DB_VERSION = 1;
-  const STORE_NAME = "model";
-  const WEIGHTS_KEY = "weights";
-
-  // ============================================================
-  // IndexedDB helpers (model weights only)
-  // ============================================================
-
-  function openDB() {
-    return new Promise((resolve, reject) => {
-      const req = indexedDB.open(DB_NAME, DB_VERSION);
-      req.onupgradeneeded = () => req.result.createObjectStore(STORE_NAME);
-      req.onsuccess = () => resolve(req.result);
-      req.onerror = () => reject(req.error);
-    });
-  }
-
-  async function dbGet(key) {
-    const db = await openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(STORE_NAME, "readonly");
-      const req = tx.objectStore(STORE_NAME).get(key);
-      req.onsuccess = () => resolve(req.result);
-      req.onerror = () => reject(req.error);
-    });
-  }
-
-  async function dbPut(key, value) {
-    const db = await openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(STORE_NAME, "readwrite");
-      const req = tx.objectStore(STORE_NAME).put(value, key);
-      req.onsuccess = () => resolve();
-      req.onerror = () => reject(req.error);
-    });
-  }
-
-  // ============================================================
-  // Fetch with progress
-  // ============================================================
-
-  async function fetchWithProgress(url, onProgress) {
-    const response = await fetch(url);
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    const total = parseInt(response.headers.get("content-length") || "0", 10);
-    const reader = response.body.getReader();
-    const chunks = [];
-    let received = 0;
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-      received += value.length;
-      if (onProgress) onProgress(received, total);
-    }
-
-    const result = new Uint8Array(received);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return result.buffer;
-  }
-
-  function formatBytes(bytes) {
-    if (bytes < 1024) return bytes + " B";
-    if (bytes < 1048576) return (bytes / 1024).toFixed(0) + " KB";
-    return (bytes / 1048576).toFixed(1) + " MB";
-  }
-
-  // ============================================================
-  // WASM helpers
-  // ============================================================
-
-  function wasmCall(exportName, text) {
-    const encoder = new TextEncoder();
-    const bytes = encoder.encode(text);
-    const ptr = wasmInstance.exports.alloc(bytes.length);
-    new Uint8Array(wasmInstance.exports.memory.buffer, ptr, bytes.length).set(bytes);
-
-    const ok = wasmInstance.exports[exportName](ptr, bytes.length);
-    wasmInstance.exports.dealloc(ptr, bytes.length);
-    if (!ok) throw new Error(`WASM ${exportName} failed`);
-
-    const outPtr = wasmInstance.exports.get_output_ptr();
-    const outLen = wasmInstance.exports.get_output_len();
-    const outBytes = new Uint8Array(wasmInstance.exports.memory.buffer, outPtr, outLen);
-    return JSON.parse(new TextDecoder().decode(outBytes));
-  }
-
-  function loadModelWeights(weightsBytes) {
-    const arr = new Uint8Array(weightsBytes);
-    const ptr = wasmInstance.exports.alloc(arr.length);
-    new Uint8Array(wasmInstance.exports.memory.buffer, ptr, arr.length).set(arr);
-    const ok = wasmInstance.exports.init(ptr, arr.length);
-    wasmInstance.exports.dealloc(ptr, arr.length);
-    return ok;
-  }
-
-  // ============================================================
-  // Status
-  // ============================================================
-
-  function setStatus(state, msg) {
-    switch (state) {
-      case "loading":
-        statusIndicator.textContent = "Loading...";
-        statusIndicator.className = "status status-loading";
-        break;
-      case "ready":
-        statusIndicator.textContent = "Ready";
-        statusIndicator.className = "status status-ready";
-        break;
-      case "model-ready":
-        statusIndicator.textContent = "Offline";
-        statusIndicator.className = "status status-ready";
-        break;
-      case "error":
-        statusIndicator.textContent = msg || "Error";
-        statusIndicator.className = "status status-error";
-        break;
-    }
-  }
-
-  // ============================================================
-  // Word count
-  // ============================================================
-
-  inputEl.addEventListener("input", () => {
-    const words = inputEl.value.trim().split(/\s+/).filter(Boolean).length;
-    wordCount.textContent = words + " word" + (words !== 1 ? "s" : "");
-    btnAnalyze.disabled = !wasmInstance || words < 3;
-  });
-
-  // ============================================================
-  // Forensic toggle
-  // ============================================================
-
-  forensicToggle.addEventListener("change", () => {
-    forensicPanel.hidden = !forensicToggle.checked;
-  });
-
-  // ============================================================
-  // Analyze
-  // ============================================================
-
-  btnAnalyze.addEventListener("click", () => {
-    const text = inputEl.value.trim();
-    if (!text || !wasmInstance) return;
-
-    btnAnalyze.disabled = true;
-    btnAnalyze.classList.add("btn-loading");
-    btnAnalyze.textContent = "Analyzing";
-
-    try {
-      const result = wasmCall("profile", text);
-      renderProfile(result);
-    } catch (e) {
-      console.error("Profile error:", e);
-      setStatus("error", "Analysis failed");
-    } finally {
-      btnAnalyze.disabled = false;
-      btnAnalyze.classList.remove("btn-loading");
-      btnAnalyze.textContent = "Analyze Fingerprint";
-    }
-  });
-
-  // ============================================================
-  // Render profile
-  // ============================================================
-
-  // Profile JSON keys → display names
-  const FEATURE_LABELS = {
-    avg_word_length: "Avg word length",
-    vocabulary_richness: "Vocabulary richness",
-    hapax_ratio: "Hapax ratio",
-    avg_sentence_length: "Avg sentence length",
-    sentence_length_variance: "Sentence length variance",
-    passive_voice_ratio: "Passive voice ratio",
-    contraction_rate: "Contraction rate",
-    semicolon_rate: "Semicolon rate",
-    comma_rate: "Comma rate",
-    dash_rate: "Dash rate",
-    exclamation_rate: "Exclamation rate",
-    hyphenation_rate: "Hyphenation rate",
-  };
-
-  // WASM marker names → profile feature keys
-  const MARKER_TO_FEATURE = {
-    semicolon_high: "semicolon_rate",
-    contraction_high: "contraction_rate",
-    comma_rate: "comma_rate",
-    colon_high: "colon_rate",
-    dash_preference: "dash_rate",
-    exclamation_high: "exclamation_rate",
-    ellipsis_high: "ellipsis_rate",
-    parenthetical_high: "parenthetical_rate",
-    sentence_length_high: "avg_sentence_length",
-    sentence_length_variance_high: "sentence_length_variance",
-    passive_voice_high: "passive_voice_ratio",
-    vocabulary_richness_high: "vocabulary_richness",
-    hapax_ratio_high: "hapax_ratio",
-    hyphenation_high: "hyphenation_rate",
-    avg_word_length: "avg_word_length",
-    avg_syllables: "avg_syllables_per_word",
-  };
-
-  function formatMarkerName(name) {
-    return name.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-  }
-
-  function renderProfile(result) {
-    // Summary
-    markerCount.textContent = result.markers.length;
-    resultsSummary.dataset.variant = result.markers.length === 0 ? "success" : "warning";
-
-    // Markers list
-    markersContainer.innerHTML = "";
-    for (const m of result.markers) {
-      const item = document.createElement("div");
-      item.className = "change-item";
-      const dir = m.z_score > 0 ? "HIGH" : "LOW";
-      item.innerHTML = `
-        <div class="change-header">
-          <span class="change-marker">${esc(formatMarkerName(m.name))}</span>
-          <span class="change-arrow">${dir}</span>
-        </div>
-        <div class="change-reason">Value: ${m.value.toFixed(4)} &middot; Baseline: ${m.baseline.toFixed(4)} &middot; z = ${m.z_score.toFixed(2)}</div>
-      `;
-      markersContainer.appendChild(item);
-    }
-
-    // Build marker lookup by feature key
-    const flagged = new Map();
-    for (const m of result.markers) {
-      const featureKey = MARKER_TO_FEATURE[m.name];
-      if (featureKey) flagged.set(featureKey, m);
-    }
-
-    // Forensic table
-    forensicBody.innerHTML = "";
-    for (const [key, label] of Object.entries(FEATURE_LABELS)) {
-      if (result[key] === undefined) continue;
-      const tr = document.createElement("tr");
-      const m = flagged.get(key);
-
-      let statusCls, statusTxt;
-      if (m) {
-        statusCls = "forensic-warn";
-        statusTxt = m.z_score > 0 ? "\u26a0 High" : "\u26a0 Low";
-      } else {
-        statusCls = "forensic-fixed";
-        statusTxt = "\u2713 Normal";
-      }
-
-      const baseline = m ? m.baseline.toFixed(4) : "\u2014";
-      tr.innerHTML = `
-        <td>${esc(label)}</td>
-        <td>${typeof result[key] === "boolean" ? (result[key] ? "Yes" : "No") : result[key].toFixed(4)}</td>
-        <td>${baseline}</td>
-        <td class="${statusCls}">${statusTxt}</td>
-      `;
-      forensicBody.appendChild(tr);
-    }
-
-    // Show rewriter section
-    rewriterSection.hidden = false;
-    if (modelLoaded) {
-      btnDownload.hidden = true;
-      btnNeutralize.hidden = false;
-    } else {
-      btnDownload.hidden = false;
-      btnNeutralize.hidden = true;
-    }
-
-    resultsSection.hidden = false;
-    resultsSection.scrollIntoView({ behavior: "smooth", block: "start" });
-  }
-
-  // ============================================================
-  // Download model
-  // ============================================================
-
-  btnDownload.addEventListener("click", async () => {
-    btnDownload.disabled = true;
-    downloadProgress.hidden = false;
-
-    try {
-      progressText.textContent = "Downloading model...";
-      progressFill.style.width = "0%";
-
-      const weightsBytes = await fetchWithProgress("model.bin", (recv, total) => {
-        if (total > 0) {
-          const pct = Math.round((recv / total) * 100);
-          progressFill.style.width = pct + "%";
-          progressText.textContent = `${formatBytes(recv)} / ${formatBytes(total)}`;
-        } else {
-          progressText.textContent = formatBytes(recv);
-        }
-      });
-
-      await dbPut(WEIGHTS_KEY, weightsBytes);
-      progressText.textContent = "Initializing model...";
-      progressFill.style.width = "100%";
-
-      const ok = loadModelWeights(weightsBytes);
-      if (ok) {
-        modelLoaded = true;
-        downloadProgress.hidden = true;
-        btnDownload.hidden = true;
-        btnNeutralize.hidden = false;
-        setStatus("model-ready");
-      } else {
-        progressText.textContent = "Model init failed";
-        btnDownload.disabled = false;
-      }
-    } catch (e) {
-      console.error("Download error:", e);
-      progressText.textContent = "Model not available yet";
-      progressFill.style.width = "0%";
-      btnDownload.disabled = false;
-    }
-  });
-
-  // ============================================================
-  // Neutralize
-  // ============================================================
-
-  btnNeutralize.addEventListener("click", () => {
-    const text = inputEl.value.trim();
-    if (!text || !wasmInstance || !modelLoaded) return;
-
-    btnNeutralize.disabled = true;
-    btnNeutralize.classList.add("btn-loading");
-    btnNeutralize.textContent = "Neutralizing";
-
-    try {
-      const result = wasmCall("neutralize", text);
-      // TODO: render rewritten text + changes when inference engine is ready
-      // For now, neutralize returns the same as profile
-      renderProfile(result);
-    } catch (e) {
-      console.error("Neutralize error:", e);
-    } finally {
-      btnNeutralize.disabled = false;
-      btnNeutralize.classList.remove("btn-loading");
-      btnNeutralize.textContent = "Neutralize";
-    }
-  });
-
-  // ============================================================
-  // Panic — erase everything
-  // ============================================================
-
-  btnPanic.addEventListener("click", async () => {
-    // Clear all text and UI state immediately
-    inputEl.value = "";
-    wordCount.textContent = "0 words";
-    btnAnalyze.disabled = true;
-    resultsSection.hidden = true;
-    markersContainer.innerHTML = "";
-    forensicBody.innerHTML = "";
-    forensicToggle.checked = false;
-    forensicPanel.hidden = true;
-
-    // Delete model from IndexedDB
-    try {
-      const db = await openDB();
-      const tx = db.transaction(STORE_NAME, "readwrite");
-      tx.objectStore(STORE_NAME).clear();
-      await new Promise((resolve, reject) => {
-        tx.oncomplete = resolve;
-        tx.onerror = () => reject(tx.error);
-      });
-    } catch {
-      // Best effort
-    }
-
-    // Delete the entire database
-    try {
-      indexedDB.deleteDatabase(DB_NAME);
-    } catch {
-      // Best effort
-    }
-
-    // Unregister service worker and clear caches
-    if ("serviceWorker" in navigator) {
-      const regs = await navigator.serviceWorker.getRegistrations();
-      for (const reg of regs) reg.unregister();
-    }
-    if ("caches" in window) {
-      const names = await caches.keys();
-      for (const name of names) await caches.delete(name);
-    }
-
-    // Clear any other storage
-    try { sessionStorage.clear(); } catch {}
-    try { localStorage.clear(); } catch {}
-
-    modelLoaded = false;
-    wasmInstance = null;
-    setStatus("loading");
-
-    // Replace page with blank to remove DOM traces
-    document.title = "";
-    document.body.innerHTML = "";
-    history.replaceState(null, "", "about:blank");
-  });
-
-  // ============================================================
-  // Retry
-  // ============================================================
-
-  btnRetry.addEventListener("click", () => {
-    resultsSection.hidden = true;
-    inputEl.focus();
-  });
-
-  // ============================================================
-  // Helpers
-  // ============================================================
-
-  function esc(str) {
-    const div = document.createElement("div");
-    div.textContent = str;
-    return div.innerHTML;
-  }
-
-  // ============================================================
-  // Init: fetch WASM directly, check IndexedDB for model
-  // ============================================================
-
-  (async function init() {
-    setStatus("loading");
-
-    try {
-      const wasmBytes = await fetch("fantasma.wasm").then((r) => {
-        if (!r.ok) throw new Error(`HTTP ${r.status}`);
-        return r.arrayBuffer();
-      });
-
-      const { instance } = await WebAssembly.instantiate(wasmBytes, {
-        env: {
-          log_message: (ptr, len) => {
-            const bytes = new Uint8Array(instance.exports.memory.buffer, ptr, len);
-            console.log("[wasm]", new TextDecoder().decode(bytes));
-          },
-        },
-      });
-
-      wasmInstance = instance;
-      setStatus("ready");
-
-      // Enable analyze if text already present
-      const words = inputEl.value.trim().split(/\s+/).filter(Boolean).length;
-      if (words >= 3) btnAnalyze.disabled = false;
-
-      // Check if model weights are already stored
-      try {
-        const storedWeights = await dbGet(WEIGHTS_KEY);
-        if (storedWeights) {
-          const ok = loadModelWeights(storedWeights);
-          if (ok) {
-            modelLoaded = true;
-            setStatus("model-ready");
-          }
-        }
-      } catch {
-        // IndexedDB not available — model download will be offered later
-      }
-    } catch (e) {
-      console.error("WASM load failed:", e);
-      setStatus("error", "Engine unavailable");
-    }
-  })();
-
-  if ("serviceWorker" in navigator) {
-    navigator.serviceWorker.register("sw.js").catch(() => {});
-  }
-})();

web/bun.lock

···
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "fantasma-web",
+      "dependencies": {
+        "@knadh/oat": "^0.4.1",
+        "zod": "^4.3.6",
+        "zustand": "^5.0.11",
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3",
+        "vite": "^7.3.1",
+      },
+    },
+  },
+  "packages": {
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.3", "", { "os": "aix", "cpu": "ppc64" }, "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.27.3", "", { "os": "android", "cpu": "arm" }, "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.3", "", { "os": "android", "cpu": "arm64" }, "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.27.3", "", { "os": "android", "cpu": "x64" }, "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.3", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.3", "", { "os": "freebsd", "cpu": "x64" }, "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.3", "", { "os": "linux", "cpu": "arm" }, "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.3", "", { "os": "linux", "cpu": "ia32" }, "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.3", "", { "os": "linux", "cpu": "none" }, "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.3", "", { "os": "linux", "cpu": "none" }, "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.3", "", { "os": "linux", "cpu": "ppc64" }, "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.3", "", { "os": "linux", "cpu": "none" }, "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.3", "", { "os": "linux", "cpu": "s390x" }, "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.3", "", { "os": "linux", "cpu": "x64" }, "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.3", "", { "os": "none", "cpu": "arm64" }, "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.3", "", { "os": "none", "cpu": "x64" }, "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.3", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.3", "", { "os": "openbsd", "cpu": "x64" }, "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.3", "", { "os": "none", "cpu": "arm64" }, "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.3", "", { "os": "sunos", "cpu": "x64" }, "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.3", "", { "os": "win32", "cpu": "arm64" }, "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.3", "", { "os": "win32", "cpu": "ia32" }, "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.3", "", { "os": "win32", "cpu": "x64" }, "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA=="],
+
+    "@knadh/oat": ["@knadh/oat@0.4.1", "", {}, "sha512-Cdpuy1/828ICY5A9mjGYbDszt3tE4OiS0kcbjkHmBRwtFGZ/4oKA0cNkqJEgyNGdabhMlfiGTvKEflKMaax8mA=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.59.0", "", { "os": "android", "cpu": "arm" }, "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.59.0", "", { "os": "android", "cpu": "arm64" }, "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.59.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.59.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.59.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.59.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.59.0", "", { "os": "linux", "cpu": "arm" }, "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.59.0", "", { "os": "linux", "cpu": "arm" }, "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.59.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.59.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA=="],
+
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg=="],
+
+    "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.59.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA=="],
+
+    "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.59.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.59.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.59.0", "", { "os": "linux", "cpu": "x64" }, "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.59.0", "", { "os": "linux", "cpu": "x64" }, "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg=="],
+
+    "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.59.0", "", { "os": "openbsd", "cpu": "x64" }, "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ=="],
+
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.59.0", "", { "os": "none", "cpu": "arm64" }, "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.59.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.59.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.59.0", "", { "os": "win32", "cpu": "x64" }, "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.59.0", "", { "os": "win32", "cpu": "x64" }, "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA=="],
+
+    "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
+
+    "esbuild": ["esbuild@0.27.3", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.3", "@esbuild/android-arm": "0.27.3", "@esbuild/android-arm64": "0.27.3", "@esbuild/android-x64": "0.27.3", "@esbuild/darwin-arm64": "0.27.3", "@esbuild/darwin-x64": "0.27.3", "@esbuild/freebsd-arm64": "0.27.3", "@esbuild/freebsd-x64": "0.27.3", "@esbuild/linux-arm": "0.27.3", "@esbuild/linux-arm64": "0.27.3", "@esbuild/linux-ia32": "0.27.3", "@esbuild/linux-loong64": "0.27.3", "@esbuild/linux-mips64el": "0.27.3", "@esbuild/linux-ppc64": "0.27.3", "@esbuild/linux-riscv64": "0.27.3", "@esbuild/linux-s390x": "0.27.3", "@esbuild/linux-x64": "0.27.3", "@esbuild/netbsd-arm64": "0.27.3", "@esbuild/netbsd-x64": "0.27.3", "@esbuild/openbsd-arm64": "0.27.3", "@esbuild/openbsd-x64": "0.27.3", "@esbuild/openharmony-arm64": "0.27.3", "@esbuild/sunos-x64": "0.27.3", "@esbuild/win32-arm64": "0.27.3", "@esbuild/win32-ia32": "0.27.3", "@esbuild/win32-x64": "0.27.3" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg=="],
+
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+
+    "postcss": ["postcss@8.5.8", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg=="],
+
+    "rollup": ["rollup@4.59.0", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.59.0", "@rollup/rollup-android-arm64": "4.59.0", "@rollup/rollup-darwin-arm64": "4.59.0", "@rollup/rollup-darwin-x64": "4.59.0", "@rollup/rollup-freebsd-arm64": "4.59.0", "@rollup/rollup-freebsd-x64": "4.59.0", "@rollup/rollup-linux-arm-gnueabihf": "4.59.0", "@rollup/rollup-linux-arm-musleabihf": "4.59.0", "@rollup/rollup-linux-arm64-gnu": "4.59.0", "@rollup/rollup-linux-arm64-musl": "4.59.0", "@rollup/rollup-linux-loong64-gnu": "4.59.0", "@rollup/rollup-linux-loong64-musl": "4.59.0", "@rollup/rollup-linux-ppc64-gnu": "4.59.0", "@rollup/rollup-linux-ppc64-musl": "4.59.0", "@rollup/rollup-linux-riscv64-gnu": "4.59.0", "@rollup/rollup-linux-riscv64-musl": "4.59.0", "@rollup/rollup-linux-s390x-gnu": "4.59.0", "@rollup/rollup-linux-x64-gnu": "4.59.0", "@rollup/rollup-linux-x64-musl": "4.59.0", "@rollup/rollup-openbsd-x64": "4.59.0", "@rollup/rollup-openharmony-arm64": "4.59.0", "@rollup/rollup-win32-arm64-msvc": "4.59.0", "@rollup/rollup-win32-ia32-msvc": "4.59.0", "@rollup/rollup-win32-x64-gnu": "4.59.0", "@rollup/rollup-win32-x64-msvc": "4.59.0", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "vite": ["vite@7.3.1", "", { "dependencies": { "esbuild": "^0.27.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA=="],
+
+    "zod": ["zod@4.3.6", "", {}, "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg=="],
+
+    "zustand": ["zustand@5.0.11", "", { "peerDependencies": { "@types/react": ">=18.0.0", "immer": ">=9.0.6", "react": ">=18.0.0", "use-sync-external-store": ">=1.2.0" }, "optionalPeers": ["@types/react", "immer", "react", "use-sync-external-store"] }, "sha512-fdZY+dk7zn/vbWNCYmzZULHRrss0jx5pPFiOuMZ/5HJN6Yv3u+1Wswy/4MpZEkEGhtNH+pwxZB8OKgUBPzYAGg=="],
+  }
+}

web/index.html

···
   <title>Fantasma — Write Like No One</title>
   <meta name="description" content="Neutralize your stylometric fingerprint. Same meaning, no authorship signal. Runs entirely in your browser.">
   <meta name="theme-color" content="#1e1e2e">
-  <link rel="icon" href="favicon.svg" type="image/svg+xml">
-  <link rel="manifest" href="manifest.json">
-  <link rel="stylesheet" href="oat.min.css">
-  <script src="oat.min.js" defer></script>
-  <link rel="stylesheet" href="style.css">
+  <link rel="icon" href="/favicon.svg" type="image/svg+xml">
+  <link rel="manifest" href="/manifest.json">
 </head>
 <body data-theme="dark">
 
···
     <p>made with &#10084;&#65039; by <a href="https://qontact.qstorage.quilibrium.com/?address=QmeGDXJ58AJ9hJCLqFXyosYg6uW3hekYnuPXpLhiLrKjj8&name=meta" target="_blank" rel="noopener">meta</a> &middot; hosted on <a href="https://quilibrium.com" target="_blank" rel="noopener">Quilibrium</a></p>
   </footer>
 
-  <script src="app.js"></script>
+  <script type="module" src="/src/main.ts"></script>
 </body>
 </html>

web/oat.min.css

···
-@layer theme,base,components,animations,utilities;@layer base{*,*:before,*:after{box-sizing:border-box;-webkit-tap-highlight-color:transparent}*{margin:0}html{tab-size:4}body,dialog,[popover]{font-family:var(--font-sans);font-size:var(--text-regular);line-height:var(--leading-normal);color:var(--foreground)}body{background-color:var(--background);color:var(--foreground);-webkit-font-smoothing:antialiased}main{padding-block-start:var(--space-8)}img,picture,video,canvas,svg{max-width:100%}p,h1,h2,h3,h4,h5,h6{overflow-wrap:break-word}h1,h2,h3,h4,h5,h6{font-weight:var(--font-semibold);line-height:1.25;&:first-child{margin-block-start:0}}h1{font-size:var(--text-1);margin:var(--space-10) 0 var(--space-6)}h2{font-size:var(--text-2);margin:var(--space-8) 0 var(--space-5)}h3{font-size:var(--text-3);margin:var(--space-6) 0 var(--space-4)}h4{font-size:var(--text-4);margin:var(--space-5) 0 var(--space-3)}h5{font-size:var(--text-5);margin:var(--space-4) 0 var(--space-2)}h6{font-size:var(--text-regular);margin:var(--space-4) 0 var(--space-2)}p{margin-block-end:var(--space-4);&:last-child{margin-block-end:0}}a{color:var(--primary);text-decoration:underline;text-underline-offset:2px;transition:color var(--transition-fast);&:hover{color:rgb(from var(--primary) r g b / .8)}}strong,b{font-weight:var(--font-semibold)}em,i{font-style:italic}small{font-size:var(--text-7)}code{font-family:var(--font-mono);font-size:.875em;padding:calc(var(--space-1) / 2) var(--space-1);background-color:var(--faint);border-radius:var(--radius-small)}pre{font-family:var(--font-mono);padding:var(--space-4);background-color:var(--faint);border-radius:var(--radius-medium);overflow-x:auto;margin-block-end:var(--space-4);code{padding:0;background:none;border-radius:0}}blockquote{border-inline-start:4px solid var(--border);padding-inline-start:var(--space-4);margin:var(--space-4) 0;color:var(--muted-foreground);font-style:italic}hr{border:none;border-top:1px solid var(--border);margin:var(--space-2) 0}ul,ol{padding-inline-start:var(--space-6);margin-block-end:var(--space-4)}ul{list-style-type:disc}ol{list-style-type:decimal}li{margin-block-end:var(--space-1)}mark{background-color:rgb(from var(--warning) r g b / .3);padding:calc(var(--space-1) / 2) var(--space-1);border-radius:var(--radius-small)}[hidden]{display:none}:focus-visible{outline:2px solid var(--ring);outline-offset:2px}:disabled{opacity:.5;cursor:not-allowed}}@layer theme{:root{color-scheme:light dark;--background: light-dark(#fff, #09090b);--foreground: light-dark(#09090b, #fafafa);--card: light-dark(#fff, #18181b);--card-foreground: light-dark(#09090b, #fafafa);--primary: light-dark(#574747, #fafafa);--primary-foreground: light-dark(#fafafa, #18181b);--secondary: light-dark(#f4f4f5, #27272a);--secondary-foreground: light-dark(#574747, #fafafa);--muted: light-dark(#f4f4f5, #27272a);--muted-foreground: light-dark(#71717a, #a1a1aa);--faint: light-dark(#fafafa, #1e1e21);--faint-foreground: light-dark(#a1a1aa, #71717a);--accent: light-dark(#f4f4f5, #27272a);--danger: light-dark(#d32f2f, #f4807b);--danger-foreground: light-dark(#fafafa, #18181b);--success: light-dark(#008032, #6cc070);--success-foreground: light-dark(#fafafa, #18181b);--warning: light-dark(#a65b00, #f0a030);--warning-foreground: #09090b;--border: light-dark(#d4d4d8, #52525b);--input: light-dark(#d4d4d8, #52525b);--ring: light-dark(#574747, #d4d4d8);--space-1: .25rem;--space-2: .5rem;--space-3: .75rem;--space-4: 1rem;--space-5: 1.25rem;--space-6: 1.5rem;--space-8: 2rem;--space-10: 2.5rem;--space-12: 3rem;--space-14: 3.5rem;--space-16: 4rem;--space-18: 4.5rem;--radius-small: .125rem;--radius-medium: .375rem;--radius-large: .75rem;--radius-full: 9999px;--bar-height: .5rem;--font-sans: system-ui, sans-serif;--font-mono: ui-monospace, Consolas, monospace;--text-1: clamp(1.75rem, 1.5rem + 1.1vw, 2.25rem);--text-2: clamp(1.5rem, 1.3rem + .8vw, 1.875rem);--text-3: clamp(1.25rem, 1.1rem + .5vw, 1.5rem);--text-4: clamp(1.125rem, 1.05rem + .3vw, 1.25rem);--text-5: 1.125rem;--text-6: 1rem;--text-7: .875rem;--text-8: .75rem;--text-regular: var(--text-6);--leading-normal: 1.5;--font-normal: 400;--font-medium: 500;--font-semibold: 600;--font-bold: 600;--shadow-small: 0 1px 2px 0 rgb(0 0 0 / .05);--shadow-medium: 0 1px 3px 0 rgb(0 0 0 / .1), 0 1px 2px -1px rgb(0 0 0 / .1);--shadow-large: 0 4px 6px -1px rgb(0 0 0 / .1), 0 2px 4px -2px rgb(0 0 0 / .1);--transition-fast: .12s cubic-bezier(.4, 0, .2, 1);--transition: .2s cubic-bezier(.4, 0, .2, 1);--z-dropdown: 50;--z-modal: 200}}@layer animations{.animate-pop-in{opacity:1;transform:perspective(1000px) rotateX(0) translateZ(0);transition:opacity .15s cubic-bezier(.4,0,.2,1),transform .15s cubic-bezier(.4,0,.2,1),overlay .15s cubic-bezier(.4,0,.2,1) allow-discrete,display .15s cubic-bezier(.4,0,.2,1) allow-discrete;@starting-style{opacity:0;transform:perspective(1000px) rotateX(-15deg) translateZ(-80px)}&[data-state=closing]{opacity:0;transform:perspective(1000px) rotateX(-15deg) translateZ(-80px)}&[data-state=closing]::backdrop{opacity:0}}dialog::backdrop{opacity:1;transition:opacity .15s cubic-bezier(.4,0,.2,1);@starting-style{opacity:0}}.animate-slide-in{opacity:1;transform:translate(0);transition:opacity .15s cubic-bezier(.16,1,.3,1),transform .15s cubic-bezier(.16,1,.3,1);@starting-style{opacity:0;transform:translate(100%)}&[data-state=closing]{opacity:0;transform:translate(100%)}}}@layer base{:is(button,[type=submit],[type=reset],[type=button],a.button),::file-selector-button{--_hov: color-mix(in srgb, var(--primary), white 25%);display:inline-flex;align-items:center;justify-content:center;gap:var(--space-2);padding:var(--space-2) var(--space-4);font-size:var(--text-7);font-weight:var(--font-medium);line-height:var(--leading-normal);white-space:nowrap;text-decoration:none;background-color:var(--primary);color:var(--primary-foreground);border-radius:var(--radius-medium);border:1px solid;border-color:rgb(from #fff r g b / .15) rgb(from #000 r g b / .2) rgb(from #000 r g b / .2) rgb(from #fff r g b / .15);transition:background-color var(--transition-fast),opacity var(--transition-fast),transform var(--transition-fast);&:not(:disabled){cursor:pointer}&:hover:not(:disabled){background-color:var(--_hov)}&:active:not(:disabled){transform:translate(1px,1px)}&[data-variant=secondary]{--_hov: color-mix(in srgb, var(--secondary), black 10%);background-color:var(--secondary);color:var(--secondary-foreground);border-color:rgb(from #fff r g b / .5) rgb(from #000 r g b / .1) rgb(from #000 r g b / .1) rgb(from #fff r g b / .5)}&[data-variant=danger]{--_hov: color-mix(in srgb, var(--danger), black 15%);background-color:var(--danger);color:var(--danger-foreground)}&:is(.outline,.ghost){--_hov: var(--accent);background-color:transparent;color:var(--foreground);&[data-variant=danger]{--_hov: color-mix(in srgb, var(--danger), transparent 90%);color:var(--danger)}&[data-variant=secondary]{--_hov: color-mix(in srgb, var(--secondary), transparent 80%);color:var(--secondary-foreground)}}&.outline{border-color:var(--border);&[data-variant=danger]{border-color:var(--danger)}&[data-variant=secondary]{border-color:var(--secondary)}}&.ghost{border-color:transparent}&.small{padding:var(--space-1) var(--space-3);font-size:var(--text-8)}&.large{height:3rem;padding:0 var(--space-6);font-size:var(--text-regular)}&.icon{width:2.5rem;padding:0;&.small{width:2rem}&.large{width:3rem}}}::file-selector-button{background-color:transparent;color:var(--foreground);border:1px solid var(--border)}::file-selector-button:hover{background-color:var(--accent)}}@layer components{menu.buttons{list-style-type:none;padding-inline-start:0;display:inline-flex;>li{&:first-child>*{border-start-start-radius:var(--radius-medium);border-end-start-radius:var(--radius-medium)}&:last-child>*{border-start-end-radius:var(--radius-medium);border-end-end-radius:var(--radius-medium)}>*{border-radius:0}&:not(:last-child)>*{border-inline-end:1px solid rgb(from var(--primary-foreground) r g b / .2)}}}}@layer base{label{display:block;font-size:var(--text-7);font-weight:var(--font-medium);&:has(input:where([type=checkbox],[type=radio])){display:inline-flex;align-items:center;gap:var(--space-2);font-weight:var(--font-normal)}}:where(input:not([type=checkbox],[type=radio],[type=range],[type=file],[type=color]),textarea,select){width:100%;margin-block-start:var(--space-1);padding:var(--space-2) var(--space-3);font-size:var(--text-7);line-height:var(--leading-normal);background-color:var(--background);color:var(--foreground);border:1px solid var(--input);border-radius:var(--radius-medium);transition:border-color var(--transition-fast),box-shadow var(--transition-fast);&::placeholder{color:var(--muted-foreground)}&:focus{outline:none;border-color:var(--ring);box-shadow:0 0 0 2px rgb(from var(--ring) r g b / .2);z-index:1}&:disabled{background-color:var(--muted)}&:is([aria-invalid=true],:user-invalid){border-color:var(--danger);&:focus{box-shadow:0 0 0 2px rgb(from var(--danger) r g b / .2)}}}textarea{height:auto;min-height:5rem;padding:var(--space-3);resize:vertical}select{appearance:none;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 24 24' fill='none' stroke='%2371717a' stroke-width='2'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right var(--space-2) center;padding-inline-end:var(--space-6)}input:where([type=checkbox],[type=radio]){appearance:none;width:1rem;height:1rem;margin:0;position:relative;background-color:var(--background);border:1px solid var(--input);transition:background-color var(--transition-fast),border-color var(--transition-fast);&:checked{background-color:var(--primary);border-color:var(--primary);&:after{content:"";position:absolute;inset:0;background-color:var(--primary-foreground);mask-position:center;mask-repeat:no-repeat;mask-size:100%}}}input[type=checkbox]{border-radius:var(--radius-small);&:checked:after{mask-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='currentColor' stroke-width='4'%3E%3Cpolyline points='20 6 9 17 4 12'/%3E%3C/svg%3E")}&[role=switch]{--switch-height: calc(var(--bar-height) * 3);--switch-inset: 2px;--switch-thumb: calc(var(--switch-height) - var(--switch-inset) * 3);width:calc(var(--switch-height) * 2);height:var(--switch-height);border-radius:var(--radius-full);background-color:var(--input);&:before{content:"";position:absolute;top:50%;left:var(--switch-inset);transform:translateY(-50%);width:var(--switch-thumb);height:var(--switch-thumb);background-color:var(--background);border-radius:var(--radius-full);transition:transform var(--transition);box-shadow:var(--shadow-small)}&:checked{background-color:var(--primary);&:after{content:none}&:before{transform:translateY(-50%) translate(var(--switch-height))}}}}input[type=radio]{border-radius:var(--radius-full);&:checked:after{mask-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Ccircle cx='8' cy='8' r='4' fill='currentColor'/%3E%3C/svg%3E")}}:where(input:where([type=checkbox],[type=radio],[type=range]),select):not(:disabled),label:has(input:where([type=checkbox],[type=radio]):not(:disabled)){cursor:pointer}input[type=range]{width:100%;height:var(--bar-height);appearance:none;background:var(--muted);border-radius:var(--radius-full);&::-webkit-slider-thumb{appearance:none;width:1.25rem;height:1.25rem;background:var(--primary);border-radius:var(--radius-full);transition:transform var(--transition-fast);&:hover{transform:scale(1.1)}}&::-moz-range-thumb{width:1.25rem;height:1.25rem;background:var(--primary);border:none;border-radius:var(--radius-full)}}fieldset{border:1px solid var(--border);border-radius:var(--radius-medium);padding:var(--space-4);margin-block-end:var(--space-4)}legend{font-size:var(--text-7);font-weight:var(--font-medium);padding:0 var(--space-2)}}@layer components{fieldset.group{display:flex;align-items:stretch;border:none;padding:0;margin:0;>:is(input,textarea,select){flex:1;margin-block-start:0;&:not(:focus):not(:last-child){border-inline-end-color:transparent}}>:is(input,textarea,select,button){border-radius:0;&:first-child{border-radius:var(--radius-medium) 0 0 var(--radius-medium)}&:last-child{border-radius:0 var(--radius-medium) var(--radius-medium) 0}}>legend{float:inline-start;display:inline-flex;align-items:center;padding:0 var(--space-3);line-height:var(--leading-normal);font-weight:var(--font-normal);color:var(--muted-foreground);background-color:var(--muted);border:1px solid var(--input);border-inline-end:none;border-radius:var(--radius-medium) 0 0 var(--radius-medium)}}[data-field]{margin-block-end:var(--space-4);[data-hint],.error{font-size:var(--text-8);font-weight:var(--font-normal);color:var(--muted-foreground);margin-block-start:var(--space-1)}.error{display:none}&[data-field=error] .error{display:block;color:var(--danger)}}}@layer base{.table{min-width:320px;width:100%;overflow-x:auto}table{border-collapse:collapse;width:100%;font-size:var(--text-7)}thead{border-bottom:1px solid var(--border)}th,td{overflow-wrap:break-word}th{padding:var(--space-3) var(--space-2);text-align:start;font-weight:var(--font-medium);color:var(--muted-foreground)}td{padding:var(--space-3) var(--space-2)}tbody tr{border-bottom:1px solid var(--border);transition:background-color var(--transition-fast);&:last-child{border-bottom:none}&:hover{background-color:rgb(from var(--muted) r g b / .5)}}}@layer base{progress{appearance:none;width:100%;height:var(--bar-height);border:none;border-radius:var(--radius-full);overflow:hidden;background-color:var(--muted);&::-webkit-progress-bar{background-color:var(--muted);border-radius:var(--radius-full)}&::-webkit-progress-value{background-color:var(--primary);border-radius:var(--radius-full);transition:width var(--transition)}&::-moz-progress-bar{background-color:var(--primary);border-radius:var(--radius-full)}}meter{appearance:none;width:100%;height:var(--bar-height);border:none;border-radius:var(--radius-full);overflow:hidden;background:var(--muted);&::-webkit-meter-bar{background:var(--muted);border:none;border-radius:var(--radius-full);height:var(--bar-height)}&::-webkit-meter-optimum-value,&::-webkit-meter-suboptimum-value,&::-webkit-meter-even-less-good-value{border-radius:var(--radius-full)}&::-webkit-meter-optimum-value{background:var(--success)}&::-webkit-meter-suboptimum-value{background:var(--warning)}&::-webkit-meter-even-less-good-value{background:var(--danger)}&::-moz-meter-bar{background:var(--success);border-radius:var(--radius-full)}&:-moz-meter-sub-optimum::-moz-meter-bar{background:var(--warning)}&:-moz-meter-sub-sub-optimum::-moz-meter-bar{background:var(--danger)}}}@layer components{[aria-busy=true]{&:before{content:"";display:inline-block;inset:0;margin:auto;width:1.5rem;height:1.5rem;border:2px solid var(--muted);border-top-color:var(--primary);border-radius:var(--radius-full);animation:spin 1s linear infinite;text-align:center}&[data-spinner~=small]:before{width:1rem;height:1rem}&[data-spinner~=large]:before{width:2rem;height:2rem;border-width:3px}&[data-spinner~=overlay]{position:relative;>*{opacity:.3;pointer-events:none}&:before{position:absolute;inset:0;margin:auto;z-index:1}}}@keyframes spin{to{transform:rotate(360deg)}}}@layer components{:root{--grid-cols: 12;--grid-gap: 1.5rem;--container-max: 1280px;--container-pad: 1rem}.container{width:100%;max-width:var(--container-max);margin-inline:auto;padding-inline:var(--container-pad)}.row{display:grid;grid-template-columns:repeat(var(--grid-cols),1fr);gap:var(--grid-gap);width:100%}.col,[class*=col-]{grid-column-end:span var(--span, var(--grid-cols))}.col-1{--span: 1}.col-2{--span: 2}.col-3{--span: 3}.col-4{--span: 4}.col-5{--span: 5}.col-6{--span: 6}.col-7{--span: 7}.col-8{--span: 8}.col-9{--span: 9}.col-10{--span: 10}.col-11{--span: 11}.col-12{--span: 12}.offset-1{grid-column-start:2}.offset-2{grid-column-start:3}.offset-3{grid-column-start:4}.offset-4{grid-column-start:5}.offset-5{grid-column-start:6}.offset-6{grid-column-start:7}.col-end{grid-column-start:span var(--span, 1);grid-column-end:-1}@media(max-width:768px){.row{--grid-cols: 4;--grid-gap: 1rem}.col,[class*=col-]{--span: 4}[class*=offset-]{grid-column-start:auto}}}@layer components{.card{background-color:var(--card);color:var(--card-foreground);border:1px solid var(--border);border-radius:var(--radius-medium);box-shadow:var(--shadow-small);padding:var(--space-6);overflow:hidden}}@layer components{[role=alert]{position:relative;display:flex;gap:var(--space-3);padding:var(--space-4) var(--space-6);background-color:var(--background);border:1px solid var(--border);border-radius:var(--radius-medium);font-size:var(--text-7);&[data-variant]{border:none}&[data-variant=error],&[data-variant=danger]{color:var(--danger);background-color:light-dark(color-mix(in srgb,var(--danger) 8%,transparent),color-mix(in srgb,var(--danger) 20%,transparent));& a{color:var(--danger)}}&[data-variant=success]{color:var(--success);background-color:light-dark(color-mix(in srgb,var(--success) 8%,transparent),color-mix(in srgb,var(--success) 20%,transparent));& a{color:var(--success)}}&[data-variant=warning]{color:var(--warning);background-color:light-dark(color-mix(in srgb,var(--warning) 8%,transparent),color-mix(in srgb,var(--warning) 20%,transparent));& a{color:var(--warning)}}}}@layer components{.badge{display:inline-flex;align-items:center;gap:var(--space-1);padding:var(--space-1) var(--space-4);font-size:var(--text-8);font-weight:var(--font-medium);line-height:var(--leading-normal);background-color:var(--primary);color:var(--primary-foreground);border-radius:var(--radius-full);&.secondary{background-color:var(--secondary);color:var(--secondary-foreground)}&.outline{background-color:transparent;color:var(--foreground);border:1px solid var(--border)}&.success{color:var(--success);background-color:light-dark(color-mix(in srgb,var(--success) 10%,transparent),color-mix(in srgb,var(--success) 30%,transparent))}&.warning{color:var(--warning);background-color:light-dark(color-mix(in srgb,var(--warning) 10%,transparent),color-mix(in srgb,var(--warning) 30%,transparent))}&.danger{color:var(--danger);background-color:light-dark(color-mix(in srgb,var(--danger) 10%,transparent),color-mix(in srgb,var(--danger) 30%,transparent))}}}@layer components{details{border:1px solid var(--border);border-radius:var(--radius-medium);overflow:hidden;+details{margin-top:-1px;border-start-start-radius:0;border-start-end-radius:0}&:has(+details){border-end-start-radius:0;border-end-end-radius:0}&[open] summary{border-bottom:1px solid var(--border)}}summary{display:flex;align-items:center;justify-content:space-between;gap:var(--space-2);padding:var(--space-4);font-weight:var(--font-medium);cursor:pointer;user-select:none;transition:background-color var(--transition-fast);&:hover{background-color:var(--muted)}&::-webkit-details-marker,&::marker{display:none}&:after{content:"";width:1em;height:1em;flex-shrink:0;background-color:currentColor;mask-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='currentColor' stroke-width='2'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");mask-size:contain;mask-repeat:no-repeat;transition:transform var(--transition-fast)}details[open] &:after{transform:rotate(180deg)}}details>*:not(summary){margin:var(--space-4)}}@layer components{[role=tablist]{display:inline-flex;align-items:center;gap:var(--space-1);padding:var(--space-1);background-color:var(--muted);border-radius:var(--radius-medium)}[role=tab]{display:inline-flex;align-items:center;justify-content:center;padding:var(--space-2) var(--space-3);font-size:var(--text-7);font-weight:var(--font-medium);white-space:nowrap;background-color:transparent;color:var(--foreground);border:none;border-radius:calc(var(--radius-medium) - 2px);cursor:pointer;transition:background-color var(--transition-fast),color var(--transition-fast);&:hover{color:var(--muted-foreground)}&[aria-selected=true]{background-color:var(--background);box-shadow:var(--shadow-small)}}[role=tabpanel]{padding:var(--space-4) 0;&:focus-visible{outline:none}}}@layer components{dialog{position:fixed;inset:0;z-index:var(--z-modal);width:min(100% - 2rem,32rem);max-height:85vh;margin:auto;padding:0;background-color:var(--card);border:1px solid var(--border);border-radius:var(--radius-large);box-shadow:var(--shadow-large);overflow:hidden;opacity:0;transform:scale(.95);transition:opacity .15s ease,transform .15s ease,overlay .15s ease allow-discrete,display .15s ease allow-discrete;&[open]{opacity:1;transform:scale(1)}@starting-style{&[open]{opacity:0;transform:scale(.95)}}&::backdrop{background-color:#0000;transition:background-color .15s ease,overlay .15s ease allow-discrete,display .15s ease allow-discrete}&[open]::backdrop{background-color:#00000080}@starting-style{&[open]::backdrop{background-color:#0000}}>header,>form>header{display:flex;flex-direction:column;gap:var(--space-1);padding:var(--space-6);padding-block-end:0;>h1,>h2,>h3,>h4,>h5,>h6{margin-block-end:0}>p{font-size:var(--text-7);color:var(--muted-foreground);margin-block-end:0}}>p,>div,>section,>form>p,>form>div,>form>section{padding:var(--space-6);overflow-y:auto}>footer,>form>footer{display:flex;justify-content:flex-end;gap:var(--space-2);padding:var(--space-6);padding-block-start:0}}}@layer components{ot-dropdown{[popover]{position:fixed;margin:0;min-width:12rem;background-color:var(--background);border:1px solid var(--border);border-radius:var(--radius-medium);box-shadow:var(--shadow-medium);opacity:0;transform:translateY(-4px);transition:opacity .15s ease-out,transform .15s ease-out,display .15s allow-discrete,overlay .15s allow-discrete;&:popover-open{opacity:1;transform:translateY(0)}@starting-style{&:popover-open{opacity:0;transform:translateY(-4px)}}}[role=menuitem]{display:flex;align-items:center;justify-content:start;gap:var(--space-2);width:100%;padding:var(--space-2) var(--space-3);font-size:var(--text-7);text-align:start;color:var(--foreground);background:none;border:none;border-radius:var(--radius-small);cursor:pointer;&:hover,&:focus{background-color:var(--accent);outline:none}}}}@layer components{.toast-container{position:fixed;display:flex;flex-direction:column;pointer-events:none;margin:0;padding:0;border:none;background:transparent;overflow:visible;&::backdrop{display:none}&[data-placement=top-left]{inset:var(--space-4) auto auto var(--space-4)}&[data-placement=top-center]{inset:var(--space-4) auto auto 50%;transform:translate(-50%)}&[data-placement=top-right]{inset:var(--space-4) var(--space-4) auto auto}&[data-placement=bottom-left]{inset:auto auto var(--space-4) var(--space-4);flex-direction:column-reverse}&[data-placement=bottom-center]{inset:auto auto var(--space-4) 50%;transform:translate(-50%);flex-direction:column-reverse}&[data-placement=bottom-right]{inset:auto var(--space-4) var(--space-4) auto;flex-direction:column-reverse}}.toast{--transition: .3s;--transition-in: calc(var(--transition) - 50ms);padding:var(--space-5) var(--space-4);max-width:28rem;min-width:20rem;pointer-events:auto;background-color:var(--card);border:1px solid var(--border);border-inline-start-width:var(--space-1);border-inline-start-style:solid;border-radius:var(--radius-medium);box-shadow:var(--shadow-small);transition:opacity var(--transition-in),transform var(--transition-in),margin var(--transition-in);line-height:1;.toast-title{font-weight:600;margin:0 0 var(--space-3) 0}.toast-message{color:var(--muted-foreground)}&[data-variant=success]{border-inline-start-color:var(--success);.toast-title{color:var(--success)}}&[data-variant=danger]{border-inline-start-color:var(--danger);.toast-title{color:var(--danger)}}&[data-variant=warning]{border-inline-start-color:var(--warning);.toast-title{color:var(--warning)}}>[data-close]{margin-inline-start:auto;background:none;border:none;padding:0;cursor:pointer;opacity:.5;&:hover{opacity:1}}margin:var(--space-2) 0;&[data-entering]{opacity:0;transform:translateY(-1rem)}&[data-exiting]{opacity:0;margin:0;padding-block:0;max-height:0;overflow:hidden;transition:opacity var(--transition),margin var(--transition),padding var(--transition),max-height var(--transition)}}}@layer components{[data-sidebar-layout]{display:grid;grid-template-columns:14rem 1fr;grid-template-rows:auto 1fr;height:100dvh;>main{grid-row:2;min-width:0;overflow-y:auto}>aside[data-sidebar]{grid-row:2;min-height:0;z-index:1;background-color:var(--background);border-inline-end:1px solid var(--border);box-shadow:var(--shadow-medium);display:flex;flex-direction:column;>:is(header,footer){flex-shrink:0;padding:var(--space-3)}>footer{margin-block-start:auto}>nav{flex:1;min-height:0;overflow-y:auto;padding:var(--space-3) var(--space-2);font-size:var(--text-7);ul{list-style:none;padding:0;margin:0;display:flex;flex-direction:column;gap:var(--space-1);li{margin:0}}a{display:flex;gap:var(--space-2);padding:var(--space-1) var(--space-3);color:var(--foreground);text-decoration:none;border-radius:var(--radius-small);transition:background-color var(--transition-fast);&:is(:hover,[aria-current]){background-color:var(--accent)}}details{border:none;overflow:visible;+details{margin-top:0}&[open] summary{border-bottom:none}>ul{margin-inline-start:var(--space-4);padding:var(--space-1) 0}}summary{justify-content:flex-start;padding:var(--space-2) var(--space-3);border-radius:var(--radius-small);&:after{width:.75rem;height:.75rem;margin-inline-start:auto}}}}>nav[data-topnav]{grid-column:1 / -1}}nav[data-topnav]{position:sticky;top:0;z-index:5;display:flex;align-items:center;gap:var(--space-3);padding:var(--space-2) var(--space-4);background-color:var(--background);border-bottom:1px solid var(--border);box-shadow:var(--shadow-small);a{text-decoration:none}}:is([data-sidebar-toggle],[data-sidebar-header]){display:none}[data-sidebar-toggle]{padding:0 var(--space-1);background:none;border:1px solid var(--border);border-radius:var(--radius-small)}@media(min-width:769px){[data-sidebar-layout=always]{transition:grid-template-columns var(--transition);[data-sidebar-toggle]{display:inline-block}>aside[data-sidebar]{transform:translate(0);opacity:1;transition:transform var(--transition),opacity var(--transition),visibility var(--transition)}&[data-sidebar-open]{grid-template-columns:0px 1fr;gap:0;>aside[data-sidebar]{overflow:hidden;min-width:0;transform:translate(-100%);opacity:0;visibility:hidden;border-inline-end:none}}}}@media(max-width:768px){[data-sidebar-layout]{grid-template-columns:1fr;>main{grid-column:1}>aside[data-sidebar]{grid-column:1;z-index:2;width:16rem;transform:translate(-100%);transition:transform var(--transition);box-shadow:var(--shadow-large)}&[data-sidebar-open]>aside[data-sidebar]{transform:translate(0)}}[data-sidebar-toggle]{display:inline-block}[data-sidebar-header]{display:flex;align-items:center;gap:var(--space-3);padding:var(--space-3) var(--space-4);border-bottom:1px solid var(--border)}}}@layer components{[role=status].skeleton{--_c: light-dark( color-mix(in srgb, var(--muted) 30%, white), color-mix(in srgb, var(--muted) 90%, var(--foreground)) );margin-block-end:var(--space-3);background:var(--muted);border-radius:var(--radius-medium);animation:anim 2s infinite;background-size:200% 100%;background-image:linear-gradient(90deg,var(--muted) 0%,var(--_c) 50%,var(--muted) 100%);&.box{width:4rem;height:4rem}&.line{height:1rem;width:100%}}[role=status].skeleton:last-child{margin-block-end:0}@keyframes anim{0%{background-position:200% 0}to{background-position:-200% 0}}}@layer components{[data-tooltip]{position:relative}[data-tooltip]:before,[data-tooltip]:after{position:absolute;inset-inline-start:50%;opacity:0;visibility:hidden;transition:opacity var(--transition-fast),transform var(--transition-fast),visibility var(--transition-fast);pointer-events:none;z-index:1000}[data-tooltip]:after{content:attr(data-tooltip);inset-block-end:calc(100% + 10px);transform:translate(-50%) translateY(4px);padding:var(--space-2) var(--space-3);font-size:var(--text-7);line-height:1;white-space:nowrap;background:var(--foreground);color:var(--background);border-radius:var(--radius-medium)}[data-tooltip]:before{content:"";inset-block-end:calc(100% - 5px);transform:translate(-50%) translateY(4px);border:8px solid transparent;border-top-color:var(--foreground)}[data-tooltip]:is(:hover,:focus-visible):before,[data-tooltip]:is(:hover,:focus-visible):after{opacity:1;visibility:visible;transition-delay:.7s;transform:translate(-50%) translateY(0)}}@layer utilities{.align-left{text-align:start}.align-center{text-align:center}.align-right{text-align:end}.text-light{color:var(--muted-foreground)}.text-lighter{color:var(--faint-foreground)}.flex{display:flex}.flex-col{flex-direction:column}.items-center{align-items:center}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.justify-end{justify-content:flex-end}.hstack{display:flex;align-items:center;gap:var(--space-3);flex-wrap:wrap;align-content:flex-start;height:auto;*{margin:0}}.vstack{display:flex;flex-direction:column;gap:var(--space-3)}.gap-1{gap:var(--space-1)}.gap-2{gap:var(--space-2)}.gap-4{gap:var(--space-4)}.mt-2{margin-block-start:var(--space-2)}.mt-4{margin-block-start:var(--space-4)}.mt-6{margin-block-start:var(--space-6)}.mb-2{margin-block-end:var(--space-2)}.mb-4{margin-block-end:var(--space-4)}.mb-6{margin-block-end:var(--space-6)}.p-4{padding:var(--space-4)}.w-100{width:100%}:is(ul,ol,a).unstyled{list-style:none;text-decoration:none;padding:0}}

web/oat.min.js

···
-(()=>{var l=class extends HTMLElement{#t=!1;connectedCallback(){this.#t||(document.readyState==="loading"?document.addEventListener("DOMContentLoaded",()=>this.#e(),{once:!0}):this.#e())}#e(){this.#t||(this.#t=!0,this.init())}disconnectedCallback(){this.cleanup()}cleanup(){}handleEvent(t){let e=this[`on${t.type}`];e&&e.call(this,t)}keyNav(t,e,n,o,s,a=!1){let{key:r}=t,c=-1;return r===s?c=(e+1)%n:r===o?c=(e-1+n)%n:a&&(r==="Home"?c=0:r==="End"&&(c=n-1)),c>=0&&t.preventDefault(),c}emit(t,e=null){return this.dispatchEvent(new CustomEvent(t,{bubbles:!0,composed:!0,cancelable:!0,detail:e}))}$(t){return this.querySelector(t)}$$(t){return Array.from(this.querySelectorAll(t))}uid(){return Math.random().toString(36).slice(2,10)}};"commandForElement"in HTMLButtonElement.prototype||document.addEventListener("click",i=>{let t=i.target.closest("button[commandfor]");if(!t)return;let e=document.getElementById(t.getAttribute("commandfor"));if(!e)return;let n=t.getAttribute("command")||"toggle";e instanceof HTMLDialogElement&&(n==="show-modal"?e.showModal():n==="close"||e.open?e.close():e.showModal())});var u=class extends l{#t=[];#e=[];init(){let t=this.$(':scope > [role="tablist"]');if(this.#t=t?[...t.querySelectorAll('[role="tab"]')]:[],this.#e=this.$$(':scope > [role="tabpanel"]'),this.#t.length===0||this.#e.length===0){console.warn("ot-tabs: Missing tab or tabpanel elements");return}this.#t.forEach((n,o)=>{let s=this.#e[o];if(!s)return;let a=n.id||`ot-tab-${this.uid()}`,r=s.id||`ot-panel-${this.uid()}`;n.id=a,s.id=r,n.setAttribute("aria-controls",r),s.setAttribute("aria-labelledby",a)}),t.addEventListener("click",this),t.addEventListener("keydown",this);let e=this.#t.findIndex(n=>n.ariaSelected==="true");this.#i(e>=0?e:0)}onclick(t){let e=this.#t.indexOf(t.target.closest('[role="tab"]'));e>=0&&this.#i(e)}onkeydown(t){if(!t.target.closest('[role="tab"]'))return;let e=this.keyNav(t,this.activeIndex,this.#t.length,"ArrowLeft","ArrowRight");e>=0&&(this.#i(e),this.#t[e].focus())}#i(t){this.#t.forEach((e,n)=>{let o=n===t;e.ariaSelected=String(o),e.tabIndex=o?0:-1}),this.#e.forEach((e,n)=>{e.hidden=n!==t}),this.emit("ot-tab-change",{index:t,tab:this.#t[t]})}get activeIndex(){return this.#t.findIndex(t=>t.ariaSelected==="true")}set activeIndex(t){t>=0&&t<this.#t.length&&this.#i(t)}};customElements.define("ot-tabs",u);var h=class extends l{#t;#e;#i;#n;init(){this.#t=this.$("[popover]"),this.#e=this.$("[popovertarget]"),!(!this.#t||!this.#e)&&(this.#t.addEventListener("toggle",this),this.#t.addEventListener("keydown",this),this.#i=()=>{let t=this.#e.getBoundingClientRect(),e=this.#t.getBoundingClientRect();this.#t.style.top=`${t.bottom+e.height>window.innerHeight?t.top-e.height:t.bottom}px`,this.#t.style.left=`${t.left+e.width>window.innerWidth?t.right-e.width:t.left}px`})}ontoggle(t){t.newState==="open"?(this.#i(),window.addEventListener("scroll",this.#i,!0),window.addEventListener("resize",this.#i),this.#n=this.$$('[role="menuitem"]'),this.#n[0]?.focus(),this.#e.ariaExpanded="true"):(this.cleanup(),this.#n=null,this.#e.ariaExpanded="false",this.#e.focus())}onkeydown(t){if(!t.target.matches('[role="menuitem"]'))return;let e=this.#n.indexOf(t.target),n=this.keyNav(t,e,this.#n.length,"ArrowUp","ArrowDown",!0);n>=0&&this.#n[n].focus()}cleanup(){window.removeEventListener("scroll",this.#i,!0),window.removeEventListener("resize",this.#i)}};customElements.define("ot-dropdown",h);document.addEventListener("DOMContentLoaded",()=>{let i="title",t="[title]",e=n=>{let o=n.getAttribute(i);o&&(n.setAttribute("data-tooltip",o),n.hasAttribute("aria-label")||n.setAttribute("aria-label",o),n.removeAttribute(i))};document.querySelectorAll(t).forEach(e),new MutationObserver(n=>{for(let o of n){e(o.target);for(let s of o.addedNodes)s.nodeType===1&&(e(s),s.querySelectorAll(t).forEach(e))}}).observe(document.body,{childList:!0,subtree:!0,attributes:!0,attributeFilter:[i]})});document.addEventListener("click",i=>{let t=i.target.closest("[data-sidebar-toggle]");if(t){t.closest("[data-sidebar-layout]")?.toggleAttribute("data-sidebar-open");return}if(!i.target.closest("[data-sidebar]")){let e=document.querySelector("[data-sidebar-layout][data-sidebar-open]");e&&window.matchMedia("(max-width: 768px)").matches&&e.removeAttribute("data-sidebar-open")}});var d={};function E(i){if(!d[i]){let t=document.createElement("div");t.className="toast-container",t.setAttribute("popover","manual"),t.setAttribute("data-placement",i),document.body.appendChild(t),d[i]=t}return d[i]}function p(i,t={}){let{placement:e="top-right",duration:n=4e3}=t,o=E(e);i.classList.add("toast");let s;return i.onmouseenter=()=>clearTimeout(s),i.onmouseleave=()=>{n>0&&(s=setTimeout(()=>f(i,o),n))},i.setAttribute("data-entering",""),o.appendChild(i),o.showPopover(),requestAnimationFrame(()=>{requestAnimationFrame(()=>{i.removeAttribute("data-entering")})}),n>0&&(s=setTimeout(()=>f(i,o),n)),i}function f(i,t){if(i.hasAttribute("data-exiting"))return;i.setAttribute("data-exiting","");let e=()=>{i.remove(),t.children.length||t.hidePopover()};i.addEventListener("transitionend",e,{once:!0});let n=getComputedStyle(i).getPropertyValue("--transition").trim(),o=parseFloat(n),s=n.endsWith("ms")?o:o*1e3;setTimeout(e,s)}function b(i,t,e={}){let{variant:n="info",...o}=e,s=document.createElement("output");if(s.setAttribute("data-variant",n),t){let r=document.createElement("h6");r.className="toast-title",r.textContent=t,s.appendChild(r)}let a=document.createElement("div");return a.className="toast-message",a.textContent=i,s.appendChild(a),p(s,o)}function g(i,t={}){let e;if(i instanceof HTMLTemplateElement?e=i.content.firstElementChild?.cloneNode(!0):i&&(e=i.cloneNode(!0)),!!e)return e.removeAttribute("id"),p(e,t)}function v(i){i&&d[i]?(d[i].innerHTML="",d[i].hidePopover()):Object.values(d).forEach(t=>{t.innerHTML="",t.hidePopover()})}var m=window.ot||(window.ot={});m.toast=b;m.toast.el=g;m.toast.clear=v;})();

web/package.json

···
+{
+  "name": "fantasma-web",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "prebuild": "cp ../zig-out/bin/fantasma.wasm public/",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@knadh/oat": "^0.4.1",
+    "zod": "^4.3.6",
+    "zustand": "^5.0.11"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1"
+  }
+}

web/src/db.ts

···
+const DB_NAME = "fantasma";
+const DB_VERSION = 1;
+const STORE_NAME = "model";
+export const WEIGHTS_KEY = "weights";
+
+function openDB(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => req.result.createObjectStore(STORE_NAME);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function dbGet(key: string): Promise<ArrayBuffer | undefined> {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const req = tx.objectStore(STORE_NAME).get(key);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function dbPut(key: string, value: ArrayBuffer): Promise<void> {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const req = tx.objectStore(STORE_NAME).put(value, key);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function dbClear(): Promise<void> {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    tx.objectStore(STORE_NAME).clear();
+    await new Promise<void>((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  } catch {
+    // best effort
+  }
+  try {
+    indexedDB.deleteDatabase(DB_NAME);
+  } catch {
+    // best effort
+  }
+}

web/src/main.ts

···
+import "@knadh/oat/oat.min.css";
+import "./style.css";
+
+import { store } from "./store";
+import { loadWasm, wasmCall, loadModelWeights } from "./wasm";
+import { dbGet, dbPut, dbClear, WEIGHTS_KEY } from "./db";
+import { updateStatus, renderProfile } from "./render";
+
+const $ = (sel: string) => document.querySelector<HTMLElement>(sel)!;
+
+// ============================================================
+// Helpers
+// ============================================================
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1048576) return (bytes / 1024).toFixed(0) + " KB";
+  return (bytes / 1048576).toFixed(1) + " MB";
+}
+
+async function fetchWithProgress(
+  url: string,
+  onProgress: (received: number, total: number) => void,
+): Promise<ArrayBuffer> {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  const total = parseInt(response.headers.get("content-length") || "0", 10);
+  const reader = response.body!.getReader();
+  const chunks: Uint8Array[] = [];
+  let received = 0;
+
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    received += value.length;
+    onProgress(received, total);
+  }
+
+  const result = new Uint8Array(received);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result.buffer;
+}
+
+function wordCount(text: string): number {
+  return text.trim().split(/\s+/).filter(Boolean).length;
+}
+
+// ============================================================
+// Subscribe to store changes
+// ============================================================
+
+store.subscribe((state, prev) => {
+  if (state.status !== prev.status || state.statusMessage !== prev.statusMessage) {
+    updateStatus();
+  }
+});
+
+// ============================================================
+// DOM bindings
+// ============================================================
+
+const inputEl = $("#input-text") as HTMLTextAreaElement;
+const btnAnalyze = $("#btn-analyze") as HTMLButtonElement;
+const btnRetry = $("#btn-retry") as HTMLButtonElement;
+const forensicToggle = $("#forensic-toggle") as HTMLInputElement;
+const forensicPanel = $("#forensic-panel") as HTMLElement;
+const btnDownload = $("#btn-download-model") as HTMLButtonElement;
+const downloadProgress = $("#download-progress") as HTMLElement;
+const progressFill = $("#progress-fill") as HTMLElement;
+const progressText = $("#progress-text") as HTMLElement;
+const btnNeutralize = $("#btn-neutralize") as HTMLButtonElement;
+const btnPanic = $("#btn-panic") as HTMLButtonElement;
+const wordCountEl = $("#word-count") as HTMLElement;
+const resultsSection = $("#results") as HTMLElement;
+
+// Word count
+inputEl.addEventListener("input", () => {
+  const words = wordCount(inputEl.value);
+  wordCountEl.textContent = words + " word" + (words !== 1 ? "s" : "");
+  btnAnalyze.disabled = !store.getState().wasmInstance || words < 3;
+});
+
+// Forensic toggle
+forensicToggle.addEventListener("change", () => {
+  store.getState().toggleForensic(forensicToggle.checked);
+  forensicPanel.hidden = !forensicToggle.checked;
+});
+
+// Analyze
+btnAnalyze.addEventListener("click", () => {
+  const text = inputEl.value.trim();
+  const { wasmInstance } = store.getState();
+  if (!text || !wasmInstance) return;
+
+  btnAnalyze.disabled = true;
+  btnAnalyze.classList.add("btn-loading");
+  btnAnalyze.textContent = "Analyzing";
+
+  try {
+    const result = wasmCall(wasmInstance, "profile", text);
+    store.getState().setProfileResult(result);
+    renderProfile(result);
+  } catch (e) {
+    console.error("Profile error:", e);
+    store.getState().setStatus("error", "Analysis failed");
+  } finally {
+    btnAnalyze.disabled = false;
+    btnAnalyze.classList.remove("btn-loading");
+    btnAnalyze.textContent = "Analyze Fingerprint";
+  }
+});
+
+// Download model
+btnDownload.addEventListener("click", async () => {
+  btnDownload.disabled = true;
+  downloadProgress.hidden = false;
+
+  try {
+    progressText.textContent = "Downloading model...";
+    progressFill.style.width = "0%";
+
+    const weightsBytes = await fetchWithProgress("/model.bin", (recv, total) => {
+      if (total > 0) {
+        const pct = Math.round((recv / total) * 100);
+        progressFill.style.width = pct + "%";
+        progressText.textContent = `${formatBytes(recv)} / ${formatBytes(total)}`;
+      } else {
+        progressText.textContent = formatBytes(recv);
+      }
+    });
+
+    await dbPut(WEIGHTS_KEY, weightsBytes);
+    progressText.textContent = "Initializing model...";
+    progressFill.style.width = "100%";
+
+    const { wasmInstance } = store.getState();
+    if (wasmInstance && loadModelWeights(wasmInstance, weightsBytes)) {
+      store.getState().setModelLoaded(true);
+      downloadProgress.hidden = true;
+      btnDownload.hidden = true;
+      btnNeutralize.hidden = false;
+      store.getState().setStatus("model-ready");
+    } else {
+      progressText.textContent = "Model init failed";
+      btnDownload.disabled = false;
+    }
+  } catch (e) {
+    console.error("Download error:", e);
+    progressText.textContent = "Model not available yet";
+    progressFill.style.width = "0%";
+    btnDownload.disabled = false;
+  }
+});
+
+// Neutralize
+btnNeutralize.addEventListener("click", () => {
+  const text = inputEl.value.trim();
+  const { wasmInstance, modelLoaded } = store.getState();
+  if (!text || !wasmInstance || !modelLoaded) return;
+
+  btnNeutralize.disabled = true;
+  btnNeutralize.classList.add("btn-loading");
+  btnNeutralize.textContent = "Neutralizing";
+
+  try {
+    const result = wasmCall(wasmInstance, "neutralize", text);
+    store.getState().setProfileResult(result);
+    renderProfile(result);
+  } catch (e) {
+    console.error("Neutralize error:", e);
+  } finally {
+    btnNeutralize.disabled = false;
+    btnNeutralize.classList.remove("btn-loading");
+    btnNeutralize.textContent = "Neutralize";
+  }
+});
+
+// Panic
+btnPanic.addEventListener("click", async () => {
+  inputEl.value = "";
+  wordCountEl.textContent = "0 words";
+  btnAnalyze.disabled = true;
+  resultsSection.hidden = true;
+  $("#markers-container").innerHTML = "";
+  $("#forensic-table-body").innerHTML = "";
+  forensicToggle.checked = false;
+  forensicPanel.hidden = true;
+
+  await dbClear();
+
+  if ("serviceWorker" in navigator) {
+    const regs = await navigator.serviceWorker.getRegistrations();
+    for (const reg of regs) reg.unregister();
+  }
+  if ("caches" in window) {
+    const names = await caches.keys();
+    for (const name of names) await caches.delete(name);
+  }
+
+  try {
+    sessionStorage.clear();
+  } catch {}
+  try {
+    localStorage.clear();
+  } catch {}
+
+  store.getState().reset();
+
+  document.title = "";
+  document.body.innerHTML = "";
+  history.replaceState(null, "", "about:blank");
+});
+
+// Retry
+btnRetry.addEventListener("click", () => {
+  resultsSection.hidden = true;
+  inputEl.focus();
+});
+
+// ============================================================
+// Init
+// ============================================================
+
+async function init() {
+  store.getState().setStatus("loading");
+
+  try {
+    const instance = await loadWasm();
+    store.getState().setWasmInstance(instance);
+    store.getState().setStatus("ready");
+
+    const words = wordCount(inputEl.value);
+    if (words >= 3) btnAnalyze.disabled = false;
+
+    try {
+      const storedWeights = await dbGet(WEIGHTS_KEY);
+      if (storedWeights) {
+        if (loadModelWeights(instance, storedWeights)) {
+          store.getState().setModelLoaded(true);
+          store.getState().setStatus("model-ready");
+        }
+      }
+    } catch {
+      // IndexedDB not available
+    }
+  } catch (e) {
+    console.error("WASM load failed:", e);
+    store.getState().setStatus("error", "Engine unavailable");
+  }
+}
+
+init();
+
+if ("serviceWorker" in navigator) {
+  navigator.serviceWorker.register("/sw.js").catch(() => {});
+}

web/src/render.ts

···
+import type { ProfileResult, Marker } from "./schemas";
+import { store } from "./store";
+
+const FEATURE_LABELS: Record<string, string> = {
+  avg_word_length: "Avg word length",
+  vocabulary_richness: "Vocabulary richness",
+  hapax_ratio: "Hapax ratio",
+  avg_sentence_length: "Avg sentence length",
+  sentence_length_variance: "Sentence length variance",
+  passive_voice_ratio: "Passive voice ratio",
+  contraction_rate: "Contraction rate",
+  semicolon_rate: "Semicolon rate",
+  comma_rate: "Comma rate",
+  dash_rate: "Dash rate",
+  exclamation_rate: "Exclamation rate",
+  hyphenation_rate: "Hyphenation rate",
+};
+
+const MARKER_TO_FEATURE: Record<string, string> = {
+  semicolon_high: "semicolon_rate",
+  contraction_high: "contraction_rate",
+  comma_rate: "comma_rate",
+  colon_high: "colon_rate",
+  dash_preference: "dash_rate",
+  exclamation_high: "exclamation_rate",
+  ellipsis_high: "ellipsis_rate",
+  parenthetical_high: "parenthetical_rate",
+  sentence_length_high: "avg_sentence_length",
+  sentence_length_variance_high: "sentence_length_variance",
+  passive_voice_high: "passive_voice_ratio",
+  vocabulary_richness_high: "vocabulary_richness",
+  hapax_ratio_high: "hapax_ratio",
+  hyphenation_high: "hyphenation_rate",
+  avg_word_length: "avg_word_length",
+  avg_syllables: "avg_syllables_per_word",
+};
+
+function esc(str: string): string {
+  const div = document.createElement("div");
+  div.textContent = str;
+  return div.innerHTML;
+}
+
+function formatMarkerName(name: string): string {
+  return name.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+function $(sel: string): HTMLElement {
+  return document.querySelector(sel)!;
+}
+
+export function updateStatus(): void {
+  const { status, statusMessage } = store.getState();
+  const el = $("#status-indicator");
+  el.textContent = statusMessage;
+  el.className = `status status-${status === "model-ready" ? "ready" : status}`;
+}
+
+export function renderProfile(result: ProfileResult): void {
+  const state = store.getState();
+
+  // Summary
+  $("#marker-count").textContent = String(result.markers.length);
+  const summary = $("#results-summary");
+  summary.dataset.variant = result.markers.length === 0 ? "success" : "warning";
+
+  // Markers list
+  const container = $("#markers-container");
+  container.innerHTML = "";
+  for (const m of result.markers) {
+    const item = document.createElement("div");
+    item.className = "change-item";
+    const dir = m.z_score > 0 ? "HIGH" : "LOW";
+    item.innerHTML = `
+      <div class="change-header">
+        <span class="change-marker">${esc(formatMarkerName(m.name))}</span>
+        <span class="change-arrow">${dir}</span>
+      </div>
+      <div class="change-reason">Value: ${m.value.toFixed(4)} &middot; Baseline: ${m.baseline.toFixed(4)} &middot; z = ${m.z_score.toFixed(2)}</div>
+    `;
+    container.appendChild(item);
+  }
+
+  // Marker lookup by feature key
+  const flagged = new Map<string, Marker>();
+  for (const m of result.markers) {
+    const featureKey = MARKER_TO_FEATURE[m.name];
+    if (featureKey) flagged.set(featureKey, m);
+  }
+
+  // Forensic table
+  const forensicBody = $("#forensic-table-body");
+  forensicBody.innerHTML = "";
+  const raw = result as Record<string, unknown>;
+  for (const [key, label] of Object.entries(FEATURE_LABELS)) {
+    if (raw[key] === undefined) continue;
+    const tr = document.createElement("tr");
+    const m = flagged.get(key);
+
+    let statusCls: string, statusTxt: string;
+    if (m) {
+      statusCls = "forensic-warn";
+      statusTxt = m.z_score > 0 ? "\u26a0 High" : "\u26a0 Low";
+    } else {
+      statusCls = "forensic-fixed";
+      statusTxt = "\u2713 Normal";
+    }
+
+    const baseline = m ? m.baseline.toFixed(4) : "\u2014";
+    const val = raw[key];
+    tr.innerHTML = `
+      <td>${esc(label)}</td>
+      <td>${typeof val === "boolean" ? (val ? "Yes" : "No") : (val as number).toFixed(4)}</td>
+      <td>${baseline}</td>
+      <td class="${statusCls}">${statusTxt}</td>
+    `;
+    forensicBody.appendChild(tr);
+  }
+
+  // Rewriter section
+  const rewriterSection = $("#rewriter-section") as HTMLElement;
+  rewriterSection.hidden = false;
+  const btnDownload = $("#btn-download-model") as HTMLElement;
+  const btnNeutralize = $("#btn-neutralize") as HTMLElement;
+  if (state.modelLoaded) {
+    btnDownload.hidden = true;
+    btnNeutralize.hidden = false;
+  } else {
+    btnDownload.hidden = false;
+    btnNeutralize.hidden = true;
+  }
+
+  const resultsSection = $("#results") as HTMLElement;
+  resultsSection.hidden = false;
+  resultsSection.scrollIntoView({ behavior: "smooth", block: "start" });
+}

web/src/schemas.ts

···
+import { z } from "zod";
+
+export const MarkerSchema = z.object({
+  name: z.string(),
+  value: z.number(),
+  baseline: z.number(),
+  z_score: z.number(),
+});
+
+export const ProfileResultSchema = z
+  .object({
+    markers: z.array(MarkerSchema),
+  })
+  .passthrough();
+
+export type Marker = z.infer<typeof MarkerSchema>;
+export type ProfileResult = z.infer<typeof ProfileResultSchema>;

web/src/store.ts

···
+import { createStore } from "zustand/vanilla";
+import type { ProfileResult } from "./schemas";
+
+export interface AppState {
+  status: "loading" | "ready" | "model-ready" | "error";
+  statusMessage: string;
+  wasmInstance: WebAssembly.Instance | null;
+  modelLoaded: boolean;
+  profileResult: ProfileResult | null;
+  forensicVisible: boolean;
+}
+
+export interface AppActions {
+  setStatus(status: AppState["status"], message?: string): void;
+  setWasmInstance(instance: WebAssembly.Instance): void;
+  setModelLoaded(loaded: boolean): void;
+  setProfileResult(result: ProfileResult | null): void;
+  toggleForensic(visible: boolean): void;
+  reset(): void;
+}
+
+const initialState: AppState = {
+  status: "loading",
+  statusMessage: "Loading...",
+  wasmInstance: null,
+  modelLoaded: false,
+  profileResult: null,
+  forensicVisible: false,
+};
+
+export const store = createStore<AppState & AppActions>()((set) => ({
+  ...initialState,
+
+  setStatus: (status, message) =>
+    set({
+      status,
+      statusMessage:
+        message ??
+        { loading: "Loading...", ready: "Ready", "model-ready": "Offline", error: "Error" }[
+          status
+        ],
+    }),
+
+  setWasmInstance: (instance) => set({ wasmInstance: instance }),
+
+  setModelLoaded: (loaded) => set({ modelLoaded: loaded }),
+
+  setProfileResult: (result) => set({ profileResult: result }),
+
+  toggleForensic: (visible) => set({ forensicVisible: visible }),
+
+  reset: () =>
+    set({
+      ...initialState,
+      status: "loading",
+      statusMessage: "Loading...",
+    }),
+}));

web/src/wasm.ts

···
+import { ProfileResultSchema, type ProfileResult } from "./schemas";
+
+export interface FantasmaExports extends WebAssembly.Exports {
+  memory: WebAssembly.Memory;
+  alloc(len: number): number;
+  dealloc(ptr: number, len: number): void;
+  profile(ptr: number, len: number): number;
+  neutralize(ptr: number, len: number): number;
+  init(ptr: number, len: number): number;
+  get_output_ptr(): number;
+  get_output_len(): number;
+}
+
+export async function loadWasm(): Promise<WebAssembly.Instance> {
+  const wasmBytes = await fetch("/fantasma.wasm").then((r) => {
+    if (!r.ok) throw new Error(`HTTP ${r.status}`);
+    return r.arrayBuffer();
+  });
+
+  const { instance } = await WebAssembly.instantiate(wasmBytes, {
+    env: {
+      log_message: (ptr: number, len: number) => {
+        const bytes = new Uint8Array(
+          (instance.exports as unknown as FantasmaExports).memory.buffer,
+          ptr,
+          len,
+        );
+        console.log("[wasm]", new TextDecoder().decode(bytes));
+      },
+    },
+  });
+
+  return instance;
+}
+
+export function wasmCall(
+  instance: WebAssembly.Instance,
+  exportName: "profile" | "neutralize",
+  text: string,
+): ProfileResult {
+  const exports = instance.exports as unknown as FantasmaExports;
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(text);
+  const ptr = exports.alloc(bytes.length);
+  new Uint8Array(exports.memory.buffer, ptr, bytes.length).set(bytes);
+
+  const ok = exports[exportName](ptr, bytes.length);
+  exports.dealloc(ptr, bytes.length);
+  if (!ok) throw new Error(`WASM ${exportName} failed`);
+
+  const outPtr = exports.get_output_ptr();
+  const outLen = exports.get_output_len();
+  const outBytes = new Uint8Array(exports.memory.buffer, outPtr, outLen);
+  const raw = JSON.parse(new TextDecoder().decode(outBytes));
+
+  return ProfileResultSchema.parse(raw);
+}
+
+export function loadModelWeights(
+  instance: WebAssembly.Instance,
+  weightsBytes: ArrayBuffer,
+): boolean {
+  const exports = instance.exports as unknown as FantasmaExports;
+  const arr = new Uint8Array(weightsBytes);
+  const ptr = exports.alloc(arr.length);
+  new Uint8Array(exports.memory.buffer, ptr, arr.length).set(arr);
+  const ok = exports.init(ptr, arr.length);
+  exports.dealloc(ptr, arr.length);
+  return !!ok;
+}

web/tsconfig.json

···
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["src"]
+}

web/vite.config.ts

···
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  root: ".",
+  publicDir: "public",
+  build: {
+    outDir: "dist",
+    emptyOutDir: true,
+  },
+  server: {
+    port: 3000,
+  },
+});