Publish VBL-32M-Utility Native x86_64 v0.1.0

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+bin/linux-x86_64-v3/vbl32m filter=lfs diff=lfs merge=lfs -text

ARCHITECTURE.json

@@ -0,0 +1,38 @@
+{
+  "release": "VBL-32M-Utility",
+  "status": "EXPERIMENTAL_32M_UTILITY_NOT_KR100_PROMOTED",
+  "active_neural_architecture": [
+    "VBL_RC prelude -> shared recurrent core -> coda",
+    "GRT V16_NORM_MEAN",
+    "fixed certified recurrence R2",
+    "state-conditioned token-causal top-k elastic routing",
+    "73 experts x 320->256->320",
+    "router shares expert down.weight[0]; zero extra router parameters",
+    "copy/write gate sigmoid(4 + gate_logits)",
+    "tied embedding/output projection"
+  ],
+  "approved_runtime_policy": [
+    "native Rust x86_64",
+    "AVX2/FMA optimized dot products",
+    "all FP32 model weights resident in RAM",
+    "no mmap",
+    "no SSD streaming",
+    "no quantization",
+    "verified utility routing before raw neural fallback",
+    "abstain on unsupported utility requests",
+    "latent fixed-point distance trace instrumentation",
+    "route/halting trace reports fixed R2 execution"
+  ],
+  "approved_but_not_claimed_active": [
+    "adaptive STOP/CONTINUE: not activated because no certified trained gate exists",
+    "LTP: training-only candidate, not baked into this checkpoint",
+    "RHTM: trace concept only; no trained persistent memory in this checkpoint",
+    "Predictive Compute Prefetch/streaming: disabled because this release is full-RAM by requirement",
+    "K0/K1/K2 residency: not assigned; this release does not invent residency labels"
+  ],
+  "official_32m_c1": {
+    "passed": 583,
+    "total": 853,
+    "kr100": false
+  }
+}

CARGO_BUILD_RELEASE.log

@@ -0,0 +1,104 @@
+   Compiling proc-macro2 v1.0.107
+   Compiling unicode-ident v1.0.24
+   Compiling quote v1.0.47
+   Compiling serde_core v1.0.229
+   Compiling libc v0.2.189
+   Compiling syn v3.0.5
+   Compiling cfg-if v1.0.4
+   Compiling syn v2.0.119
+   Compiling memchr v2.8.3
+   Compiling serde v1.0.229
+   Compiling crossbeam-utils v0.8.23
+   Compiling serde_derive v1.0.229
+   Compiling zerocopy v0.8.57
+   Compiling crossbeam-epoch v0.9.21
+   Compiling strsim v0.11.1
+   Compiling getrandom v0.3.4
+   Compiling ident_case v1.0.1
+   Compiling fnv v1.0.7
+   Compiling darling_core v0.20.11
+   Compiling crossbeam-deque v0.8.8
+   Compiling darling_macro v0.20.11
+   Compiling rayon-core v1.13.0
+   Compiling rustversion v1.0.23
+   Compiling zmij v1.0.23
+   Compiling darling v0.20.11
+   Compiling aho-corasick v1.1.5
+   Compiling itoa v1.0.18
+   Compiling either v1.18.0
+   Compiling getrandom v0.4.3
+   Compiling once_cell v1.21.4
+   Compiling regex-syntax v0.8.11
+   Compiling version_check v0.9.5
+   Compiling rustix v1.1.4
+   Compiling serde_json v1.0.151
+   Compiling ahash v0.8.12
+   Compiling ppv-lite86 v0.2.21
+   Compiling regex-automata v0.4.18
+   Compiling derive_builder_core v0.20.2
+   Compiling rand_core v0.9.5
+   Compiling minimal-lexical v0.2.1
+   Compiling esaxx-rs v0.1.10
+   Compiling bit-vec v0.8.0
+   Compiling thiserror v2.0.20
+   Compiling bitflags v2.13.2
+   Compiling paste v1.0.15
+   Compiling linux-raw-sys v0.12.1
+   Compiling bit-set v0.8.0
+   Compiling nom v7.1.3
+   Compiling rand_chacha v0.9.0
+   Compiling castaway v0.2.4
+   Compiling derive_builder_macro v0.20.2
+   Compiling rayon v1.12.0
+   Compiling itertools v0.14.0
+   Compiling monostate-impl v0.1.18
+   Compiling thiserror-impl v2.0.20
+   Compiling unicode-segmentation v1.13.3
+   Compiling base64 v0.13.1
+   Compiling pastey v0.2.3
+   Compiling equivalent v1.0.2
+   Compiling macro_rules_attribute-proc_macro v0.2.3
+   Compiling foldhash v0.2.0
+   Compiling smallvec v1.16.0
+   Compiling static_assertions v1.1.0
+   Compiling allocator-api2 v0.2.21
+   Compiling fastrand v2.5.0
+   Compiling ryu v1.0.23
+   Compiling anyhow v1.0.104
+   Compiling hashbrown v0.16.1
+   Compiling compact_str v0.9.1
+   Compiling tempfile v3.27.0
+   Compiling unicode-normalization-alignments v0.1.12
+   Compiling macro_rules_attribute v0.2.3
+   Compiling spm_precompiled v0.1.4
+   Compiling monostate v0.1.18
+   Compiling rayon-cond v0.4.0
+   Compiling derive_builder v0.20.2
+   Compiling rand v0.9.5
+   Compiling fancy-regex v0.17.0
+   Compiling regex v1.13.1
+   Compiling dary_heap v0.3.9
+   Compiling log v0.4.34
+   Compiling unicode_categories v0.1.1
+   Compiling daachorse v3.0.3
+   Compiling tokenizers v0.23.2
+   Compiling safetensors v0.8.0
+   Compiling vbl32m v0.1.0 (/content/vbl32m_native_release/VBL-32M-Utility/native)
+warning: fields `format`, `base_parameters`, and `growth_parameters` are never read
+  --> src/main.rs:25:5
+   |
+24 | struct NativeConfig {
+   |        ------------ fields in this struct
+25 |     format: String,
+   |     ^^^^^^
+26 |     parameters: usize,
+27 |     base_parameters: usize,
+   |     ^^^^^^^^^^^^^^^
+28 |     growth_parameters: usize,
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = note: `NativeConfig` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
+   = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
+
+warning: `vbl32m` (bin "vbl32m") generated 1 warning
+    Finished `release` profile [optimized] target(s) in 2m 12s

CARGO_CHECK.log

@@ -0,0 +1,110 @@
+    Updating crates.io index
+     Locking 93 packages to latest compatible versions
+ Downloading crates ...
+  Downloaded bit-set v0.8.0
+  Downloaded bit-vec v0.8.0
+  Downloaded fancy-regex v0.17.0
+   Compiling proc-macro2 v1.0.107
+   Compiling unicode-ident v1.0.24
+   Compiling quote v1.0.47
+   Compiling serde_core v1.0.229
+   Compiling libc v0.2.189
+   Compiling syn v3.0.5
+    Checking cfg-if v1.0.4
+   Compiling syn v2.0.119
+    Checking memchr v2.8.3
+   Compiling crossbeam-utils v0.8.23
+   Compiling serde v1.0.229
+   Compiling serde_derive v1.0.229
+   Compiling strsim v0.11.1
+   Compiling fnv v1.0.7
+   Compiling crossbeam-epoch v0.9.21
+   Compiling getrandom v0.3.4
+   Compiling ident_case v1.0.1
+   Compiling zerocopy v0.8.57
+   Compiling darling_core v0.20.11
+   Compiling crossbeam-deque v0.8.8
+   Compiling darling_macro v0.20.11
+   Compiling rayon-core v1.13.0
+   Compiling zmij v1.0.23
+   Compiling rustversion v1.0.23
+   Compiling darling v0.20.11
+    Checking aho-corasick v1.1.5
+    Checking either v1.18.0
+    Checking regex-syntax v0.8.11
+   Compiling serde_json v1.0.151
+    Checking itoa v1.0.18
+   Compiling version_check v0.9.5
+    Checking once_cell v1.21.4
+   Compiling rustix v1.1.4
+   Compiling getrandom v0.4.3
+   Compiling ahash v0.8.12
+    Checking ppv-lite86 v0.2.21
+    Checking regex-automata v0.4.18
+   Compiling derive_builder_core v0.20.2
+    Checking rand_core v0.9.5
+   Compiling paste v1.0.15
+   Compiling thiserror v2.0.20
+    Checking bit-vec v0.8.0
+    Checking bitflags v2.13.2
+   Compiling esaxx-rs v0.1.10
+    Checking minimal-lexical v0.2.1
+    Checking linux-raw-sys v0.12.1
+    Checking nom v7.1.3
+    Checking bit-set v0.8.0
+    Checking rand_chacha v0.9.0
+    Checking castaway v0.2.4
+   Compiling derive_builder_macro v0.20.2
+    Checking rayon v1.12.0
+    Checking itertools v0.14.0
+   Compiling monostate-impl v0.1.18
+   Compiling thiserror-impl v2.0.20
+    Checking foldhash v0.2.0
+    Checking fastrand v2.5.0
+    Checking base64 v0.13.1
+   Compiling anyhow v1.0.104
+   Compiling macro_rules_attribute-proc_macro v0.2.3
+    Checking allocator-api2 v0.2.21
+    Checking ryu v1.0.23
+    Checking equivalent v1.0.2
+    Checking unicode-segmentation v1.13.3
+    Checking static_assertions v1.1.0
+   Compiling pastey v0.2.3
+    Checking smallvec v1.16.0
+    Checking macro_rules_attribute v0.2.3
+    Checking spm_precompiled v0.1.4
+    Checking unicode-normalization-alignments v0.1.12
+    Checking compact_str v0.9.1
+    Checking hashbrown v0.16.1
+    Checking tempfile v3.27.0
+    Checking monostate v0.1.18
+    Checking rayon-cond v0.4.0
+    Checking derive_builder v0.20.2
+    Checking rand v0.9.5
+    Checking fancy-regex v0.17.0
+    Checking regex v1.13.1
+    Checking dary_heap v0.3.9
+    Checking daachorse v3.0.3
+    Checking unicode_categories v0.1.1
+    Checking log v0.4.34
+    Checking safetensors v0.8.0
+    Checking tokenizers v0.23.2
+    Checking vbl32m v0.1.0 (/content/vbl32m_native_release/VBL-32M-Utility/native)
+warning: fields `format`, `base_parameters`, and `growth_parameters` are never read
+  --> src/main.rs:25:5
+   |
+24 | struct NativeConfig {
+   |        ------------ fields in this struct
+25 |     format: String,
+   |     ^^^^^^
+26 |     parameters: usize,
+27 |     base_parameters: usize,
+   |     ^^^^^^^^^^^^^^^
+28 |     growth_parameters: usize,
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = note: `NativeConfig` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
+   = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
+
+warning: `vbl32m` (bin "vbl32m") generated 1 warning
+    Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.10s

MANIFEST.json

@@ -0,0 +1,53 @@
+{
+  "format": "VBL_32M_UTILITY_NATIVE_X86_RELEASE_V1",
+  "version": "VBL_32M_UTILITY_NATIVE_X86_HF_V2",
+  "parameters": 31974240,
+  "dtype": "FP32",
+  "weight_bytes": 127896960,
+  "weights_sha256": "aa08c34407a32488fe42f112be0d353f65ef8703dbc281ce11711f882bf9bf27",
+  "tokenizer_sha256": "b32e7a10b7a4766e3aae3be9e2ab11c14c7b0637d528df2ffc06151248e1db30",
+  "base_m0_sha256": "148b363527ba77ef77780db7ca00cf37d72e2fcf2ea480910839e31b71cc68c3",
+  "source_v85_checkpoint": "/content/drive/MyDrive/VBL/results/vbl_m0_32m_v8_5_path_independent/edae457e5ca263a13ce4/artifact/vbl_model_state_32m.pt",
+  "source_v85_checkpoint_sha256": "5630360510655334d02bf58c1c8b5e8f82faabc1342cca257d1ec2cabe7d569b",
+  "selected_alpha": 0.75,
+  "official_c1": {
+    "passed": 583,
+    "total": 853,
+    "kr100": false
+  },
+  "native": {
+    "language": "Rust",
+    "target": "x86_64-v3",
+    "required_features": [
+      "AVX2",
+      "FMA"
+    ],
+    "resident_policy": "FULL_RAM_HEAP_NO_MMAP_NO_STREAMING",
+    "linux_binary": "bin/linux-x86_64-v3/vbl32m",
+    "windows_build": "native/build-windows-x86_64.ps1",
+    "parity": {
+      "probe_ids": [
+        4919,
+        31,
+        3188,
+        328,
+        372,
+        392,
+        372,
+        36,
+        204,
+        2775,
+        362,
+        31
+      ],
+      "max_abs_last_logit": 2.384185791015625e-06,
+      "mean_abs_last_logit": 4.4087744299758924e-07,
+      "top1_reference": 204,
+      "top1_native": 204,
+      "pass": true
+    }
+  },
+  "training_performed": false,
+  "canonical_32m": false,
+  "release_role": "UTILITY_EXPERIMENTAL_32M"
+}

README.md

@@ -0,0 +1,112 @@
+---
+tags:
+- vbl
+- recurrent
+- x86-64
+- avx2
+- rust
+- cpu
+- full-ram
+- research
+library_name: custom
+---
+
+# VBL-32M-Utility Native
+
+**31,974,240-parameter VBL utility/research release with a native Rust x86_64 runtime.**
+
+## Native execution
+
+The primary runtime is **not Python/PyTorch**.
+
+- Rust x86_64
+- AVX2 + FMA optimized CPU dot products
+- FP32 weights
+- all model weights loaded into process RAM at startup
+- **no mmap**
+- **no SSD/model streaming**
+- no quantization
+- no GPU required for runtime
+
+FP32 neural parameter payload: **121.97 MiB**.
+
+## Neural architecture
+
+Active checkpoint architecture:
+
+`input -> embedding -> prelude -> [V16_NORM_MEAN + state-conditioned elastic bank + shared recurrent core] x R2 -> coda -> tied output`
+
+- base VBL-RC M0: 20,013,920 parameters
+- connected elastic capacity: 11,960,320 parameters
+- total: 31,974,240
+- 73 experts
+- expert width: 320 -> 256 -> 320
+- top-k: 3
+- router: token-causal, shares expert `down.weight[0]`, zero additional router parameters
+- selected experimental alpha: 0.75
+
+## Verification status
+
+This repository is intentionally named **Utility**, not Verified-32M.
+
+The 32M candidate's official frozen C1 result was:
+
+**583 / 853**
+
+Therefore it is **NOT KR100 promoted**. The canonical M0 lineage remains preserved in the 32M base weights.
+
+## Utility mode
+
+The native executable loads the complete 32M model into RAM and first routes deterministic tasks
+through executable verifiers. Unsupported utility requests abstain instead of fabricating a result.
+
+Examples:
+
+```bash
+./vbl32m --model-dir . "What is 34 + -13?"
+./vbl32m --model-dir . "Is 772 even or odd?"
+./vbl32m --model-dir . "Complete the sequence: 32, 33, 34, 35,"
+```
+
+Raw experimental neural generation:
+
+```bash
+./vbl32m --model-dir . --raw "User: What is 2 + 2? Assistant:"
+```
+
+Trace recurrent state convergence:
+
+```bash
+./vbl32m --model-dir . --raw --trace "User: Hello Assistant:"
+```
+
+## Windows x86_64
+
+The repository includes `native/build-windows-x86_64.ps1`.
+
+On an x86_64 Windows machine with Rust installed:
+
+```powershell
+cd native
+.uild-windows-x86_64.ps1
+```
+
+This produces `native	arget
+
+## VBL architecture policy
+
+See `ARCHITECTURE.json`.
+
+Features that were approved as experimental directions but were not trained/certified in this exact
+checkpoint are explicitly marked inactive instead of being falsely presented as learned behavior.
+Full-RAM residency intentionally disables predictive SSD streaming/prefetch.
+
+## Files
+
+- `model.safetensors` — complete 32M FP32 state
+- `tokenizer.json` — VBL-BPE-24K
+- `native_config.json` — native runtime configuration and parity proof
+- `native/` — Rust source
+- `bin/linux-x86_64-v3/vbl32m` — compiled Linux x86_64 AVX2/FMA binary
+- `ARCHITECTURE.json` — active/inactive VBL architecture contract
+- `MANIFEST.json` / `SHA256SUMS` — provenance

RUST_INSTALL.log

@@ -0,0 +1,44 @@
+info: downloading installer
+warn: it looks like you have an existing rustup settings file at:
+warn: /root/.rustup/settings.toml
+info: profile set to minimal
+info: default host tuple is x86_64-unknown-linux-gnu
+warn: Updating existing toolchain, profile choice will be ignored
+info: syncing channel updates for stable-x86_64-unknown-linux-gnu
+info: default toolchain set to stable-x86_64-unknown-linux-gnu
+
+  stable-x86_64-unknown-linux-gnu unchanged - rustc 1.98.1 (48a229cea 2026-09-01)
+
+
+Rust is installed now. Great!
+
+To get started you may need to restart your current shell.
+This would reload your PATH environment variable to include
+Cargo's bin directory ($HOME/.cargo/bin).
+
+To configure your current shell, you need to source the
+corresponding env file under $HOME/.cargo.
+
+Consider running the right command for your shell (note the leading DOT):
+. "$HOME/.cargo/env" # For sh/ash/dash/pdksh/bash
+cargo:rerun-if-env-changed=CC_x86_64-unknown-linux-gnu
+CC_x86_64-unknown-linux-gnu = None
+cargo:rerun-if-env-changed=CC_x86_64_unknown_linux_gnu
+CC_x86_64_unknown_linux_gnu = None
+cargo:rerun-if-env-changed=HOST_CC
+HOST_CC = None
+cargo:rerun-if-env-changed=CC
+CC = None
+cargo:rerun-if-env-changed=CC_ENABLE_DEBUG_OUTPUT
+cargo:rerun-if-env-changed=CRATE_CC_NO_DEFAULTS
+CRATE_CC_NO_DEFAULTS = None
+cargo:rerun-if-env-changed=CFLAGS
+CFLAGS = None
+cargo:rerun-if-env-changed=HOST_CFLAGS
+HOST_CFLAGS = None
+cargo:rerun-if-env-changed=CFLAGS_x86_64_unknown_linux_gnu
+CFLAGS_x86_64_unknown_linux_gnu = None
+cargo:rerun-if-env-changed=CFLAGS_x86_64-unknown-linux-gnu
+CFLAGS_x86_64-unknown-linux-gnu = None
+rustc 1.98.1 (48a229cea 2026-09-01)
+cargo 1.98.1 (797e8a9bc 2026-08-05)

SHA256SUMS

@@ -0,0 +1,15 @@
+28c770a61afc8cc4066bfd856c41f6ecdfd03b522736b79f54bdff6f36ad7317  ARCHITECTURE.json
+d00490a82132cfc56c21d8780619c9c5dbf39b15eb6f42bda1736f0a29482076  CARGO_BUILD_RELEASE.log
+6ced8bbe8624935152264fd7bc676e0dcdfde0c20078e221f2eee3a079207f0d  CARGO_CHECK.log
+4b8b12d0e52af640388f6df1d93b920a665b84880b7e6335fc0072d3cfe87772  MANIFEST.json
+fb0319921416548097b42d72b98d54000b27a735b0b9246c35204242f239cb27  README.md
+2127f17c34fa8c2aaf34f0aab48ba9021fec04cce193f4c293baf6340014e0d6  RUST_INSTALL.log
+81cf8501b3d0d571b9bab39df5c351958ec04ebddff2afe690b4c0823b92b4ca  bin/linux-x86_64-v3/vbl32m
+aa08c34407a32488fe42f112be0d353f65ef8703dbc281ce11711f882bf9bf27  model.safetensors
+aa1befe0b0f2e07af1b6327e79fb585c2bf330dff1331c56f07308853b853556  native/Cargo.lock
+39482e8172d0ba051b14b17d817e34a008826839164195fad29730050df67e24  native/Cargo.toml
+679c802c67dea2ff0e84cec86ea53114e657cbf0b2df01a8b21512861f8aed5a  native/build-linux-x86_64.sh
+33cf6e9dd273b04bb368c1d9ec26b76d64bc59b958f66a919830400cda7c423b  native/build-windows-x86_64.ps1
+6878196bcd9ba224205dc76b981453e4e8406d2cfaf9cf93f33b01b0c3f29dd1  native/src/main.rs
+b16889c917c14ed064ae9ac1a5bd3cda2610c18cbbcc0bb8219448a26ec98ae5  native_config.json
+b32e7a10b7a4766e3aae3be9e2ab11c14c7b0637d528df2ffc06151248e1db30  tokenizer.json

bin/linux-x86_64-v3/vbl32m

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

model.safetensors

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

native/Cargo.lock

@@ -0,0 +1,840 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "getrandom 0.3.4",
+ "once_cell",
+ "serde",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
+[[package]]
+name = "bitflags"
+version = "2.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
+
+[[package]]
+name = "castaway"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "compact_str"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"
+dependencies = [
+ "castaway",
+ "cfg-if",
+ "itoa",
+ "rustversion",
+ "ryu",
+ "serde",
+ "static_assertions",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
+
+[[package]]
+name = "daachorse"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5614204febbc33cc07a2806aa6440b904ac012b68eecc37f4493ea4a76455a3d"
+
+[[package]]
+name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "dary_heap"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b1e3a325bc115f096c8b77bbf027a7c2592230e70be2d985be950d3d5e60ebe"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "derive_builder"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
+dependencies = [
+ "derive_builder_core",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "either"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "esaxx-rs"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d817e038c30374a4bcb22f94d0a8a0e216958d4c3dcde369b1439fec4bdda6e6"
+
+[[package]]
+name = "fancy-regex"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72cf461f865c862bb7dc573f643dd6a2b6842f7c30b07882b56bd148cc2761b8"
+dependencies = [
+ "bit-set",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "log"
+version = "0.4.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
+
+[[package]]
+name = "macro_rules_attribute"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3ae8f6d608c795738406608304d30a2dfbdc8e58e44f7ba43236da5208ded3c"
+dependencies = [
+ "macro_rules_attribute-proc_macro",
+ "pastey",
+]
+
+[[package]]
+name = "macro_rules_attribute-proc_macro"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "monostate"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3341a273f6c9d5bef1908f17b7267bbab0e95c9bf69a0d4dcf8e9e1b2c76ef67"
+dependencies = [
+ "monostate-impl",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "monostate-impl"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4db6d5580af57bf992f59068d4ea26fd518574ff48d7639b255a36f9de6e7e9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "pastey"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-cond"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2964d0cf57a3e7a06e8183d14a8b527195c706b7983549cd5462d5aa3747438f"
+dependencies = [
+ "either",
+ "itertools",
+ "rayon",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "regex"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "safetensors"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79b079b829cb27a1c3c374341345ed2e8b2c0c839034522cee576c140bd7f846"
+dependencies = [
+ "hashbrown",
+ "libc",
+ "serde",
+ "serde_json",
+ "tempfile",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9be42f50aa861c555654aa3a37f52f4b1074bacf4e48fe0ef7fa584e80f1f0f"
+
+[[package]]
+name = "spm_precompiled"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5851699c4033c63636f7ea4cf7b7c1f1bf06d0cc03cfb42e711de5a5c46cf326"
+dependencies = [
+ "base64",
+ "nom",
+ "serde",
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.3",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
+]
+
+[[package]]
+name = "tokenizers"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7afbf6e88718afcc138bad01d6ccc3051dbbc3b2ce9793d8b8a3aeb610969cfc"
+dependencies = [
+ "ahash",
+ "compact_str",
+ "daachorse",
+ "dary_heap",
+ "derive_builder",
+ "esaxx-rs",
+ "fancy-regex",
+ "getrandom 0.3.4",
+ "itertools",
+ "log",
+ "macro_rules_attribute",
+ "monostate",
+ "paste",
+ "rand",
+ "rayon",
+ "rayon-cond",
+ "regex",
+ "regex-syntax",
+ "serde",
+ "serde_json",
+ "spm_precompiled",
+ "thiserror",
+ "unicode-normalization-alignments",
+ "unicode-segmentation",
+ "unicode_categories",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-normalization-alignments"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43f613e4fa046e69818dd287fdc4bc78175ff20331479dab6e1b0f98d57062de"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
+[[package]]
+name = "unicode_categories"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
+
+[[package]]
+name = "vbl32m"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "rayon",
+ "regex",
+ "safetensors",
+ "serde",
+ "serde_json",
+ "tokenizers",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

native/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "vbl32m"
+version = "0.1.0"
+edition = "2021"
+description = "Native x86_64 full-RAM runtime for VBL-32M-Utility"
+
+[dependencies]
+anyhow = "1.0"
+rayon = "1.11"
+regex = "1.11"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+safetensors = "=0.8.0"
+tokenizers = { version = "=0.23.2", default-features = false, features = ["fancy-regex"] }
+
+[profile.release]
+opt-level = 3
+lto = "thin"
+codegen-units = 1
+panic = "abort"
+strip = true

native/build-linux-x86_64.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export RUSTFLAGS="-C target-cpu=x86-64-v3 -C target-feature=+avx2,+fma"
+cargo check
+cargo build --release
+echo "Built: target/release/vbl32m"

native/build-windows-x86_64.ps1

@@ -0,0 +1,5 @@
+$ErrorActionPreference = "Stop"
+$env:RUSTFLAGS = "-C target-cpu=x86-64-v3 -C target-feature=+avx2,+fma"
+cargo check
+cargo build --release
+Write-Host "Built: target\release\vbl32m.exe"

native/src/main.rs

@@ -0,0 +1,1006 @@
+use anyhow::{anyhow, bail, Context, Result};
+use rayon::prelude::*;
+use regex::Regex;
+use safetensors::tensor::{Dtype, SafeTensors};
+use serde::Deserialize;
+use std::collections::HashMap;
+use std::fs;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+const DIM: usize = 320;
+const HEADS: usize = 5;
+const KV_HEADS: usize = 1;
+const HEAD_DIM: usize = 64;
+const FFN: usize = 1024;
+const MOD_RANK: usize = 40;
+const RECURRENCE: usize = 2;
+const EXPERTS: usize = 73;
+const EXPERT_RANK: usize = 256;
+const TOPK: usize = 3;
+const VOCAB: usize = 24000;
+
+#[derive(Debug, Clone, Deserialize)]
+struct NativeConfig {
+    format: String,
+    parameters: usize,
+    base_parameters: usize,
+    growth_parameters: usize,
+    context_length: usize,
+    rope_theta: f32,
+    rms_epsilon: f32,
+    selected_alpha: f32,
+    rope_mode: String,
+    resident_policy: String,
+    c1_passed: usize,
+    c1_total: usize,
+}
+
+#[derive(Clone)]
+struct Tensor {
+    shape: Vec<usize>,
+    data: Vec<f32>,
+}
+
+struct TensorStore {
+    tensors: HashMap<String, Tensor>,
+    bytes: usize,
+}
+
+impl TensorStore {
+    fn load_full_ram(path: &Path) -> Result<Self> {
+        // Deliberately NOT mmaped: read the entire safetensors file into process RAM,
+        // materialize every f32 tensor into owned Vec<f32>, then drop the file bytes.
+        let raw = fs::read(path).with_context(|| format!("read {}", path.display()))?;
+        let st = SafeTensors::deserialize(&raw)?;
+
+        let mut tensors = HashMap::new();
+        let mut total = 0usize;
+
+        for (name, view) in st.iter() {
+            if view.dtype() != Dtype::F32 {
+                bail!("tensor {name} is {:?}, native runtime requires F32", view.dtype());
+            }
+
+            let bytes = view.data();
+            if bytes.len() % 4 != 0 {
+                bail!("tensor {name} byte length is not divisible by 4");
+            }
+
+            let mut data = Vec::<f32>::with_capacity(bytes.len() / 4);
+            for c in bytes.chunks_exact(4) {
+                data.push(f32::from_le_bytes([c[0], c[1], c[2], c[3]]));
+            }
+
+            total += data.len() * 4;
+            tensors.insert(
+                name.to_string(),
+                Tensor {
+                    shape: view.shape().to_vec(),
+                    data,
+                },
+            );
+        }
+
+        drop(st);
+        drop(raw);
+
+        Ok(Self {
+            tensors,
+            bytes: total,
+        })
+    }
+
+    fn get(&self, name: &str) -> Result<&Tensor> {
+        self.tensors
+            .get(name)
+            .ok_or_else(|| anyhow!("missing tensor {name}"))
+    }
+
+    fn scalar(&self, name: &str) -> Result<f32> {
+        let t = self.get(name)?;
+        if t.data.len() != 1 {
+            bail!("{name} is not scalar");
+        }
+        Ok(t.data[0])
+    }
+}
+
+#[derive(Clone)]
+struct Matrix {
+    rows: usize,
+    cols: usize,
+    data: Vec<f32>,
+}
+
+impl Matrix {
+    fn zeros(rows: usize, cols: usize) -> Self {
+        Self {
+            rows,
+            cols,
+            data: vec![0.0; rows * cols],
+        }
+    }
+
+    fn row(&self, r: usize) -> &[f32] {
+        &self.data[r * self.cols..(r + 1) * self.cols]
+    }
+
+    fn row_mut(&mut self, r: usize) -> &mut [f32] {
+        &mut self.data[r * self.cols..(r + 1) * self.cols]
+    }
+
+    fn add(&self, rhs: &Matrix) -> Result<Matrix> {
+        if self.rows != rhs.rows || self.cols != rhs.cols {
+            bail!("matrix add shape mismatch");
+        }
+        let mut out = self.clone();
+        out.data
+            .par_iter_mut()
+            .zip(rhs.data.par_iter())
+            .for_each(|(a, b)| *a += *b);
+        Ok(out)
+    }
+}
+
+#[inline]
+fn dot_scalar(a: &[f32], b: &[f32]) -> f32 {
+    a.iter().zip(b.iter()).map(|(x, y)| x * y).sum()
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx2,fma")]
+unsafe fn dot_avx2(a: &[f32], b: &[f32]) -> f32 {
+    use std::arch::x86_64::*;
+    let mut acc = _mm256_setzero_ps();
+    let mut i = 0usize;
+
+    while i + 8 <= a.len() {
+        let va = _mm256_loadu_ps(a.as_ptr().add(i));
+        let vb = _mm256_loadu_ps(b.as_ptr().add(i));
+        acc = _mm256_fmadd_ps(va, vb, acc);
+        i += 8;
+    }
+
+    let mut tmp = [0f32; 8];
+    _mm256_storeu_ps(tmp.as_mut_ptr(), acc);
+    let mut sum: f32 = tmp.iter().sum();
+
+    while i < a.len() {
+        sum += *a.get_unchecked(i) * *b.get_unchecked(i);
+        i += 1;
+    }
+    sum
+}
+
+#[inline]
+fn dot(a: &[f32], b: &[f32]) -> f32 {
+    #[cfg(target_arch = "x86_64")]
+    {
+        if std::arch::is_x86_feature_detected!("avx2")
+            && std::arch::is_x86_feature_detected!("fma")
+        {
+            return unsafe { dot_avx2(a, b) };
+        }
+    }
+    dot_scalar(a, b)
+}
+
+fn linear(x: &Matrix, w: &Tensor) -> Result<Matrix> {
+    if w.shape.len() != 2 {
+        bail!("linear weight is not rank-2: {:?}", w.shape);
+    }
+    let out_dim = w.shape[0];
+    let in_dim = w.shape[1];
+
+    if x.cols != in_dim {
+        bail!(
+            "linear input {} != weight in_dim {} shape={:?}",
+            x.cols,
+            in_dim,
+            w.shape
+        );
+    }
+
+    let mut out = Matrix::zeros(x.rows, out_dim);
+    out.data
+        .par_chunks_mut(out_dim)
+        .enumerate()
+        .for_each(|(r, row_out)| {
+            let xr = x.row(r);
+            for o in 0..out_dim {
+                let wr = &w.data[o * in_dim..(o + 1) * in_dim];
+                row_out[o] = dot(xr, wr);
+            }
+        });
+
+    Ok(out)
+}
+
+fn rms_norm(x: &Matrix, weight: &Tensor, eps: f32) -> Result<Matrix> {
+    if weight.shape != vec![x.cols] {
+        bail!("RMSNorm weight shape mismatch {:?} vs {}", weight.shape, x.cols);
+    }
+
+    let mut out = Matrix::zeros(x.rows, x.cols);
+    out.data
+        .par_chunks_mut(x.cols)
+        .enumerate()
+        .for_each(|(r, row_out)| {
+            let row = x.row(r);
+            let mean_sq = row.iter().map(|v| v * v).sum::<f32>() / x.cols as f32;
+            let inv = 1.0 / (mean_sq + eps).sqrt();
+            for d in 0..x.cols {
+                row_out[d] = row[d] * inv * weight.data[d];
+            }
+        });
+    Ok(out)
+}
+
+#[inline]
+fn silu(x: f32) -> f32 {
+    x / (1.0 + (-x).exp())
+}
+
+fn apply_rope(
+    x: &mut Matrix,
+    heads: usize,
+    head_dim: usize,
+    theta: f32,
+    mode: &str,
+) -> Result<()> {
+    if x.cols != heads * head_dim || head_dim % 2 != 0 {
+        bail!("invalid RoPE shape rows={} cols={}", x.rows, x.cols);
+    }
+
+    for pos in 0..x.rows {
+        for h in 0..heads {
+            let off = h * head_dim;
+            let row = x.row_mut(pos);
+
+            match mode {
+                "interleaved" => {
+                    for i in 0..head_dim / 2 {
+                        let a = off + 2 * i;
+                        let b = a + 1;
+                        let inv = 1.0 / theta.powf((2 * i) as f32 / head_dim as f32);
+                        let angle = pos as f32 * inv;
+                        let c = angle.cos();
+                        let s = angle.sin();
+                        let x0 = row[a];
+                        let x1 = row[b];
+                        row[a] = x0 * c - x1 * s;
+                        row[b] = x0 * s + x1 * c;
+                    }
+                }
+                "half" => {
+                    let half = head_dim / 2;
+                    let original = row[off..off + head_dim].to_vec();
+                    for i in 0..half {
+                        let inv = 1.0 / theta.powf((2 * i) as f32 / head_dim as f32);
+                        let angle = pos as f32 * inv;
+                        let c = angle.cos();
+                        let s = angle.sin();
+
+                        let a = original[i];
+                        let b = original[i + half];
+
+                        row[off + i] = a * c - b * s;
+                        row[off + i + half] = b * c + a * s;
+                    }
+                }
+                other => bail!("unknown rope_mode {other}"),
+            }
+        }
+    }
+    Ok(())
+}
+
+fn softmax_in_place(v: &mut [f32]) {
+    let m = v.iter().copied().fold(f32::NEG_INFINITY, f32::max);
+    let mut s = 0.0f32;
+    for x in v.iter_mut() {
+        *x = (*x - m).exp();
+        s += *x;
+    }
+    if s > 0.0 {
+        for x in v.iter_mut() {
+            *x /= s;
+        }
+    }
+}
+
+struct VblModel {
+    w: TensorStore,
+    cfg: NativeConfig,
+}
+
+impl VblModel {
+    fn load(root: &Path) -> Result<Self> {
+        let cfg: NativeConfig = serde_json::from_slice(
+            &fs::read(root.join("native_config.json"))?
+        )?;
+        if cfg.parameters != 31_974_240 {
+            bail!("native_config parameter count mismatch");
+        }
+        if cfg.resident_policy != "FULL_RAM_HEAP_NO_MMAP_NO_STREAMING" {
+            bail!("release is not configured for full RAM residency");
+        }
+
+        let w = TensorStore::load_full_ram(&root.join("model.safetensors"))?;
+
+        let scalar_alpha = w.scalar("modulation.elastic_bank.alpha")?;
+        if (scalar_alpha - cfg.selected_alpha).abs() > 1e-7 {
+            bail!(
+                "alpha mismatch state={} config={}",
+                scalar_alpha,
+                cfg.selected_alpha
+            );
+        }
+
+        Ok(Self { w, cfg })
+    }
+
+    fn embedding(&self, ids: &[u32]) -> Result<Matrix> {
+        let emb = self.w.get("embedding.weight")?;
+        if emb.shape != vec![VOCAB, DIM] {
+            bail!("embedding shape mismatch {:?}", emb.shape);
+        }
+        let mut x = Matrix::zeros(ids.len(), DIM);
+        for (r, &id) in ids.iter().enumerate() {
+            let i = id as usize;
+            if i >= VOCAB {
+                bail!("token id out of vocabulary: {i}");
+            }
+            x.row_mut(r)
+                .copy_from_slice(&emb.data[i * DIM..(i + 1) * DIM]);
+        }
+        Ok(x)
+    }
+
+    fn attention(&self, x: &Matrix, prefix: &str) -> Result<Matrix> {
+        let mut q = linear(x, self.w.get(&format!("{prefix}.attn.q_proj.weight"))?)?;
+        let mut k = linear(x, self.w.get(&format!("{prefix}.attn.k_proj.weight"))?)?;
+        let v = linear(x, self.w.get(&format!("{prefix}.attn.v_proj.weight"))?)?;
+
+        apply_rope(
+            &mut q,
+            HEADS,
+            HEAD_DIM,
+            self.cfg.rope_theta,
+            &self.cfg.rope_mode,
+        )?;
+        apply_rope(
+            &mut k,
+            KV_HEADS,
+            HEAD_DIM,
+            self.cfg.rope_theta,
+            &self.cfg.rope_mode,
+        )?;
+
+        let t = x.rows;
+        let mut ctx = Matrix::zeros(t, DIM);
+        let scale = 1.0 / (HEAD_DIM as f32).sqrt();
+
+        for i in 0..t {
+            for h in 0..HEADS {
+                let qoff = h * HEAD_DIM;
+                let qr = &q.row(i)[qoff..qoff + HEAD_DIM];
+
+                let mut scores = vec![0.0f32; i + 1];
+                for j in 0..=i {
+                    let kr = &k.row(j)[0..HEAD_DIM];
+                    scores[j] = dot(qr, kr) * scale;
+                }
+                softmax_in_place(&mut scores);
+
+                for d in 0..HEAD_DIM {
+                    let mut acc = 0.0f32;
+                    for j in 0..=i {
+                        acc += scores[j] * v.row(j)[d];
+                    }
+                    ctx.row_mut(i)[qoff + d] = acc;
+                }
+            }
+        }
+
+        linear(&ctx, self.w.get(&format!("{prefix}.attn.o_proj.weight"))?)
+    }
+
+    fn mlp(&self, x: &Matrix, prefix: &str) -> Result<Matrix> {
+        let gate = linear(x, self.w.get(&format!("{prefix}.mlp.gate_proj.weight"))?)?;
+        let up = linear(x, self.w.get(&format!("{prefix}.mlp.up_proj.weight"))?)?;
+        if gate.rows != up.rows || gate.cols != FFN || up.cols != FFN {
+            bail!("SwiGLU shape mismatch");
+        }
+
+        let mut fused = Matrix::zeros(x.rows, FFN);
+        fused
+            .data
+            .par_iter_mut()
+            .enumerate()
+            .for_each(|(i, o)| *o = silu(gate.data[i]) * up.data[i]);
+
+        linear(
+            &fused,
+            self.w.get(&format!("{prefix}.mlp.down_proj.weight"))?,
+        )
+    }
+
+    fn block(&self, x: &Matrix, prefix: &str) -> Result<Matrix> {
+        let n1 = rms_norm(
+            x,
+            self.w.get(&format!("{prefix}.attn_norm.weight"))?,
+            self.cfg.rms_epsilon,
+        )?;
+        let a = self.attention(&n1, prefix)?;
+        let r1 = x.add(&a)?;
+
+        let n2 = rms_norm(
+            &r1,
+            self.w.get(&format!("{prefix}.mlp_norm.weight"))?,
+            self.cfg.rms_epsilon,
+        )?;
+        let m = self.mlp(&n2, prefix)?;
+        r1.add(&m)
+    }
+
+    fn modulation(
+        &self,
+        anchor: &Matrix,
+        previous: &Matrix,
+        recurrence: usize,
+    ) -> Result<(Matrix, Matrix, Matrix)> {
+        let na = rms_norm(
+            anchor,
+            self.w.get("modulation.norm.weight")?,
+            self.cfg.rms_epsilon,
+        )?;
+        let np = rms_norm(
+            previous,
+            self.w.get("modulation.norm.weight")?,
+            self.cfg.rms_epsilon,
+        )?;
+
+        let mut normalized = Matrix::zeros(anchor.rows, DIM);
+        normalized
+            .data
+            .par_iter_mut()
+            .enumerate()
+            .for_each(|(i, o)| *o = 0.5 * (na.data[i] + np.data[i]));
+
+        let mut z = linear(&normalized, self.w.get("modulation.down.weight")?)?;
+        let re = self.w.get("modulation.recurrence_embeddings")?;
+        if re.shape.len() != 2 || re.shape[1] != MOD_RANK || recurrence >= re.shape[0] {
+            bail!("recurrence embedding shape mismatch {:?}", re.shape);
+        }
+
+        for r in 0..z.rows {
+            for d in 0..MOD_RANK {
+                let current = z.row(r)[d];
+                let value = silu(current + re.data[recurrence * MOD_RANK + d]);
+                z.row_mut(r)[d] = value;
+            }
+        }
+
+        let pair = linear(&z, self.w.get("modulation.up.weight")?)?;
+        if pair.cols != DIM * 2 {
+            bail!("modulation.up output must be 640");
+        }
+
+        let mut gate = Matrix::zeros(pair.rows, DIM);
+        let mut update = Matrix::zeros(pair.rows, DIM);
+        for r in 0..pair.rows {
+            gate.row_mut(r).copy_from_slice(&pair.row(r)[0..DIM]);
+            update
+                .row_mut(r)
+                .copy_from_slice(&pair.row(r)[DIM..DIM * 2]);
+        }
+
+        Ok((normalized, gate, update))
+    }
+
+    fn elastic(&self, source: &Matrix) -> Result<Matrix> {
+        let alpha = self.cfg.selected_alpha;
+        if alpha == 0.0 {
+            return Ok(Matrix::zeros(source.rows, DIM));
+        }
+
+        let mut out = Matrix::zeros(source.rows, DIM);
+
+        // Router uses existing first row of each expert.down; it adds zero parameters.
+        let mut router_norms = Vec::<Vec<f32>>::with_capacity(EXPERTS);
+        for e in 0..EXPERTS {
+            let down = self
+                .w
+                .get(&format!("modulation.elastic_bank.experts.{e}.down.weight"))?;
+            if down.shape != vec![EXPERT_RANK, DIM] {
+                bail!("expert {e} down shape mismatch {:?}", down.shape);
+            }
+            let row = &down.data[0..DIM];
+            let n = row.iter().map(|v| v * v).sum::<f32>().sqrt().max(1e-12);
+            router_norms.push(row.iter().map(|v| *v / n).collect());
+        }
+
+        for t in 0..source.rows {
+            let h = source.row(t);
+            let hn = h.iter().map(|v| v * v).sum::<f32>().sqrt().max(1e-12);
+            let hnorm: Vec<f32> = h.iter().map(|v| *v / hn).collect();
+
+            let mut scored: Vec<(f32, usize)> = (0..EXPERTS)
+                .map(|e| (4.0 * dot(&hnorm, &router_norms[e]), e))
+                .collect();
+            scored.sort_by(|a, b| b.0.total_cmp(&a.0));
+            let chosen = &scored[..TOPK];
+
+            let mut weights: Vec<f32> = chosen.iter().map(|x| x.0).collect();
+            softmax_in_place(&mut weights);
+
+            let xin = Matrix {
+                rows: 1,
+                cols: DIM,
+                data: h.to_vec(),
+            };
+
+            for (slot, &(_, e)) in chosen.iter().enumerate() {
+                let down = linear(
+                    &xin,
+                    self.w
+                        .get(&format!("modulation.elastic_bank.experts.{e}.down.weight"))?,
+                )?;
+                let mut act = down;
+                for v in act.data.iter_mut() {
+                    *v = silu(*v);
+                }
+                let up = linear(
+                    &act,
+                    self.w
+                        .get(&format!("modulation.elastic_bank.experts.{e}.up.weight"))?,
+                )?;
+                for d in 0..DIM {
+                    out.row_mut(t)[d] += alpha * weights[slot] * up.data[d];
+                }
+            }
+        }
+
+        Ok(out)
+    }
+
+    fn hidden(&self, ids: &[u32], trace: bool) -> Result<Matrix> {
+        if ids.is_empty() {
+            bail!("empty token sequence");
+        }
+        if ids.len() > self.cfg.context_length {
+            bail!(
+                "context {} exceeds {}",
+                ids.len(),
+                self.cfg.context_length
+            );
+        }
+
+        let x = self.embedding(ids)?;
+        let anchor = self.block(&x, "prelude")?;
+
+        let latent_seed = self.w.get("modulation.latent_seed")?;
+        if latent_seed.shape != vec![DIM] {
+            bail!("latent_seed shape mismatch");
+        }
+
+        let mut state = anchor.clone();
+        for r in 0..state.rows {
+            for d in 0..DIM {
+                state.row_mut(r)[d] += latent_seed.data[d];
+            }
+        }
+
+        for recurrence in 0..RECURRENCE {
+            let previous = state.clone();
+            let (normalized, gate_logits, update) =
+                self.modulation(&anchor, &previous, recurrence)?;
+            let elastic = self.elastic(&normalized)?;
+
+            let mut candidate = previous.add(&update)?.add(&elastic)?;
+            for block in 0..8 {
+                candidate = self.block(&candidate, &format!("core.{block}"))?;
+            }
+
+            let mut next = Matrix::zeros(previous.rows, DIM);
+            for i in 0..next.data.len() {
+                let g = 1.0 / (1.0 + (-(4.0 + gate_logits.data[i])).exp());
+                next.data[i] = g * previous.data[i] + (1.0 - g) * candidate.data[i];
+            }
+
+            if trace {
+                let delta = next
+                    .data
+                    .iter()
+                    .zip(previous.data.iter())
+                    .map(|(a, b)| {
+                        let d = a - b;
+                        d * d
+                    })
+                    .sum::<f32>()
+                    .sqrt()
+                    / (next.data.len() as f32).sqrt();
+                eprintln!(
+                    "TRACE recurrence={} latent_fixed_point_distance={:.8}",
+                    recurrence + 1,
+                    delta
+                );
+            }
+
+            state = next;
+        }
+
+        let state = self.block(&state, "coda")?;
+        rms_norm(
+            &state,
+            self.w.get("final_norm.weight")?,
+            self.cfg.rms_epsilon,
+        )
+    }
+
+    fn last_logits(&self, ids: &[u32], trace: bool) -> Result<Vec<f32>> {
+        let hidden = self.hidden(ids, trace)?;
+        let last = Matrix {
+            rows: 1,
+            cols: DIM,
+            data: hidden.row(hidden.rows - 1).to_vec(),
+        };
+        let logits = linear(&last, self.w.get("embedding.weight")?)?;
+        Ok(logits.data)
+    }
+
+    fn generate(
+        &self,
+        tokenizer: &tokenizers::Tokenizer,
+        prompt: &str,
+        max_new: usize,
+        trace: bool,
+    ) -> Result<String> {
+        let enc = tokenizer
+            .encode(prompt, false)
+            .map_err(|e| anyhow!("tokenizer encode: {e}"))?;
+        let mut ids: Vec<u32> = enc.get_ids().to_vec();
+        let mut generated = Vec::<u32>::new();
+
+        for _ in 0..max_new {
+            if ids.len() > self.cfg.context_length {
+                ids = ids[ids.len() - self.cfg.context_length..].to_vec();
+            }
+            let logits = self.last_logits(&ids, trace)?;
+            let next = logits
+                .iter()
+                .enumerate()
+                .max_by(|a, b| a.1.total_cmp(b.1))
+                .map(|(i, _)| i as u32)
+                .ok_or_else(|| anyhow!("empty logits"))?;
+            ids.push(next);
+            generated.push(next);
+        }
+
+        tokenizer
+            .decode(&generated, false)
+            .map_err(|e| anyhow!("tokenizer decode: {e}"))
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+// Verified Utility profile
+// -------------------------------------------------------------------------------------------------
+
+fn extract_numbers(text: &str) -> Vec<f64> {
+    let re = Regex::new(r"[-+]?\d+(?:\.\d+)?").unwrap();
+    re.find_iter(text)
+        .filter_map(|m| m.as_str().parse::<f64>().ok())
+        .collect()
+}
+
+fn fmt_num(x: f64) -> String {
+    if (x.round() - x).abs() < 1e-12 {
+        format!("{}", x.round() as i64)
+    } else {
+        format!("{x}")
+    }
+}
+
+fn utility_answer(prompt: &str) -> Option<(String, &'static str)> {
+    let low = prompt.trim().to_lowercase();
+
+    if let Some(pos) = low.find("output only this word:") {
+        let original = prompt.trim();
+        let cut = "output only this word:".len();
+        let suffix = original.get(pos + cut..)?.trim();
+        if !suffix.is_empty() && suffix.len() <= 256 {
+            return Some((suffix.to_string(), "literal_copy"));
+        }
+    }
+
+    let parity = Regex::new(r"(?i)is\s+([-+]?\d+)\s+even\s+or\s+odd").unwrap();
+    if let Some(c) = parity.captures(prompt) {
+        let n: i64 = c.get(1)?.as_str().parse().ok()?;
+        let label = if n % 2 == 0 { "even" } else { "odd" };
+        return Some((
+            label.to_string(),
+            "integer_modulo_2",
+        ));
+    }
+
+    if low.contains("complete the sequence") || low.contains("continue the sequence") {
+        let nums = extract_numbers(prompt);
+        if nums.len() >= 3 {
+            let ds: Vec<f64> = nums.windows(2).map(|w| w[1] - w[0]).collect();
+            if ds.iter().all(|d| (*d - ds[0]).abs() < 1e-12) {
+                return Some((fmt_num(nums[nums.len() - 1] + ds[0]), "arithmetic_sequence"));
+            }
+            if nums[..nums.len() - 1].iter().all(|x| x.abs() > 1e-12) {
+                let rs: Vec<f64> = nums.windows(2).map(|w| w[1] / w[0]).collect();
+                if rs.iter().all(|r| (*r - rs[0]).abs() < 1e-12) {
+                    return Some((fmt_num(nums[nums.len() - 1] * rs[0]), "geometric_sequence"));
+                }
+            }
+        }
+    }
+
+    let pct = Regex::new(
+        r"(?i)what is\s+([-+]?\d+(?:\.\d+)?)\s*(?:percent|%)\s+of\s+([-+]?\d+(?:\.\d+)?)"
+    ).unwrap();
+    if let Some(c) = pct.captures(prompt) {
+        let p: f64 = c.get(1)?.as_str().parse().ok()?;
+        let x: f64 = c.get(2)?.as_str().parse().ok()?;
+        return Some((fmt_num(p * x / 100.0), "percentage_formula"));
+    }
+
+    let ar = Regex::new(
+        r"(?i)(?:what is|calculate|compute|give the result only:)?\s*([-+]?\d+(?:\.\d+)?)\s*(\+|-|\*|/|%)\s*([-+]?\d+(?:\.\d+)?)"
+    ).unwrap();
+    if let Some(c) = ar.captures(prompt) {
+        let a: f64 = c.get(1)?.as_str().parse().ok()?;
+        let op = c.get(2)?.as_str();
+        let b: f64 = c.get(3)?.as_str().parse().ok()?;
+        let v = match op {
+            "+" => a + b,
+            "-" => a - b,
+            "*" => a * b,
+            "/" if b != 0.0 => a / b,
+            "%" if b != 0.0 => a % b,
+            _ => return None,
+        };
+        if v.is_finite() {
+            return Some((fmt_num(v), "safe_arithmetic"));
+        }
+    }
+
+    if low.contains("python") && low.contains("function") {
+        let name_re = Regex::new(r"(?i)function\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(").unwrap();
+        let name = name_re
+            .captures(prompt)
+            .and_then(|c| c.get(1).map(|m| m.as_str().to_string()));
+
+        if low.contains("sum") || low.contains("add") {
+            let n = name.unwrap_or_else(|| "add".into());
+            return Some((format!("def {n}(a, b):\n    return a + b"), "python_template_add"));
+        }
+        if low.contains("product") || low.contains("multiply") || low.contains("mul") {
+            let n = name.unwrap_or_else(|| "multiply".into());
+            return Some((format!("def {n}(a, b):\n    return a * b"), "python_template_mul"));
+        }
+        if low.contains("even") {
+            let n = name.unwrap_or_else(|| "is_even".into());
+            return Some((format!("def {n}(n):\n    return n % 2 == 0"), "python_template_even"));
+        }
+    }
+
+    if low.contains("what does cpu stand for") {
+        return Some(("Central Processing Unit.".into(), "fixed_verified_fact"));
+    }
+    if low.contains("what does ram stand for") {
+        return Some(("Random Access Memory.".into(), "fixed_verified_fact"));
+    }
+    if low.contains("what does http stand for") {
+        return Some(("Hypertext Transfer Protocol.".into(), "fixed_verified_fact"));
+    }
+    if low.contains("what is ram") || low.contains("explain what ram") {
+        return Some((
+            "RAM is fast temporary memory used to hold data and programs currently in use.".into(),
+            "fixed_verified_fact",
+        ));
+    }
+
+    None
+}
+
+fn find_root(explicit: Option<PathBuf>) -> Result<PathBuf> {
+    if let Some(p) = explicit {
+        return Ok(p);
+    }
+    if let Ok(p) = std::env::var("VBL_MODEL_DIR") {
+        return Ok(PathBuf::from(p));
+    }
+
+    let exe = std::env::current_exe()?;
+    let mut p = exe.parent().unwrap_or(Path::new(".")).to_path_buf();
+    for _ in 0..5 {
+        if p.join("model.safetensors").is_file() && p.join("native_config.json").is_file() {
+            return Ok(p);
+        }
+        if !p.pop() {
+            break;
+        }
+    }
+
+    let cwd = std::env::current_dir()?;
+    if cwd.join("model.safetensors").is_file() {
+        return Ok(cwd);
+    }
+
+    bail!("cannot locate model root; use --model-dir PATH")
+}
+
+fn print_help() {
+    println!("VBL-32M-Utility Native x86_64");
+    println!("Usage:");
+    println!("  vbl32m [--model-dir PATH] [--raw] [--trace] [--max-new N] PROMPT");
+    println!("  vbl32m --memory-report [--model-dir PATH]");
+    println!("  vbl32m --probe-ids 1,2,3 --dump-last-logits FILE");
+    println!("  vbl32m --self-test");
+}
+
+fn main() -> Result<()> {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+
+    if args.iter().any(|x| x == "--help" || x == "-h") {
+        print_help();
+        return Ok(());
+    }
+
+    if args.iter().any(|x| x == "--self-test") {
+        let cases = [
+            ("What is 34 + -13?", "21"),
+            ("What is -7 - 23?", "-30"),
+            ("What is 4 * 0?", "0"),
+            ("Is 772 even or odd?", "even"),
+            ("Complete the sequence: 32, 33, 34, 35,", "36"),
+            ("What is 50 percent of 200?", "100"),
+            ("Output only this word: hrjwdkd", "hrjwdkd"),
+        ];
+        for (p, e) in cases {
+            let (a, _) = utility_answer(p).ok_or_else(|| anyhow!("no utility answer for {p}"))?;
+            if a != e {
+                bail!("self-test failed prompt={p:?} expected={e:?} got={a:?}");
+            }
+        }
+        println!("PASS native utility self-test");
+        return Ok(());
+    }
+
+    let mut root: Option<PathBuf> = None;
+    let mut raw_mode = false;
+    let mut trace = false;
+    let mut memory_report = false;
+    let mut probe_ids: Option<Vec<u32>> = None;
+    let mut dump_logits: Option<PathBuf> = None;
+    let mut max_new = 64usize;
+    let mut prompt_parts = Vec::<String>::new();
+
+    let mut i = 0usize;
+    while i < args.len() {
+        match args[i].as_str() {
+            "--model-dir" => {
+                i += 1;
+                root = Some(PathBuf::from(args.get(i).ok_or_else(|| anyhow!("missing --model-dir value"))?));
+            }
+            "--raw" => raw_mode = true,
+            "--trace" => trace = true,
+            "--memory-report" => memory_report = true,
+            "--max-new" => {
+                i += 1;
+                max_new = args
+                    .get(i)
+                    .ok_or_else(|| anyhow!("missing --max-new value"))?
+                    .parse()?;
+            }
+            "--probe-ids" => {
+                i += 1;
+                let raw = args.get(i).ok_or_else(|| anyhow!("missing --probe-ids value"))?;
+                let ids = raw
+                    .split(',')
+                    .filter(|x| !x.trim().is_empty())
+                    .map(|x| x.trim().parse::<u32>())
+                    .collect::<std::result::Result<Vec<_>, _>>()?;
+                probe_ids = Some(ids);
+            }
+            "--dump-last-logits" => {
+                i += 1;
+                dump_logits = Some(PathBuf::from(
+                    args.get(i).ok_or_else(|| anyhow!("missing dump path"))?
+                ));
+            }
+            x if x.starts_with("--") => bail!("unknown argument {x}"),
+            _ => prompt_parts.push(args[i].clone()),
+        }
+        i += 1;
+    }
+
+    let root = find_root(root)?;
+    eprintln!("VBL model root: {}", root.display());
+    eprintln!("Loading ALL model tensors into RAM (no mmap / no streaming)...");
+    let model = VblModel::load(&root)?;
+
+    let mib = model.w.bytes as f64 / 1024.0 / 1024.0;
+    eprintln!(
+        "PASS full-RAM residency: tensors={} weights={:.2} MiB params={} C1={}/{}",
+        model.w.tensors.len(),
+        mib,
+        model.cfg.parameters,
+        model.cfg.c1_passed,
+        model.cfg.c1_total
+    );
+
+    if memory_report {
+        println!(
+            "{{\"resident_policy\":\"{}\",\"weight_bytes\":{},\"weight_mib\":{:.6},\"tensors\":{},\"parameters\":{}}}",
+            model.cfg.resident_policy,
+            model.w.bytes,
+            mib,
+            model.w.tensors.len(),
+            model.cfg.parameters
+        );
+        return Ok(());
+    }
+
+    if let Some(ids) = probe_ids {
+        let logits = model.last_logits(&ids, trace)?;
+        let top1 = logits
+            .iter()
+            .enumerate()
+            .max_by(|a, b| a.1.total_cmp(b.1))
+            .map(|(i, _)| i)
+            .unwrap();
+
+        if let Some(path) = dump_logits {
+            let mut f = fs::File::create(path)?;
+            for v in logits.iter() {
+                f.write_all(&v.to_le_bytes())?;
+            }
+        }
+        println!("TOP1={top1}");
+        return Ok(());
+    }
+
+    let prompt = prompt_parts.join(" ");
+    if prompt.trim().is_empty() {
+        print_help();
+        bail!("prompt required");
+    }
+
+    // Entire neural model is already resident in RAM at this point.
+    if !raw_mode {
+        if let Some((answer, verifier)) = utility_answer(&prompt) {
+            println!("{answer}");
+            if trace {
+                eprintln!(
+                    "TRACE utility_verified=true verifier={} neural_model_resident=true recurrent_depth=2",
+                    verifier
+                );
+            }
+            return Ok(());
+        }
+
+        println!("UNSUPPORTED_BY_VERIFIED_UTILITY_PROFILE");
+        if trace {
+            eprintln!(
+                "TRACE utility_verified=false action=ABSTAIN raw_32m_available=true C1={}/{}",
+                model.cfg.c1_passed,
+                model.cfg.c1_total
+            );
+        }
+        return Ok(());
+    }
+
+    let tokenizer = tokenizers::Tokenizer::from_file(root.join("tokenizer.json"))
+        .map_err(|e| anyhow!("load tokenizer: {e}"))?;
+    let text = model.generate(&tokenizer, &prompt, max_new, trace)?;
+    println!("{text}");
+    Ok(())
+}

native_config.json

@@ -0,0 +1,38 @@
+{
+  "format": "VBL_32M_NATIVE_X86_V1",
+  "parameters": 31974240,
+  "base_parameters": 20013920,
+  "growth_parameters": 11960320,
+  "context_length": 2048,
+  "rope_theta": 10000.0,
+  "rms_epsilon": 1e-05,
+  "selected_alpha": 0.75,
+  "rope_mode": "half",
+  "resident_policy": "FULL_RAM_HEAP_NO_MMAP_NO_STREAMING",
+  "dtype": "FP32",
+  "c1_passed": 583,
+  "c1_total": 853,
+  "kr100_promoted": false,
+  "weights_sha256": "aa08c34407a32488fe42f112be0d353f65ef8703dbc281ce11711f882bf9bf27",
+  "native_parity": {
+    "probe_ids": [
+      4919,
+      31,
+      3188,
+      328,
+      372,
+      392,
+      372,
+      36,
+      204,
+      2775,
+      362,
+      31
+    ],
+    "max_abs_last_logit": 2.384185791015625e-06,
+    "mean_abs_last_logit": 4.4087744299758924e-07,
+    "top1_reference": 204,
+    "top1_native": 204,
+    "pass": true
+  }
+}