Publish Julia 1 model and Python runtime

.gitattributes

@@ -0,0 +1,39 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+julia/router/benchmarks/runtime/*.perf.data filter=lfs diff=lfs merge=lfs -text
+assets/*.png filter=lfs diff=lfs merge=lfs -text
+assets/*.svg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+
+__pycache__/
+*.pyc
+build/
+*.egg-info/
+benchmark/
+.venv/
+.pytest_cache/
+*.so

README.md

@@ -0,0 +1,138 @@
+---
+license: apache-2.0
+base_model: jhu-clsp/mmBERT-small
+library_name: pytorch
+tags:
+  - decision-model
+  - text-classification
+  - multilingual
+  - routing
+---
+
+![Supersonic Labs logo](assets/supersonic-labs-light.svg)
+
+<h1 align="center">Julia 1</h1>
+<p align="center">From context to decisions.</p>
+
+![Julia 1 — monochrome geometric artwork](assets/julia-banner.png)
+
+Julia 1 is the **first model in the Julia family and the first released test of our training system**. At 144.3M parameters, it turns a state, a question, and possible answers into one clear decision. The same interface handles classification, routing, ordered scores, and Boolean decisions.
+
+## Evaluation
+
+Measured on **2026-09-24** with H200 BF16 inference and strict encoding. These are results for the checkpoint in this repository.
+
+| Benchmark | Correct / total | Julia 1 | Jev reference | Difference |
+| --- | ---: | ---: | ---: | ---: |
+| Typed decisions | 1,463 / 2,000 | **73.15%** | 72.70% | +0.45 pp |
+| AG News · 4 labels | 94 / 100 | **94.00%** | 91.00% | +3.00 pp |
+| DAIR Emotion · 6 labels | 86 / 100 | **86.00%** | 48.00% | +38.00 pp |
+| Banking77 pilot · 72 labels | 64 / 100 | 64.00% | **87.00%** | −23.00 pp |
+
+Typed accuracy: **Choice 71.33%** (428/600), **Noul 80.67%** (484/600), **Score 68.88%** (551/800).
+
+| MASSIVE scenario classification | Correct / total | Accuracy |
+| --- | ---: | ---: |
+| All 52 locales | 110,573 / 154,648 | **71.50%** |
+| Portuguese · pt-PT | 2,565 / 2,974 | **86.25%** |
+| English · en-US | 2,580 / 2,974 | **86.75%** |
+
+MASSIVE measures 18 scenario labels across 52 locales with 2,974 examples per locale. It does not measure intent classification or slot filling. The all-locale value is macro accuracy.
+
+**Protocol:** [typed-decisions](https://huggingface.co/datasets/LocalLLaMA/typed-decisions) supplies the 400 test cases; classification pilots follow the pinned [Jev benchmark protocol](https://github.com/AbdelStark/jev-benchmarks/tree/0d610cc53e79bcbec691312b0c4adb4a0e371642) using [BTZSC](https://huggingface.co/datasets/btzsc/btzsc). Jev numbers are supplied comparison references, not a new Jev run. Classification pilots cover 100 examples per dataset. Banking uses a 72-label pilot through a ranking/top-16 shortlist, not a native 72-option call. Abstentions count as incorrect.
+
+[Full benchmark results](metrics/accuracy-20260924.json) · [Checkpoint and validation provenance](provenance.json).
+
+## Where Julia is accurate — and where it can miss
+
+Julia 1 shows what a focused 144.3M-parameter model can do when the task is a **clear choice grounded in supplied context**. It selected the correct answer in 94 of 100 AG News pilot cases and 86 of 100 Emotion pilot cases, and reached 71.50% scenario accuracy across all 52 MASSIVE locales. The typed-decision suite reached 73.15%. These results make Julia useful for testing classification and routing workflows with explicit candidate answers. They also make this first release a concrete test of our training system, with measured strengths and visible gaps rather than a promise of general intelligence.
+
+The tradeoff is knowledge and multi-step reasoning. Julia compares the answers you provide; it cannot be counted on to supply missing facts, solve algebraic equations, or carry a long chain of calculations just because the right answer appears among the options. Those abilities are **not established by the evaluations here**. Ambiguous wording, unfamiliar domains, and long label lists can also cause mistakes: the Banking77 pilot reached 64/100 with a shortlist, below its supplied 87/100 reference. The 100-example pilots are encouraging signals, not guarantees for a new workflow. Evaluate the exact questions and options you plan to use.
+
+## Why a decision model for routing?
+
+A conventional rule or keyword router needs someone to enumerate phrases and maintain branch order. Julia instead reads the supplied context and the meanings of the candidate answers together. One model can score a new set of labels without adding a new output head for every workflow, and it can handle `choice`, ordered `score`, and Boolean `noul` requests through one API.
+
+This is a model-based decision, so its answer depends on the evidence in `state` and the wording of the options. Keep the options clear and distinct, use strict encoding, and evaluate on your own workflow before using it for consequential actions. The hierarchical `Router` can process larger *choice* lists by narrowing groups and reranking survivors, but each native model call still accepts 2–20 options; a grouped result is not a global probability distribution. See [larger choice sets](julia/router/README.md#larger-choice-sets).
+
+## From mmBERT-small to Julia 1
+
+Julia 1 starts from [JHU CLSP's mmBERT-small](https://huggingface.co/jhu-clsp/mmBERT-small), a multilingual ModernBERT encoder. The upstream model is a general-purpose encoder released for tasks such as masked-language modeling and downstream fine-tuning. Julia retains that encoder foundation and tokenizer, then adapts the model to score supplied answer options for a typed question about a state. Its checkpoint adds a decision head and is trained on decision-format examples; the released artifact contains the resulting weights and inference code, not the private training pipeline.
+
+| | mmBERT-small | Julia 1 |
+| --- | --- | --- |
+| Main interface | Encoder representations / masked-token modeling | `state` + `question` + 2–20 `options` → one selected option |
+| Parameters | About 140M | 144.3M including the decision components |
+| Context | Upstream architecture supports up to 8,192 tokens | Evaluated Julia decision path uses up to 1,024 tokens |
+| Output | Token or encoder features for a downstream task | Scores and a selected answer in the caller's option order |
+| Usage | General multilingual encoder foundation | Specialized finite-choice decisions |
+
+The parameter and context figures for mmBERT-small come from its [model card](https://huggingface.co/jhu-clsp/mmBERT-small). Julia's values describe this checkpoint and its evaluated runtime, not a claim that mmBERT-small itself is limited to Julia's interface. Julia is not a chat or text-generation model and is not interchangeable with `AutoModelForMaskedLM`.
+
+## Start here
+
+Python 3.11+ is required. CPU inference works with the standard PyTorch installation; no native router build is needed. Download the complete repository, including its 550.5 MiB checkpoint, then install its Python package:
+
+```bash
+python -m pip install huggingface_hub
+python -c "from huggingface_hub import snapshot_download; snapshot_download('SupersonicLabs/Julia-1', local_dir='Julia-1')"
+python -m pip install -e ./Julia-1
+```
+
+Keep the model loaded between requests:
+
+```python
+from julia import load_model
+
+engine = load_model(
+    "Julia-1",
+    device="cpu",
+    strict_encoding=True,
+    max_length=1024,
+    head_length=512,
+)
+
+request = {
+    "state": "I was charged twice for the same order.",
+    "question": "Which team should handle this request?",
+    "options": [
+        "Billing and payments",
+        "Shipping and delivery",
+        "Account access",
+    ],
+    "type": "choice",
+}
+
+result = engine.predict([request])[0]
+print(request["options"][result["index"]])
+print(result["probabilities"])
+```
+
+`predict` accepts a list of requests and returns one result per request, in the same order. Each result has an `index` and `probabilities` aligned with the supplied options. Use `engine.predict(requests, probabilities=False)` when only the selected indices are needed. `engine.logits(requests)` returns raw model scores.
+
+| Field | Meaning |
+| --- | --- |
+| `state` | Context as text, a JSON object, or a JSON array. |
+| `question` | The decision to make. |
+| `options` | 2–20 nonempty answer descriptions, in the order you want returned. |
+| `type` | `choice` (default), `score` for ordered options, or `noul` for Boolean decisions. |
+
+For `noul`, provide exactly two options: **false first, true second**. For `score`, supply options in their intended order. Strict encoding rejects inputs that exceed the model's limits instead of silently truncating them. The evaluated configuration uses a 1,024-token total sequence and a 512-token question-and-options budget; each option may use at most 48 tokens.
+
+The returned percentages are **display values, not calibrated certainty**. If the raw top probability exceeds 95% and every other option is below 4.5%, the result displays 100% for the winner. Values below 1% display as 0%, with their mass redistributed proportionally among the remaining options. The selected index still comes from raw logits. For analysis or your own calibration, use `logits()`.
+
+CUDA is available with `device="cuda"` when PyTorch sees a BF16-capable GPU. Set `JULIA_CPU_THREADS` before starting Python to adjust CPU threads (default: 4). See [runtime details](julia/router/README.md).
+
+## Limits and deployment notes
+
+- The FP32 weights occupy **550.5 MiB**; allow additional memory for the tokenizer and activations. CPU inference needs no GPU.
+- A native request accepts **2–20 options**. Grouped routing can lose the correct answer during narrowing, and its final probabilities cover final candidates only.
+- Benchmark results do not establish accuracy for a new domain, every language, or high-stakes use. The Banking pilot trails its supplied reference.
+- The Python runtime in `julia/` is required. This repository is not a drop-in Transformers text-classification pipeline or a generative model.
+- Download the actual weights, not a Git LFS pointer. Keep checkpoint files unchanged while an engine is loaded.
+
+The model artifacts are licensed under **Apache 2.0**. The training pipeline is not included in this repository.
+
+---
+
+<p align="center">Supersonic Labs</p>

encoder/config.json

@@ -0,0 +1,79 @@
+{
+  "architectures": [
+    "ModernBertForMaskedLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "classifier_activation": "gelu",
+  "classifier_bias": false,
+  "classifier_dropout": 0.0,
+  "classifier_pooling": "mean",
+  "cls_token_id": 1,
+  "decoder_bias": true,
+  "deterministic_flash_attn": false,
+  "dtype": "float32",
+  "embedding_dropout": 0.0,
+  "eos_token_id": 1,
+  "global_attn_every_n_layers": 3,
+  "gradient_checkpointing": false,
+  "hidden_activation": "gelu",
+  "hidden_size": 384,
+  "initializer_cutoff_factor": 2.0,
+  "initializer_range": 0.02,
+  "intermediate_size": 1152,
+  "layer_norm_eps": 1e-05,
+  "layer_types": [
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention"
+  ],
+  "local_attention": 128,
+  "mask_token_id": 4,
+  "max_position_embeddings": 8192,
+  "mlp_bias": false,
+  "mlp_dropout": 0.0,
+  "model_type": "modernbert",
+  "norm_bias": false,
+  "norm_eps": 1e-05,
+  "num_attention_heads": 6,
+  "num_hidden_layers": 22,
+  "pad_token_id": 0,
+  "position_embedding_type": "sans_pos",
+  "repad_logits_with_grad": false,
+  "rope_parameters": {
+    "full_attention": {
+      "rope_theta": 160000,
+      "rope_type": "default"
+    },
+    "sliding_attention": {
+      "rope_theta": 160000,
+      "rope_type": "default"
+    }
+  },
+  "sep_token_id": 1,
+  "sparse_pred_ignore_index": -100,
+  "sparse_prediction": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "vocab_size": 256000
+}

inference-policy.json

@@ -0,0 +1,10 @@
+{
+  "single_model": true,
+  "max_length": 1024,
+  "head_length": 512,
+  "strict_encoding": true,
+  "calibration": null,
+  "replacement_qualified": false,
+  "step": 500,
+  "weights_sha256": "df853bf7fe424420011f3d0c47a05d7341aa9eefa7fb9f203ea4aada4ad95b72"
+}

julia/__init__.py

@@ -0,0 +1,8 @@
+"""Supersonic Labs Julia typed decision models.
+
+Use ``load_model`` for a resident CPU or CUDA inference engine.
+"""
+
+from .inference import load_model
+
+__all__ = ['load_model']

julia/cuda.py

@@ -0,0 +1,56 @@
+"""CUDA configuration and explicit environment diagnostics for the L40S path."""
+import importlib.metadata
+import json
+import os
+import platform
+import torch
+
+
+def configure(device_name='cuda', precision='bf16', seed=42):
+    device = torch.device(device_name)
+    if device.type == 'cuda' and device.index is None:
+        device = torch.device('cuda', 0)
+    if device.type == 'cuda' and not torch.cuda.is_available():
+        raise RuntimeError('CUDA requested but unavailable. Run nvidia-smi and install the CUDA PyTorch wheel; CPU fallback is disabled.')
+    if precision == 'bf16' and device.type == 'cuda' and not torch.cuda.is_bf16_supported():
+        raise RuntimeError('This CUDA device does not support BF16; select --precision fp32.')
+    torch.set_num_threads(int(os.environ.get('JULIA_CPU_THREADS', '4')))
+    torch.manual_seed(seed)
+    if device.type == 'cuda':
+        torch.cuda.set_device(device)
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        torch.cuda.reset_peak_memory_stats(device)
+    torch.set_float32_matmul_precision('high')
+    return device
+
+
+def environment(device):
+    result = dict(python=platform.python_version(), torch=str(torch.__version__), cuda=torch.version.cuda,
+                  transformers=importlib.metadata.version('transformers'), device=str(device))
+    if device.type == 'cuda':
+        prop = torch.cuda.get_device_properties(device)
+        result.update(gpu=prop.name, vram_bytes=prop.total_memory,
+                      compute_capability=list(torch.cuda.get_device_capability(device)))
+    return result
+
+
+def move(batch, device):
+    return {k: v.to(device, non_blocking=device.type == 'cuda') for k, v in batch.items()}
+
+
+def main():
+    device = configure()
+    x = torch.randn(512, 512, device=device, dtype=torch.bfloat16, requires_grad=True)
+    (x @ x.T).float().square().mean().backward()
+    torch.cuda.synchronize()
+    report = environment(device)
+    report['bf16_forward_backward_finite'] = bool(torch.isfinite(x.grad).all())
+    print(json.dumps(report, indent=2))
+    if not report['bf16_forward_backward_finite']:
+        raise RuntimeError('CUDA BF16 diagnostic produced nonfinite gradients')
+
+
+if __name__ == '__main__':
+    main()

julia/data.py

@@ -0,0 +1,142 @@
+"""Validated decision JSONL and the upstream-compatible marker serialization."""
+import hashlib
+import json
+import math
+from pathlib import Path
+
+import torch
+from torch.utils.data import Dataset
+
+QTYPES = {'choice': 0, 'score': 1, 'noul': 2}
+
+
+def digest(path):
+    with Path(path).open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def validate_row(row, line):
+    prefix = f'JSONL line {line}: '
+    if not isinstance(row, dict):
+        raise ValueError(prefix + 'request must be a JSON object')
+    if not isinstance(row.get('state'), (str, dict, list)) or not isinstance(row.get('question'), str):
+        raise ValueError(prefix + 'state must be text/JSON and question must be text')
+    options = row.get('options')
+    if not isinstance(options, list) or not 2 <= len(options) <= 20 or not all(isinstance(x, str) and x for x in options):
+        raise ValueError(prefix + 'options must contain 2–20 nonempty rendered descriptions')
+    if row.get('type', 'choice') not in QTYPES:
+        raise ValueError(prefix + 'type must be choice, score, or noul')
+    if row.get('type') == 'noul' and len(options) != 2:
+        raise ValueError(prefix + 'noul options must be ordered [false, true]')
+    if 'target' in row and (type(row['target']) is not int or not 0 <= row['target'] < len(options)):
+        raise ValueError(prefix + 'target must index the supplied option list')
+    teacher = row.get('teacher_logits')
+    if teacher is not None and (
+        not isinstance(teacher, list)
+        or len(teacher) != len(options)
+        or not all(type(x) in (int, float) and math.isfinite(x) for x in teacher)
+    ):
+        raise ValueError(prefix + 'teacher logits must be finite and match option count/order')
+
+
+class Decisions(Dataset):
+    def __init__(self, path, require_target=True, require_teacher=False):
+        self.rows = []
+        with open(path) as stream:
+            for line, text in enumerate(stream, 1):
+                if not text.strip():
+                    continue
+                try:
+                    row = json.loads(text)
+                except json.JSONDecodeError as error:
+                    raise ValueError(f'{path}:{line}: invalid JSON: {error.msg}') from error
+                validate_row(row, line)
+                if require_target and 'target' not in row:
+                    raise ValueError(f'{path}:{line}: training requires target')
+                if require_teacher and 'teacher_logits' not in row:
+                    raise ValueError(f'{path}:{line}: distillation requires teacher_logits')
+                self.rows.append(row)
+        if not self.rows:
+            raise ValueError(f'{path}: dataset contains no rows')
+        flags = {'teacher_logits' in row for row in self.rows}
+        if len(flags) != 1:
+            raise ValueError('Dataset mixes rows with and without teacher logits')
+
+    def __len__(self):
+        return len(self.rows)
+
+    def __getitem__(self, index):
+        return self.rows[index]
+
+
+def sequence(tokenizer, row, max_length=1024, head_length=256, *, strict=False):
+    if head_length + 4 >= max_length:
+        raise ValueError('max_length must leave room beyond the question head')
+    if any(x is None for x in (tokenizer.mask_token_id, tokenizer.cls_token_id, tokenizer.sep_token_id)):
+        raise ValueError('Tokenizer must define MASK, CLS and SEP IDs')
+    state = row['state'] if isinstance(row['state'], str) else json.dumps(row['state'], ensure_ascii=False)
+    if strict and any(tokenizer.mask_token in text for text in [state, row['question'], *row['options']]):
+        raise ValueError('Reserved model marker in request')
+    clean = lambda text: text.replace(tokenizer.mask_token, ' ')
+    encode = lambda text: tokenizer(text, add_special_tokens=False)['input_ids']
+    head = encode(f"{row.get('type', 'choice')} question: {clean(row['question'])}")
+    option_ids = [encode(' ' + clean(x)) for x in row['options']]
+    if strict and any(len(x) > 48 for x in option_ids):
+        raise ValueError('Option exceeds 48-token model contract')
+    options = [[tokenizer.mask_token_id] + x[:48] for x in option_ids]
+    budget = head_length - sum(map(len, options))
+    if budget < 16:
+        per_option = max(4, (head_length - 16) // len(options))
+        options = [x[:per_option] for x in options]
+        budget = head_length - sum(map(len, options))
+    if strict and (len(head) > budget or any(len(x) != len(y) + 1 for x, y in zip(options, option_ids))):
+        raise ValueError('Question/options exceed lossless head budget')
+    ids = [tokenizer.cls_token_id] + head[:max(8, budget)] + [tokenizer.sep_token_id]
+    markers = []
+    for option in options:
+        markers.append(len(ids))
+        ids.extend(option)
+    ids.append(tokenizer.sep_token_id)
+    state_ids = encode(clean(state))
+    room = max_length - len(ids) - 1
+    if room < 1:
+        raise ValueError('Question/options exceed sequence budget; shorten descriptions')
+    if strict and len(state_ids) > room:
+        raise ValueError('Game state exceeds lossless context budget')
+    result = dict(ids=ids + state_ids[:room] + [tokenizer.sep_token_id], markers=markers,
+                  qtype=QTYPES[row.get('type', 'choice')], truncated=len(state_ids) > room)
+    if strict:
+        result['option_tokens'] = list(map(len, option_ids))
+    return result
+
+
+class Collator:
+    def __init__(self, tokenizer, max_length=512, head_length=256):
+        self.tokenizer, self.max_length, self.head_length = tokenizer, max_length, head_length
+
+    def __call__(self, rows, *, include_targets=True):
+        encoded = [row['_encoded'] if '_encoded' in row else sequence(
+            self.tokenizer, row, self.max_length, self.head_length) for row in rows]
+        length = min(self.max_length, ((max(len(x['ids']) for x in encoded) + 7) // 8) * 8)
+        count = max(len(x['markers']) for x in encoded)
+        ids = torch.full((len(rows), length), self.tokenizer.pad_token_id, dtype=torch.long)
+        attention = torch.zeros_like(ids)
+        positions = torch.zeros((len(rows), count), dtype=torch.long)
+        mask = torch.zeros_like(positions, dtype=torch.bool)
+        has_teacher = include_targets and all('teacher_logits' in row for row in rows)
+        teacher = torch.zeros_like(positions, dtype=torch.float32) if has_teacher else None
+        for i, (row, item) in enumerate(zip(rows, encoded)):
+            n, k = len(item['ids']), len(item['markers'])
+            ids[i, :n] = torch.tensor(item['ids'])
+            attention[i, :n] = 1
+            positions[i, :k] = torch.tensor(item['markers'])
+            mask[i, :k] = True
+            if has_teacher:
+                teacher[i, :k] = torch.tensor(row['teacher_logits'])
+        batch = dict(input_ids=ids, attention_mask=attention, marker_pos=positions,
+                     marker_mask=mask, qtype=torch.tensor([x['qtype'] for x in encoded]))
+        if include_targets and all('target' in row for row in rows):
+            batch['labels'] = torch.tensor([row['target'] for row in rows])
+        if has_teacher:
+            batch['teacher_logits'] = teacher
+        return batch

julia/inference.py

@@ -0,0 +1,74 @@
+"""Resident CUDA inference for native Julia and CUDA INT8 checkpoints."""
+import json
+from pathlib import Path
+import torch
+from safetensors.torch import load_file
+from .cuda import configure, move
+from .data import Collator, validate_row
+from .probabilities import display_probabilities
+
+
+class TransformerEngine:
+    def __init__(self, checkpoint, device='cuda', max_length=1024, head_length=256, *, memory_map=True):
+        from transformers import AutoModel, AutoTokenizer
+        from .model import JuliaDecisionModel
+        self.device = configure(device)
+        root = Path(checkpoint)
+        if (root / 'INCOMPLETE').exists():
+            raise ValueError('Refusing to load an incomplete INT8 export')
+        self.tokenizer = AutoTokenizer.from_pretrained(root / 'tokenizer', trust_remote_code=False)
+        if (root / 'quantization.json').exists():
+            if self.device.type != 'cuda':
+                raise ValueError('This INT8 checkpoint requires CUDA')
+            encoder = AutoModel.from_pretrained(root / 'encoder', device_map={'': self.device.index or 0},
+                        attn_implementation='sdpa', trust_remote_code=False)
+            config = json.loads((root / 'julia_config.json').read_text())
+            self.model = JuliaDecisionModel(encoder, **{k: config[k] for k in ('head_layers', 'n_act', 'dropout')})
+            heads = load_file(str(root / 'heads.safetensors'))
+            expected = {k for k in self.model.state_dict() if not k.startswith('encoder.')}
+            if set(heads) != expected:
+                raise ValueError('INT8 decision-head tensor keys do not match checkpoint architecture')
+            self.model.load_state_dict(heads, strict=False)
+            for name, child in self.model.named_children():
+                if name != 'encoder':
+                    child.to(self.device)
+        else:
+            self.model = JuliaDecisionModel.from_pretrained(root, memory_map=memory_map).to(self.device)
+        self.model.eval()
+        self.collate = Collator(self.tokenizer, max_length, head_length)
+
+    @torch.inference_mode()
+    def logits(self, rows):
+        if not rows:
+            return []
+        for i, row in enumerate(rows):
+            validate_row(row, i + 1)
+        batch = move(self.collate(rows, include_targets=False), self.device)
+        with torch.autocast(device_type=self.device.type, dtype=torch.bfloat16, enabled=self.device.type == 'cuda'):
+            logits = self.model(**batch)
+        logits = logits.cpu()
+        if not torch.isfinite(logits).all():
+            raise FloatingPointError('Inference returned nonfinite logits')
+        return [values[:len(row['options'])].tolist() for values, row in zip(logits, rows)]
+
+    def predict(self, rows):
+        result = []
+        for values in self.logits(rows):
+            probabilities = torch.tensor(values).softmax(-1)
+            result.append(dict(index=int(probabilities.argmax()),
+                               probabilities=display_probabilities(probabilities.tolist())))
+        return result
+
+
+def load_model(checkpoint, device='cpu', max_length=1024, head_length=256, *, backend=None, **kwargs):
+    """Load a Julia checkpoint through the supported resident inference runtime."""
+    from .router.engine import FastEngine
+    if checkpoint is None:
+        raise ValueError('checkpoint is required; pass a local model directory')
+    if backend not in (None, 'torch', 'bend', 'bend-dense'):
+        raise ValueError('backend must be torch, bend, or bend-dense')
+    return FastEngine(checkpoint, device, max_length, head_length,
+                      transformer_backend=backend, **kwargs)
+
+
+Engine = load_model  # Backward compatible entry point.

julia/model.py

@@ -0,0 +1,133 @@
+"""Marker based decision model and checkpoint serialization."""
+import json
+from pathlib import Path
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+from torch.utils.checkpoint import checkpoint
+from safetensors.torch import load_file, save_file
+from transformers import AutoConfig, AutoModel
+
+
+class JuliaDecisionModel(nn.Module):
+    def __init__(self, encoder, head_layers=2, n_act=2, dropout=.1):
+        super().__init__()
+        self.encoder = encoder
+        width = encoder.config.hidden_size
+        self.settings = dict(head_layers=head_layers, n_act=n_act, dropout=dropout)
+        layer = nn.TransformerEncoderLayer(width, max(1, width // 64), 4 * width,
+                                          dropout, batch_first=True, norm_first=True)
+        self.head = nn.TransformerEncoder(layer, head_layers, enable_nested_tensor=False) if head_layers else None
+        self.type_emb = nn.Embedding(3, width)
+        self.scorer = nn.Sequential(nn.LayerNorm(width), nn.Linear(width, width), nn.GELU(), nn.Linear(width, 1))
+        self.act_head = nn.Sequential(nn.Linear(width + 4, 256), nn.GELU(), nn.Linear(256, n_act))
+        self.register_buffer('temperature', torch.ones(3))
+        self.head_checkpointing = False
+        self.marker_only_head = False
+        self.encoder.config.reference_compile = False
+
+    @classmethod
+    def from_backbone(cls, path, revision=None, head_layers=2):
+        encoder = AutoModel.from_pretrained(path, revision=revision, trust_remote_code=False,
+                                          attn_implementation='sdpa')
+        return cls(encoder, head_layers=head_layers)
+
+    def forward(self, input_ids, attention_mask, marker_pos, marker_mask, qtype, return_actions=False):
+        hidden = self.encoder(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state
+        hidden = hidden + self.type_emb(qtype)[:, None, :]
+        # Only option positions (and CLS for the action head) are consumed.
+        # The final block can keep full K/V context while avoiding unused queries
+        # and feed-forward outputs. Training retains the original dropout path.
+        selected = marker_pos
+        if return_actions:
+            selected = torch.cat((torch.zeros_like(marker_pos[:, :1]), marker_pos), dim=1)
+        sparse = (self.marker_only_head and not self.training and self.head is not None
+                  and len(self.head.layers) > 0
+                  and type(self.head.layers[-1]) is nn.TransformerEncoderLayer)
+        if self.head is not None:
+            padding = ~attention_mask.bool()
+            for i, layer in enumerate(self.head.layers):
+                if sparse and i == len(self.head.layers) - 1:
+                    hidden = self._selected_head(layer, hidden, selected, attention_mask)
+                elif self.head_checkpointing and self.training:
+                    hidden = checkpoint(layer, hidden, src_key_padding_mask=padding, use_reentrant=False)
+                else:
+                    hidden = layer(hidden, src_key_padding_mask=padding)
+        if not sparse:
+            positions = selected[:, :, None].expand(-1, -1, hidden.shape[-1])
+            hidden = hidden.gather(1, positions)
+        markers = hidden[:, 1:] if return_actions else hidden
+        scores = self.scorer(markers).squeeze(-1).float()
+        scores = scores.masked_fill(~marker_mask, -1e4)
+        if not return_actions:
+            return scores
+        probability = scores.detach().softmax(-1)
+        top = probability.topk(min(2, probability.shape[1]), dim=-1).values
+        if top.shape[1] == 1:
+            top = torch.cat((top, torch.zeros_like(top)), dim=-1)
+        count = marker_mask.sum(-1).clamp_min(2).float()
+        entropy = -(probability * probability.clamp_min(1e-9).log()).sum(-1) / count.log()
+        features = torch.stack((top[:, 0], top[:, 0] - top[:, 1], entropy, count / 255), -1)
+        actions = self.act_head(torch.cat((hidden[:, 0].float(), features), -1))
+        return scores, actions
+
+    @staticmethod
+    def _selected_head(layer, hidden, selected, attention_mask):
+        """Exact pre-norm block restricted to selected output positions (eval only)."""
+        width = hidden.shape[-1]
+        positions = selected[:, :, None].expand(-1, -1, width)
+        normalized = layer.norm1(hidden)
+        attn = layer.self_attn
+        query = F.linear(normalized.gather(1, positions),
+                         attn.in_proj_weight[:width], attn.in_proj_bias[:width])
+        key, value = F.linear(normalized, attn.in_proj_weight[width:],
+                              attn.in_proj_bias[width:]).chunk(2, dim=-1)
+        batch = hidden.shape[0]
+        heads = attn.num_heads
+        split = lambda x: x.reshape(batch, -1, heads, width // heads).transpose(1, 2)
+        attended = F.scaled_dot_product_attention(
+            split(query), split(key), split(value),
+            attn_mask=attention_mask[:, None, None, :].bool(), dropout_p=0.)
+        attended = attended.transpose(1, 2).reshape(batch, selected.shape[1], width)
+        result = hidden.gather(1, positions) + attn.out_proj(attended)
+        return result + layer.linear2(layer.activation(layer.linear1(layer.norm2(result))))
+
+    def save_pretrained(self, directory):
+        root = Path(directory)
+        root.mkdir(parents=True, exist_ok=True)
+        self.encoder.config.save_pretrained(root / 'encoder')
+        config = dict(format_version=1, architecture='JuliaDecisionModel',
+                      weight_dtype=str(next(self.parameters()).dtype).replace('torch.', ''), **self.settings)
+        (root / 'julia_config.json').write_text(json.dumps(config, indent=2) + '\n')
+        save_file({k: v.detach().cpu().contiguous() for k, v in self.state_dict().items()},
+                  str(root / 'model.safetensors'), metadata={'format': 'pt', 'family': 'julia'})
+
+    @classmethod
+    def from_pretrained(cls, directory, *, memory_map=False):
+        root = Path(directory)
+        if (root / 'julia_config.json').exists():
+            config = json.loads((root / 'julia_config.json').read_text())
+            if config['format_version'] != 1:
+                raise ValueError('Unsupported Julia checkpoint format')
+            settings = {k: config[k] for k in ('head_layers', 'n_act', 'dropout')}
+        else:
+            config = json.loads((root / 'rl_agent_config.json').read_text())
+            settings = dict(head_layers=config['head_layers'], n_act=len(config.get('act_costs', {})) + 1)
+        encoder_config = AutoConfig.from_pretrained(root / 'encoder', trust_remote_code=False)
+        encoder_config.reference_compile = False
+        try:
+            from transformers.initialization import no_init_weights
+        except ImportError:
+            from transformers.modeling_utils import no_init_weights
+        with no_init_weights():
+            encoder = AutoModel.from_config(encoder_config, attn_implementation='sdpa', trust_remote_code=False)
+            model = cls(encoder, **settings)
+        if not memory_map and config.get('weight_dtype') == 'bfloat16':
+            model.to(dtype=torch.bfloat16)
+        # Inference can retain safetensors' private file-backed storage rather than
+        # copying the entire (mostly unused vocabulary) embedding into anonymous RAM.
+        # The default copy path remains available for training and mutable checkpoints.
+        model.load_state_dict(load_file(str(root / 'model.safetensors')),
+                              strict=True, assign=memory_map)
+        return model

julia/probabilities.py

@@ -0,0 +1,17 @@
+"""Presentation rules for decision probabilities; logits and selection stay raw."""
+
+
+def display_probabilities(probabilities):
+    values = list(probabilities)
+    if not values:
+        return values
+
+    winner = max(range(len(values)), key=values.__getitem__)
+    if values[winner] > 0.95 and all(
+        value < 0.045 for i, value in enumerate(values) if i != winner
+    ):
+        return [1.0 if i == winner else 0.0 for i in range(len(values))]
+
+    visible = [value if value >= 0.01 else 0.0 for value in values]
+    total = sum(visible)
+    return [value / total for value in visible]

julia/router/.gitignore

@@ -0,0 +1,3 @@
+build/
+__pycache__/
+*.pyc

julia/router/README.md

@@ -0,0 +1,157 @@
+# Julia router
+
+Resident inference for Julia on **CPU or CUDA**, located in the existing `julia`
+package. No separate repository. Python loads Bend-generated C with `ctypes`;
+there is no compiler or subprocess in the request path.
+
+## Build and use
+
+From the **Julia-1** directory (the outer workspace also has an older package
+named `julia`, so running there can import the wrong one):
+
+```bash
+python -m pip install -e .
+python -m julia.router.build --bend /home/klee/.bend/bin/bend
+```
+
+The native build requires Bend **2.0.27**, Clang, and Linux. It checks `native/PROOF.bend`, generated
+function arities, and the borrowed-tree contract before compiling. `--native-cpu`
+adds host-specific machine instructions; use that build only on compatible CPUs. The bridge
+uses private Bend runtime internals, so upgrading Bend requires adapting and
+retesting the bridge. `--output` selects another library location; pass that
+path as `library=` or set `JULIA_ROUTER_LIBRARY` at runtime.
+
+```python
+from julia.router import FastEngine
+
+engine = FastEngine('/path/to/real/checkpoint', device='cpu', batch_size=16)
+# device='cuda' uses CUDA/BF16 and device-side softmax/argmax.
+rows = [{
+    'state': 'Preciso trocar minha senha.',
+    'question': 'Qual é a intenção?',
+    'options': ['Redefinir senha', 'Cancelar conta', 'Consultar saldo'],
+}]
+print(engine.predict(rows))
+print(engine.predict(rows, probabilities=False))  # return only indices
+```
+
+Use real checkpoint files, not Git LFS pointer files. The 2026-09-23 runtime audit
+loaded the actual 551 MiB checkpoint offline and exercised resident inference.
+
+## Faster inference path
+
+- Bounded LRU caches reuse token fragments and full request encodings. Model
+  forward passes still run on **every request**; no answer cache inflates timings.
+- Sort by encoded length before bounded microbatches, then restore request order.
+  This reduces padding on mixed-length inputs; it does not guarantee a speedup
+  for every batch or request size.
+- Build one NumPy arena for integer inputs, with zero-copy CPU tensor views.
+  CUDA uses two pinned bulk transfers instead of per-field transfers.
+- Softmax and argmax run on the model's device. CUDA does not copy hidden states
+  or attention matrices into CPU Bend kernels.
+- `compile_model=True` enables optional `torch.compile(dynamic=True)`. Compilation
+  adds first-call cost and requires validation on the target device.
+- CPU inference retains private file-backed safetensors storage instead of copying
+  the full vocabulary embedding into anonymous RAM. Keep checkpoint files immutable
+  while loaded; use `memory_map=False` for a detached copy. Training model loading
+  still copies by default.
+- CPU PyTorch heads compute only option queries and feed-forward outputs in the
+  final layer. Full context keys/values are retained. `marker_only_head=False`
+  selects the original path; training and the separate experimental Bend normalization head use the original
+  path automatically. CUDA retains the original default until hardware validation.
+- `strict_encoding=True` rejects marker injection and any question/option/state
+  truncation. `encoding_info(rows)` audits the same cached encoding used in inference;
+  the game worker no longer tokenizes each request twice.
+- Preserve Julia's original marker serialization, truncation, weights, and
+  option order. Returned probabilities use the model card presentation rules;
+`logits()` retains raw scores.
+
+CPU defaults to Python/PyTorch (`torch`), with no Bend build required. CUDA also
+uses PyTorch. Select `transformer_backend='bend-dense'` explicitly to use the
+optional CPU FP32 Bend encoder. `compile_model=True` works with the default Torch
+backend.
+
+## Bend transformer operations
+
+`native/router.bend` implements candidate argmax, numerically stabilized softmax,
+and two-pass LayerNorm (mean, centered variance, affine scale/bias). Balanced
+`Leaf`/`Fork` trees expose candidate reductions. LayerNorm forks over independent
+rows and uses flat tail loops over feature lists within each row, following the
+Bend guide's coarse-work/flat-leaf cost model. All use Bend's own heap. The C adapter transports arrays and owns the ABI; it does
+not duplicate the numerical algorithms.
+
+```python
+from julia.router import BendReducer, FastEngine
+
+bend = BendReducer()
+index, probabilities = bend.softmax([1.0, 3.0, -2.0])
+normalized = bend.layernorm([[1.0, 2.0, 3.0]])
+
+# Explicit experimental CPU transformer-head backend:
+engine = FastEngine('/path/to/checkpoint', device='cpu',
+                    transformer_backend='bend', bend_postprocess=True)
+
+# All 88 encoder projections of the real checkpoint also execute in Bend:
+# Set JULIA_BEND_THREADS=4 before creating the engine.
+engine = FastEngine('/path/to/checkpoint', device='cpu',
+                    transformer_backend='bend-dense', bend_postprocess=True)
+```
+
+The experimental head executes its pre-attention and pre-MLP LayerNorms, plus
+scorer LayerNorm, in Bend. Dense projections, attention, and the encoder remain
+PyTorch. This is **not a complete transformer rewrite in Bend**. Bend head math
+is inference-only CPU float32. The CPU library defaults to up to eight available Bend runtime
+workers. Set `JULIA_BEND_THREADS=4` **before the first native call** to test row
+parallelism; the worker count is fixed for the process. Pool sizing depends on the kernel and workload; the older normalization-only
+experiment does not determine the dense backend defaults. Reduction order differs from the
+old tree algorithm and PyTorch: probabilities can differ by floating-point rounding,
+and effectively tied choices may choose a different index.
+Calls share a mutex because Bend's runtime has global state. Instantiate model
+workers in spawned processes; do not fork an active inference process.
+
+### Resident dense projections (CPU default)
+
+`bend-dense` executes all 88 encoder projections in Bend. Resident packed FP32
+arrays replace linked weight trees. Contiguous 8×8 tiles expose vector arithmetic;
+coarse parallel ranges end in flat tail loops. Shared input/weight handles are
+read-only, output tiles are disjoint, and all handles are joined after evaluation.
+The bridge packs/transports buffers and checks bounds; the public API validates
+finite values, while engine inference validates weights once and final logits.
+
+PyTorch retains embeddings, SDPA, elementwise activations and the selected-output
+decision head. The native pool defaults to up to eight available CPUs; override
+with `JULIA_BEND_THREADS` before the first call. `JULIA_BEND_TILE_GRAIN` overrides
+the adaptive projection-specific chunk size. The snapshot rejects changed weights and must be recreated after mutation.
+Use the training loader to save or train checkpoints, not an installed backend.
+
+Packed kernels use
+validated unsafe array sharing and bounded loops; the tree shape proofs do not
+constitute a formal proof of packed-array memory safety or floating-point math.
+
+## Larger choice sets
+
+```python
+from julia.router import Router, FastEngine
+router = Router(FastEngine('/path/to/checkpoint', device='cuda'), survivors=2)
+result = router.route(row_with_up_to_4096_options)
+```
+
+Julia's trained head still supports **2–20** options. Larger *choice* requests
+use batched groups and rerank survivors until a final group remains. A group
+retains only its winner when raw softmax gives it over 95% and every other
+option is below 4.5%; otherwise it retains the configured survivor count.
+This can reduce later model calls for decisive groups, but group probabilities
+are not comparable across different groups. This adds model calls and can discard the correct candidate;
+it is a capacity feature, not a speed or quality guarantee. Final probabilities
+are conditional on `result.candidates`, never a fabricated global distribution.
+`model_rows` and `cache_hits` report aggregate work for the whole `route_many`
+call. Optional `cache_size` caches logits; it defaults to zero. Clear caches
+with `clear_cache()` after changing weights, tokenization or inference settings.
+
+## Tests
+
+```bash
+python -m unittest discover -s julia/router/tests -v
+```
+
+The tests exercise CPU inference and optional native behavior where available.

julia/router/__init__.py

@@ -0,0 +1,12 @@
+"""Python-compatible Julia router powered by compiled Bend trees."""
+from .native import BendReducer
+from .router import Router, RouteResult
+
+__all__ = ['BendReducer', 'Router', 'RouteResult', 'FastEngine']
+
+
+def __getattr__(name):
+    if name == 'FastEngine':
+        from .engine import FastEngine
+        return FastEngine
+    raise AttributeError(name)

julia/router/build.py

@@ -0,0 +1,62 @@
+"""Explicit, reproducible native build: python -m julia.router.build."""
+import argparse
+import os
+import re
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+
+
+def build(output=None, bend=None, native_cpu=False):
+    source = Path(__file__).parent / 'native' / 'router.bend'
+    bend = bend or shutil.which('bend') or str(Path.home() / '.bend/bin/bend')
+    version = subprocess.check_output([bend, 'version'], text=True).strip()
+    if not re.search(r'(?<![0-9.])2\.0\.27(?![0-9.])', version):
+        raise RuntimeError(f'Native adapter requires Bend 2.0.27; found {version}')
+    subprocess.run([bend, str(source.with_name('PROOF.bend'))], check=True)
+    output = Path(output or Path(__file__).parent / 'build/libjulia_router.so').resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(dir=output.parent) as temp:
+        generated = Path(temp) / 'router.c'
+        library = Path(temp) / 'router.so'
+        subprocess.run([bend, str(source), '-o', str(generated)], check=True)
+        emitted = generated.read_text()
+        if not all(re.search(pattern, emitted) for pattern in (
+                r'#define CUBE_T\s+128', r'#define LINE\s+16',
+                r'static u32\s+CUBE_LOG = 7;', r'#define RING_LOG\s+\(17 - CUBE_LOG\)')):
+            raise RuntimeError('CPU scheduling layout changed; refusing unsafe native build')
+        # The adapter depends on these private generated ABI/ownership contracts.
+        for name, arity in [('WINNER', 1), ('SOFTMAX', 1), ('LAYERNORM', 3), ('NORM_ROWS', 3), ('DENSE_TILE', 2), ('DENSE_BATCH', 2), ('PACKED_GEMM', 9)]:
+            match = re.search(rf'#define FID_{name} (\d+)', emitted)
+            table = re.search(r'FID_ARITY_T\[\] = \{([^}]+)', emitted)
+            if not match or not table or int(table[1].split(',')[int(match[1])]) != arity:
+                raise RuntimeError(f'Unsupported generated Bend ABI for {name}')
+        winner = emitted.split('WL_CASE(FID_WINNER)', 1)[1].split('#endif', 1)[0]
+        if 'term_peek(e, _tree_0)' not in winner:
+            raise RuntimeError('WINNER ownership changed; refusing unsafe native build')
+        tile = emitted.split('WL_CASE(FID_DENSE_TILE)', 1)[1].split('#endif', 1)[0]
+        if 'term_peek(e, _weights_0)' not in tile or 'term_peek(e, _ws_0)' not in emitted:
+            raise RuntimeError('Tiled weights must be borrowed; refusing unsafe native build')
+        batch = emitted.split('WL_CASE(FID_DENSE_BATCH)', 1)[1].split('#endif', 1)[0]
+        if 'term_peek(e, _tiles_0)' not in batch:
+            raise RuntimeError('Dense input tiles must be borrowed; refusing unsafe native build')
+        packed = emitted.split('WL_CASE(FID_PACKED_DOT)', 1)[1].split('#endif', 1)[0]
+        if not all(fragment in packed for fragment in ('r0 = _x_0;', 'r1 = _w_0;', 'r2 = _o_0;', 'WL_RETN(3);')):
+            raise RuntimeError('Packed result ABI changed; refusing unsafe native build')
+        from .specialize import packed_cpu
+        generated.write_text(packed_cpu(emitted))
+        subprocess.run([os.environ.get('CC', 'clang'), '-O3', '-ffp-contract=fast',
+                        *(['-march=native'] if native_cpu else []), '-fPIC', '-shared',
+                        '-pthread', str(generated), '-lm', '-ldl', '-o', str(library)], check=True)
+        os.replace(library, output)
+    return output
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--output')
+    parser.add_argument('--bend')
+    parser.add_argument('--native-cpu', action='store_true', help='Optimize for this CPU; do not distribute to other CPUs')
+    args = parser.parse_args()
+    print(build(args.output, args.bend, args.native_cpu))

julia/router/encoder.py

@@ -0,0 +1,32 @@
+"""Inference-only ModernBERT path for decision models (no unused outputs)."""
+from types import MethodType
+import torch
+from transformers.modeling_outputs import BaseModelOutput
+
+
+def _decision_forward(self, input_ids=None, attention_mask=None, **kwargs):
+    if self.training or kwargs or input_ids is None or attention_mask is None:
+        return self._julia_original_forward(input_ids=input_ids, attention_mask=attention_mask, **kwargs)
+    position_ids = torch.arange(input_ids.shape[1], device=input_ids.device).unsqueeze(0)
+    full_mask, local_mask = self._update_attention_mask(attention_mask, output_attentions=False)
+    hidden = self.embeddings(input_ids=input_ids)
+    # Upstream iterates config.layer_types (one entry per layer), overwriting
+    # the same two dictionary entries 22 times in this checkpoint.
+    positions = {kind: self.rotary_emb(hidden, position_ids, kind) for kind in self._julia_attention_types}
+    for layer in self.layers:
+        hidden = layer(hidden, attention_mask=full_mask, sliding_window_mask=local_mask,
+                       position_ids=position_ids, cu_seqlens=None, max_seqlen=None,
+                       position_embeddings=positions[layer.attention_type], output_attentions=False)[0]
+    return BaseModelOutput(last_hidden_state=self.final_norm(hidden))
+
+
+def specialize_decision_encoder(model):
+    encoder = model.encoder
+    if encoder.config.model_type != 'modernbert' or encoder.config._attn_implementation != 'sdpa':
+        return False
+    if hasattr(encoder, '_julia_original_forward'):
+        return True
+    encoder._julia_original_forward = encoder.forward
+    encoder._julia_attention_types = tuple(dict.fromkeys(encoder.config.layer_types))
+    encoder.forward = MethodType(_decision_forward, encoder)
+    return True

julia/router/engine.py

@@ -0,0 +1,225 @@
+"""Resident CPU/CUDA inference with cached encoding and length-aware batches."""
+from collections import OrderedDict
+import json
+from pathlib import Path
+import threading
+
+import numpy as np
+import torch
+
+from ..data import sequence, validate_row
+from ..probabilities import display_probabilities
+from ..inference import TransformerEngine as Engine
+
+
+class _TokenCache:
+    def __init__(self, tokenizer, capacity):
+        self.tokenizer, self.capacity = tokenizer, capacity
+        self.cache = OrderedDict()
+
+    def __getattr__(self, name):
+        return getattr(self.tokenizer, name)
+
+    def __call__(self, text, add_special_tokens=False):
+        if text not in self.cache:
+            ids = self.tokenizer(text, add_special_tokens=False)['input_ids']
+            if self.capacity:
+                self.cache[text] = tuple(ids)
+                while len(self.cache) > self.capacity:
+                    self.cache.popitem(last=False)
+            return {'input_ids': ids}
+        self.cache.move_to_end(text)
+        return {'input_ids': list(self.cache[text])}
+
+
+class FastEngine(Engine):
+    """Same weights/serialization as Engine; no cached model predictions.
+
+    Optional torch.compile specializes the transformer, while Bend handles CPU
+    softmax/selection via ctypes. CUDA softmax stays on-device to avoid a roundtrip.
+    """
+    def __init__(self, checkpoint, device='cpu', max_length=1024, head_length=256,
+                 batch_size=16, encoding_cache=2048, token_cache=8192,
+                 compile_model=False, library=None, bend_postprocess=False, transformer_backend=None,
+                 strict_encoding=False, marker_only_head=None, memory_map=True, padding_ratio=1.25):
+        if not 1 <= padding_ratio <= 16:
+            raise ValueError('padding_ratio must be between 1 and 16')
+        self.padding_ratio = padding_ratio
+        if batch_size < 1 or encoding_cache < 0 or token_cache < 0:
+            raise ValueError('Invalid batch/cache size')
+        if transformer_backend not in (None, 'torch', 'bend', 'bend-dense'):
+            raise ValueError('transformer_backend must be torch, bend, or bend-dense')
+        if transformer_backend in ('bend', 'bend-dense') and (str(device) != 'cpu' or compile_model):
+            raise ValueError('Bend requires eager CPU inference; compilation requires the torch backend')
+        weights = Path(checkpoint) / 'model.safetensors'
+        if weights.is_file():
+            with weights.open('rb') as stream:
+                if stream.read(80).startswith(b'version https://git-lfs.github.com/spec/v1'):
+                    raise ValueError('Checkpoint contains Git LFS pointers; fetch the real model weights first')
+        super().__init__(checkpoint, device, max_length, head_length, memory_map=memory_map)
+        self.model.marker_only_head = (self.device.type == 'cpu' if marker_only_head is None else marker_only_head)
+        self.strict_encoding = strict_encoding
+        self.batch_size = batch_size
+        self.max_length, self.head_length = max_length, head_length
+        self.encoding_cache = encoding_cache
+        self._encoded = OrderedDict()
+        self._tokens = _TokenCache(self.tokenizer, token_cache)
+        self._lock = threading.RLock()
+        self.bend = None
+        if bend_postprocess and self.device.type == 'cpu':
+            from .native import BendReducer
+            self.bend = BendReducer(library)
+        if transformer_backend is None:
+            transformer_backend = 'torch'
+        self.transformer_backend = transformer_backend
+        if transformer_backend in ('bend', 'bend-dense'):
+            if next(self.model.parameters()).dtype != torch.float32:
+                raise ValueError('Bend backends require FP32 weights')
+            from .native import BendReducer
+            from .transformer import install_bend_head
+            reducer = self.bend or BendReducer(library)
+            if transformer_backend == 'bend':
+                install_bend_head(self.model, reducer)
+            if transformer_backend == 'bend-dense':
+                from .transformer import install_bend_encoder
+                self.bend_projection_count = install_bend_encoder(self.model, reducer)
+        from .encoder import specialize_decision_encoder
+        self.encoder_specialized = specialize_decision_encoder(self.model)
+        self.forward = self.model
+        if compile_model:
+            self.forward = torch.compile(self.model, dynamic=True)
+
+    def clear_cache(self):
+        with self._lock:
+            self._encoded.clear()
+            self._tokens.cache.clear()
+
+    def _encode(self, rows):
+        result = []
+        for i, row in enumerate(rows):
+            validate_row(row, i + 1)
+            key = json.dumps([self.max_length, self.head_length, self.strict_encoding,
+                              row['state'], row['question'], row['options'],
+                              row.get('type', 'choice')], ensure_ascii=False, allow_nan=False)
+            encoded = self._encoded.get(key)
+            if encoded is None:
+                encoded = sequence(self._tokens, row, self.max_length, self.head_length,
+                                   strict=self.strict_encoding)
+                if self.encoding_cache:
+                    self._encoded[key] = encoded
+                    while len(self._encoded) > self.encoding_cache:
+                        self._encoded.popitem(last=False)
+            else:
+                self._encoded.move_to_end(key)
+            result.append(encoded)
+        return result
+
+    def encoding_info(self, rows):
+        """Audit the same cached encoding used by inference, without retokenizing."""
+        if not self.strict_encoding:
+            raise ValueError('Lossless encoding audit requires strict_encoding=True')
+        with self._lock:
+            return [dict(tokens=len(item['ids']), optionTokens=list(item['option_tokens']),
+                         headLength=self.head_length, stateTruncated=False, optionsTruncated=False)
+                    for item in self._encode(rows)]
+
+    def _pack(self, encoded):
+        length = min(self.max_length, (max(len(x['ids']) for x in encoded) + 7) // 8 * 8)
+        count = max(len(x['markers']) for x in encoded)
+        size = len(encoded)
+        arena = np.zeros(size * (2 * length + count + 1), dtype=np.int64)
+        end = size * length
+        ids = arena[:end].reshape(size, length)
+        ids.fill(self.tokenizer.pad_token_id)
+        attention = arena[end:2 * end].reshape(size, length)
+        positions = arena[2 * end:2 * end + size * count].reshape(size, count)
+        qtype = arena[-size:]
+        mask = np.zeros((size, count), dtype=np.bool_)
+        for i, item in enumerate(encoded):
+            n, k = len(item['ids']), len(item['markers'])
+            ids[i, :n] = item['ids']
+            attention[i, :n] = 1
+            positions[i, :k] = item['markers']
+            mask[i, :k] = True
+            qtype[i] = item['qtype']
+        host = torch.from_numpy(arena)
+        marker_mask = torch.from_numpy(mask)
+        if self.device.type == 'cuda':
+            host = host.pin_memory().to(self.device, non_blocking=True)
+            marker_mask = marker_mask.pin_memory().to(self.device, non_blocking=True)
+        return dict(input_ids=host[:end].view(size, length),
+                    attention_mask=host[end:2 * end].view(size, length),
+                    marker_pos=host[2 * end:2 * end + size * count].view(size, count),
+                    qtype=host[-size:], marker_mask=marker_mask)
+
+    def _batch_indices(self, encoded):
+        # Bound padding inflation, not just batch count: a single long request
+        # must not make every short request run the entire encoder at its length.
+        order = sorted(range(len(encoded)), key=lambda i: len(encoded[i]['ids']))
+        group, tokens = [], 0
+        for index in order:
+            length = len(encoded[index]['ids'])
+            if group and (len(group) == self.batch_size or
+                          (len(group) + 1) * length > self.padding_ratio * (tokens + length)):
+                yield group
+                group, tokens = [], 0
+            group.append(index)
+            tokens += length
+        if group:
+            yield group
+
+    def _batches(self, encoded):
+        for indices in self._batch_indices(encoded):
+            batch = self._pack([encoded[i] for i in indices])
+            with torch.autocast(device_type=self.device.type, dtype=torch.bfloat16,
+                                enabled=self.device.type == 'cuda'):
+                values = self.forward(**batch)
+            # Padding must never win against real very negative logits.
+            values = values.masked_fill(~batch['marker_mask'], -torch.inf)
+            if not (torch.isfinite(values) | ~batch['marker_mask']).all():
+                raise FloatingPointError('Inference returned nonfinite logits')
+            yield indices, values
+
+    @torch.inference_mode()
+    def logits(self, rows):
+        with self._lock:
+            encoded = self._encode(rows)
+            result = [None] * len(rows)
+            for indices, values in self._batches(encoded):
+                host = values.cpu().tolist()
+                for i, scores in zip(indices, host):
+                    result[i] = scores[:len(encoded[i]['markers'])]
+            return result
+
+    @torch.inference_mode()
+    def predict(self, rows, *, probabilities=True):
+        with self._lock:
+            encoded = self._encode(rows)
+            result = [None] * len(rows)
+            for indices, values in self._batches(encoded):
+                if self.bend is not None:
+                    host = values.contiguous().numpy()
+                    for local, i in enumerate(indices):
+                        scores = host[local, :len(encoded[i]['markers'])]
+                        if probabilities:
+                            best, probs = self.bend.softmax(scores)
+                        else:
+                            best = self.bend.argmax(scores)
+                        result[i] = dict(index=best)
+                        if probabilities:
+                            result[i]['probabilities'] = display_probabilities(probs.tolist())
+                else:
+                    best_device = values.argmax(-1)
+                    if probabilities and self.device.type == 'cuda':
+                        host = torch.cat((best_device[:, None].to(values.dtype),
+                                          values.softmax(-1)), dim=1).cpu().tolist()
+                        best = [int(row[0]) for row in host]
+                        probs = [row[1:] for row in host]
+                    else:
+                        best = best_device.cpu().tolist()
+                        probs = values.softmax(-1).tolist() if probabilities else None
+                    for local, i in enumerate(indices):
+                        result[i] = dict(index=best[local])
+                        if probabilities:
+                            result[i]['probabilities'] = display_probabilities(probs[local][:len(encoded[i]['markers'])])
+            return result

julia/router/native.py

@@ -0,0 +1,159 @@
+"""ctypes boundary; no subprocess or compilation in the request path."""
+import ctypes
+import math
+import os
+from pathlib import Path
+
+
+class BendReducer:
+    def __init__(self, library=None):
+        path = Path(library or os.environ.get('JULIA_ROUTER_LIBRARY') or
+                    Path(__file__).parent / 'build/libjulia_router.so')
+        try:
+            self._lib = ctypes.CDLL(str(path.resolve()))
+        except OSError as error:
+            raise RuntimeError(
+                f'Cannot load Bend runtime {path.resolve()}. From Julia-1 run '
+                'python -m julia.router.build --native-cpu; or explicitly select '
+                'transformer_backend="torch".') from error
+        self._argmax = self._lib.julia_router_argmax
+        self._argmax.argtypes = [ctypes.POINTER(ctypes.c_float), ctypes.c_uint32,
+                                ctypes.POINTER(ctypes.c_uint32)]
+        self._argmax.restype = ctypes.c_int
+        self._ptr = ctypes.POINTER(ctypes.c_float)
+        self._softmax = self._lib.julia_router_softmax
+        self._softmax.argtypes = [self._ptr, ctypes.c_uint32, self._ptr, ctypes.POINTER(ctypes.c_uint32)]
+        self._softmax.restype = ctypes.c_int
+        self._layernorm = self._lib.julia_router_layernorm
+        self._layernorm.argtypes = [self._ptr, self._ptr, self._ptr, ctypes.c_uint32,
+                                   ctypes.c_uint32, ctypes.c_float, self._ptr]
+        self._layernorm.restype = ctypes.c_int
+
+    def profile(self, *, enabled=False, reset=False):
+        """Process-wide packed projection timings; opt in only for diagnostics."""
+        fn = self._lib.julia_router_profile
+        fn.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_double)]
+        fn.restype = None
+        values = (ctypes.c_double * 4)()
+        fn(enabled, reset, values)
+        return dict(zip(('pack_ms', 'execute_ms', 'unpack_ms', 'calls'), values))
+
+    def argmax(self, scores):
+        scores = tuple(scores)
+        if not 1 <= len(scores) <= 1048576:
+            raise ValueError('Expected 1–1048576 scores')
+        if not all(math.isfinite(x) for x in scores):
+            raise ValueError('Scores must be finite')
+        values = (ctypes.c_float * len(scores))(*scores)
+        result = ctypes.c_uint32()
+        code = self._argmax(values, len(scores), ctypes.byref(result))
+        if code:
+            raise ValueError(f'Bend rejected scores (status {code})')
+        return result.value
+
+    def softmax(self, scores):
+        import numpy as np
+        values = np.ascontiguousarray(scores, dtype=np.float32)
+        if values.ndim != 1 or not 1 <= values.size <= 1048576:
+            raise ValueError('Expected a nonempty vector of at most 1048576 scores')
+        output = np.empty_like(values)
+        index = ctypes.c_uint32()
+        code = self._softmax(values.ctypes.data_as(self._ptr), values.size,
+                             output.ctypes.data_as(self._ptr), ctypes.byref(index))
+        if code:
+            raise ValueError(f'Bend rejected scores (status {code})')
+        return index.value, output
+
+    def layernorm(self, values, gamma=None, beta=None, epsilon=1e-5):
+        import numpy as np
+        x = np.ascontiguousarray(values, dtype=np.float32)
+        if x.ndim < 1 or x.size == 0:
+            raise ValueError('Expected a nonempty feature array')
+        width = x.shape[-1]
+        g = np.ones(width, np.float32) if gamma is None else np.ascontiguousarray(gamma, dtype=np.float32)
+        b = np.zeros(width, np.float32) if beta is None else np.ascontiguousarray(beta, dtype=np.float32)
+        if g.shape != (width,) or b.shape != (width,):
+            raise ValueError('gamma and beta must match the last dimension')
+        if x.size > 1048576 or width > 65536:
+            raise ValueError('LayerNorm input exceeds native capacity')
+        output = np.empty_like(x)
+        code = self._layernorm(x.ctypes.data_as(self._ptr), g.ctypes.data_as(self._ptr),
+            b.ctypes.data_as(self._ptr), x.size // width, width, epsilon,
+            output.ctypes.data_as(self._ptr))
+        if code:
+            raise ValueError(f'Bend rejected LayerNorm inputs (status {code})')
+        return output
+
+
+class BendMatrix:
+    """Resident immutable FP32 projection weights owned by the Bend heap."""
+    def __init__(self, weights, reducer=None):
+        import numpy as np
+        import threading
+        import weakref
+        self.reducer = reducer or BendReducer()
+        self._lock = threading.RLock()
+        values = np.ascontiguousarray(weights, dtype=np.float32)
+        if values.ndim != 2 or not all(values.shape):
+            raise ValueError('Projection weights must be a nonempty matrix')
+        self.outputs, self.inputs = values.shape
+        lib = self.reducer._lib
+        create = lib.julia_router_matrix_create
+        create.argtypes = [self.reducer._ptr, ctypes.c_uint32, ctypes.c_uint32]
+        create.restype = ctypes.c_void_p
+        release = lib.julia_router_matrix_free
+        release.argtypes = [ctypes.c_void_p]
+        release.restype = None
+        self._linear = lib.julia_router_linear
+        self._linear.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint32, ctypes.c_void_p]
+        self._linear.restype = ctypes.c_int
+        self._linear_inference = lib.julia_router_linear_inference
+        self._linear_inference.argtypes = self._linear.argtypes
+        self._linear_inference.restype = ctypes.c_int
+        self._handle = create(values.ctypes.data_as(self.reducer._ptr), self.inputs, self.outputs)
+        if not self._handle:
+            raise ValueError('Bend rejected projection dimensions or nonfinite weights')
+        self._finalize = weakref.finalize(self, release, self._handle)
+
+    def close(self):
+        with self._lock:
+            self._finalize()
+
+    def tensor(self, values, *, validate=True):
+        """Fill a contiguous Torch output directly, without NumPy/list/concat wrappers."""
+        import torch
+        if values.device.type != 'cpu' or values.dtype != torch.float32 or values.shape[-1] != self.inputs:
+            raise ValueError('Bend tensor projection requires matching CPU FP32 inputs')
+        x = values.contiguous()
+        rows = x.numel() // self.inputs
+        if not rows:
+            raise ValueError('Projection input must be nonempty')
+        out = torch.empty((*x.shape[:-1], self.outputs), dtype=x.dtype, device=x.device)
+        linear = self._linear if validate else self._linear_inference
+        limit = min(1048576 // self.inputs, 1048576 // self.outputs)
+        with self._lock:
+            if not self._finalize.alive:
+                raise RuntimeError('Bend matrix has been closed')
+            for start in range(0, rows, limit):
+                code = linear(self._handle,
+                    x.data_ptr() + start * self.inputs * 4,
+                    min(limit, rows - start),
+                    out.data_ptr() + start * self.outputs * 4)
+                if code:
+                    raise ValueError(f'Bend projection failed (status {code})')
+        return out
+
+    def __call__(self, values):
+        import numpy as np
+        x = np.ascontiguousarray(values, dtype=np.float32)
+        if x.ndim < 1 or x.shape[-1] != self.inputs or not x.size:
+            raise ValueError('Projection input must match resident weights')
+        out = np.empty((*x.shape[:-1], self.outputs), dtype=np.float32)
+        with self._lock:
+            if not self._finalize.alive:
+                raise RuntimeError('Bend matrix has been closed')
+            code = self._linear(self._handle, x.ctypes.data_as(self.reducer._ptr),
+                                x.size // self.inputs, out.ctypes.data_as(self.reducer._ptr))
+        if code:
+            raise ValueError(f'Bend projection failed (status {code})')
+        return out

julia/router/native/LAWS.bend

@@ -0,0 +1,57 @@
+import Base
+import ./router.bend as R
+
+# Runtime ABI invariant: each output leaf has exactly one 4x7 tile.
+def output_tiles(result: R.TileResult) -> Nat:
+  match result:
+    case R.JTLeaf{_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _}:
+      1n
+    case R.JTFork{left, right}:
+      Nat.add(output_tiles(left), output_tiles(right))
+
+def matrix_tiles(weights: R.JuliaMatrix) -> Nat:
+  match weights:
+    case R.JMLeaf{ws}:
+      1n
+    case R.JMFork{left, right}:
+      Nat.add(matrix_tiles(left), matrix_tiles(right))
+
+# No flat dot-product branch may omit or duplicate an output tile.
+law dot_tile_shape:
+  for +xs: R.TileInput
+  for ws: R.DenseWeights
+  for s0: F32
+  for s1: F32
+  for s2: F32
+  for s3: F32
+  for s4: F32
+  for s5: F32
+  for s6: F32
+  for s7: F32
+  for s8: F32
+  for s9: F32
+  for s10: F32
+  for s11: F32
+  for s12: F32
+  for s13: F32
+  for s14: F32
+  for s15: F32
+  for s16: F32
+  for s17: F32
+  for s18: F32
+  for s19: F32
+  for s20: F32
+  for s21: F32
+  for s22: F32
+  for s23: F32
+  for s24: F32
+  for s25: F32
+  for s26: F32
+  for s27: F32
+  {output_tiles(R.dot_tile(xs, ws, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27)) == 1n : Nat}
+
+# Fork/join must preserve the output tile count for every matrix/input tree.
+law dense_shape:
+  for +xs: R.TileInput
+  for weights: R.JuliaMatrix
+  {output_tiles(R.dense_tile(xs, weights)) == matrix_tiles(weights) : Nat}

julia/router/native/PROOF.bend

@@ -0,0 +1,50 @@
+import Base
+import ./router.bend as R
+import ./LAWS.bend as Laws
+
+def Laws.dot_tile_shape(xs, ws, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27):
+  match xs ws:
+    case R.JTVal{+x0, +x1, +x2, +x3, xt} R.JWVal{+w0, +w1, +w2, +w3, +w4, +w5, +w6, wt}:
+      Laws.dot_tile_shape(xt, wt, F32.add(s0, F32.mul(x0, w0)),
+           F32.add(s1, F32.mul(x0, w1)),
+           F32.add(s2, F32.mul(x0, w2)),
+           F32.add(s3, F32.mul(x0, w3)),
+           F32.add(s4, F32.mul(x0, w4)),
+           F32.add(s5, F32.mul(x0, w5)),
+           F32.add(s6, F32.mul(x0, w6)),
+           F32.add(s7, F32.mul(x1, w0)),
+           F32.add(s8, F32.mul(x1, w1)),
+           F32.add(s9, F32.mul(x1, w2)),
+           F32.add(s10, F32.mul(x1, w3)),
+           F32.add(s11, F32.mul(x1, w4)),
+           F32.add(s12, F32.mul(x1, w5)),
+           F32.add(s13, F32.mul(x1, w6)),
+           F32.add(s14, F32.mul(x2, w0)),
+           F32.add(s15, F32.mul(x2, w1)),
+           F32.add(s16, F32.mul(x2, w2)),
+           F32.add(s17, F32.mul(x2, w3)),
+           F32.add(s18, F32.mul(x2, w4)),
+           F32.add(s19, F32.mul(x2, w5)),
+           F32.add(s20, F32.mul(x2, w6)),
+           F32.add(s21, F32.mul(x3, w0)),
+           F32.add(s22, F32.mul(x3, w1)),
+           F32.add(s23, F32.mul(x3, w2)),
+           F32.add(s24, F32.mul(x3, w3)),
+           F32.add(s25, F32.mul(x3, w4)),
+           F32.add(s26, F32.mul(x3, w5)),
+           F32.add(s27, F32.mul(x3, w6)))
+    case R.JTVal{_, _, _, _, _} R.JWEnd{}:
+      {==}
+    case R.JTEnd{} R.JWVal{_, _, _, _, _, _, _, _}:
+      {==}
+    case R.JTEnd{} R.JWEnd{}:
+      {==}
+
+def Laws.dense_shape(xs, weights):
+  match weights:
+    case R.JMLeaf{ws}:
+      Laws.dot_tile_shape(xs, ws, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+    case R.JMFork{+left, +right}:
+      %Laws.dense_shape(xs, left) : {Nat.add(Laws.output_tiles(R.dense_tile(xs, left)), Laws.output_tiles(R.dense_tile(xs, right))) == Nat.add(_, Laws.matrix_tiles(right)) : Nat}
+      %Laws.dense_shape(xs, right) : {Nat.add(Laws.output_tiles(R.dense_tile(xs, left)), Laws.output_tiles(R.dense_tile(xs, right))) == Nat.add(Laws.output_tiles(R.dense_tile(xs, left)), _) : Nat}
+      {==}

julia/router/native/bridge.c

@@ -0,0 +1,452 @@
+/* Bend 2.0.27 ABI adapter. Arithmetic lives in router.bend.
+ * WINNER borrows its tree; SOFTMAX/LAYERNORM consume it (checked at build).
+ * The generated runtime uses process globals, hence the single shared mutex.
+ */
+#include <pthread.h>
+#if defined(__AVX2__)
+#include <immintrin.h>
+#endif
+static pthread_mutex_t router_mutex = PTHREAD_MUTEX_INITIALIZER;
+static Corpus router_heap;
+/* Opt-in diagnostics, disabled during ordinary inference. Protected by router_mutex. */
+static bool router_profile_enabled = false;
+static double router_profile_totals[4] = {0}; /* pack, eval, unpack milliseconds; calls */
+static double router_clock_ms(void) {
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  return (double)now.tv_sec * 1000.0 + (double)now.tv_nsec / 1000000.0;
+}
+void julia_router_profile(int enabled, int reset, double *out) {
+  pthread_mutex_lock(&router_mutex);
+  if (out) memcpy(out, router_profile_totals, sizeof(router_profile_totals));
+  if (reset) memset(router_profile_totals, 0, sizeof(router_profile_totals));
+  router_profile_enabled = enabled != 0;
+  pthread_mutex_unlock(&router_mutex);
+}
+static Env router_env(void) {
+  if (!router_heap) {
+    const char *setting = getenv("JULIA_BEND_THREADS");
+    long available = cpu_count();
+    long threads = setting ? strtol(setting, NULL, 10) : (available < 8 ? available : 8);
+    if (threads < 1 || threads > 32) threads = 1;
+    /* CPU projections need about two coarse tasks per worker, not the GPU-sized
+     * default 16,384-lane frontier. A smaller bag keeps the same total ring
+     * capacity (deeper queues) and cuts empty-row scans on every pool turn. */
+    CUBE_LOG = 0;
+    while ((CUBE_T / LINE) * (1u << CUBE_LOG) < (u32)threads) ++CUBE_LOG;
+    const char *cube = getenv("JULIA_BEND_CUBE_LOG");
+    if (cube) {
+      char *end;
+      long value = strtol(cube, &end, 10);
+      if (*cube && !*end && value >= (long)CUBE_LOG && value <= 7) CUBE_LOG = value;
+    }
+    router_heap = corpus_setup(false, threads, 0);
+    io_stk = pool_stack();
+  }
+  return (Env){router_heap, ALC[0]};
+}
+static Term router_tree(Env e, const float *scores, u32 start, u32 end) {
+  if (end - start == 1)
+    return io_node(e, CID_LEAF, start, f32_rewrap(scores[start]));
+  u32 mid = start + (end - start) / 2;
+  Term left = router_tree(e, scores, start, mid);
+  Term right = router_tree(e, scores, mid, end);
+  return io_node(e, CID_FORK, left, right);
+}
+static Term router_eval(Env e, u32 fid, Term tree) {
+  Loc task = task_node(e, fid, TERM_HOLE, 0, 0);
+  e.mem[task] = tree;
+  return corpus_eval(e.mem, term_tsk(fid, task));
+}
+static void router_unpack(Env e, Term tree, float *output) {
+  Loc node = term_loc(tree);
+  if (term_aux(tree) == CID_LEAF) {
+    if (output) output[(u32)e.mem[node]] = f32_unbox(e.mem[node + 1]);
+  } else {
+    router_unpack(e, e.mem[node], output);
+    router_unpack(e, e.mem[node + 1], output);
+  }
+  heap_free(e, cls_fit(2), node);
+}
+static int router_valid(const float *scores, u32 count) {
+  if (!scores || !count || count > 1048576) return -1;
+  for (u32 i = 0; i < count; ++i) if (!isfinite(scores[i])) return -2;
+  return 0;
+}
+int julia_router_argmax(const float *scores, uint32_t count, uint32_t *index) {
+  int status = router_valid(scores, count);
+  if (status || !index) return status ? status : -1;
+  pthread_mutex_lock(&router_mutex);
+  Env e = router_env();
+  Term tree = router_tree(e, scores, 0, count);
+  Term result = router_eval(e, FID_WINNER, tree);
+  *index = (u32)e.mem[term_loc(result)];
+  term_drop(e, result);
+  router_unpack(e, tree, NULL);
+  pthread_mutex_unlock(&router_mutex);
+  return 0;
+}
+int julia_router_softmax(const float *scores, uint32_t count, float *out, uint32_t *index) {
+  int status = router_valid(scores, count);
+  if (status || !out || !index) return status ? status : -1;
+  pthread_mutex_lock(&router_mutex);
+  Env e = router_env();
+  Term tree = router_tree(e, scores, 0, count);
+  Term best = router_eval(e, FID_WINNER, tree);
+  *index = (u32)e.mem[term_loc(best)];
+  term_drop(e, best);
+  router_unpack(e, router_eval(e, FID_SOFTMAX, tree), out);
+  pthread_mutex_unlock(&router_mutex);
+  return router_valid(out, count);
+}
+static Term router_features(Env e, const float *x, const float *g, const float *b, u32 lo, u32 hi) {
+  if (hi - lo == 1) {
+    Loc node = heap_alloc(e, cls_fit(3));
+    e.mem[node] = f32_rewrap(x[lo]);
+    e.mem[node + 1] = f32_rewrap(g[lo]);
+    e.mem[node + 2] = f32_rewrap(b[lo]);
+    return term_ctr(CID_FEATURE, node);
+  }
+  u32 mid = lo + (hi - lo) / 2;
+  Term left = router_features(e, x, g, b, lo, mid);
+  Term right = router_features(e, x, g, b, mid, hi);
+  return io_node(e, CID_BRANCH, left, right);
+}
+static void router_unfeatures(Env e, Term tree, float *out, u32 lo, u32 hi) {
+  Loc node = term_loc(tree);
+  if (hi - lo == 1) {
+    out[lo] = f32_unbox(e.mem[node]);
+    heap_free(e, cls_fit(3), node);
+  } else {
+    u32 mid = lo + (hi - lo) / 2;
+    router_unfeatures(e, e.mem[node], out, lo, mid);
+    router_unfeatures(e, e.mem[node + 1], out, mid, hi);
+    heap_free(e, cls_fit(2), node);
+  }
+}
+static Term router_vector(Env e, const float *x, const float *g, const float *b, u32 width) {
+  Term tail = term_ctr(CID_VNIL, 0);
+  for (u32 i = width; i-- > 0;) {
+    Loc node = heap_alloc(e, cls_fit(4));
+    e.mem[node] = f32_rewrap(x[i]);
+    e.mem[node + 1] = f32_rewrap(g[i]);
+    e.mem[node + 2] = f32_rewrap(b[i]);
+    e.mem[node + 3] = tail;
+    tail = term_ctr(CID_VCONS, node);
+  }
+  return tail;
+}
+static Term router_rows(Env e, const float *x, const float *g, const float *b,
+                        u32 width, u32 lo, u32 hi) {
+  if (hi - lo == 1) {
+    Loc node = heap_alloc(e, cls_fit(1));
+    e.mem[node] = router_vector(e, x + lo * width, g, b, width);
+    return term_ctr(CID_NLEAF, node);
+  }
+  u32 mid = lo + (hi - lo) / 2;
+  Term left = router_rows(e, x, g, b, width, lo, mid);
+  Term right = router_rows(e, x, g, b, width, mid, hi);
+  return io_node(e, CID_NFORK, left, right);
+}
+static void router_unrows(Env e, Term tree, float *out, u32 width, u32 lo, u32 hi) {
+  Loc node = term_loc(tree);
+  if (hi - lo == 1) {
+    Term vector = e.mem[node];
+    // The flat affine loop builds the result in reverse order.
+    for (u32 i = width; i-- > 0;) {
+      Loc item = term_loc(vector);
+      out[lo * width + i] = f32_unbox(e.mem[item]);
+      vector = e.mem[item + 3];
+      heap_free(e, cls_fit(4), item);
+    }
+    heap_free(e, cls_fit(1), node);
+  } else {
+    u32 mid = lo + (hi - lo) / 2;
+    router_unrows(e, e.mem[node], out, width, lo, mid);
+    router_unrows(e, e.mem[node + 1], out, width, mid, hi);
+    heap_free(e, cls_fit(2), node);
+  }
+}
+int julia_router_layernorm(const float *x, const float *gamma, const float *beta,
+                          uint32_t rows, uint32_t width, float epsilon, float *out) {
+  if (!rows || !width || width > 65536 || rows > 1048576 / width || !out ||
+      !isfinite(epsilon) || epsilon <= 0) return -1;
+  int status = router_valid(x, rows * width);
+  if (!status) status = router_valid(gamma, width);
+  if (!status) status = router_valid(beta, width);
+  if (status) return status;
+  pthread_mutex_lock(&router_mutex);
+  Env e = router_env();
+  Term tree = router_rows(e, x, gamma, beta, width, 0, rows);
+  Loc task = task_node(e, FID_NORM_ROWS, TERM_HOLE, 0, 0);
+  e.mem[task] = tree;
+  e.mem[task + 1] = f32_rewrap((float)width);
+  e.mem[task + 2] = f32_rewrap(epsilon);
+  Term result = corpus_eval(e.mem, term_tsk(FID_NORM_ROWS, task));
+  router_unrows(e, result, out, width, 0, rows);
+  pthread_mutex_unlock(&router_mutex);
+  return router_valid(out, rows * width);
+}
+
+/* Resident immutable weights are built once and borrowed by every forward. */
+typedef struct { Term tree; u32 inputs; u32 outputs; bool packed; } RouterMatrix;
+static Term router_matrix(Env e, const float *w, u32 inputs, u32 outputs, u32 lo, u32 hi) {
+  if (hi - lo == 1) {
+    Term tail = term_ctr(CID_JWEND, 0);
+    for (u32 j = inputs; j-- > 0;) {
+      Loc node = heap_alloc(e, cls_fit(8));
+      for (u32 k = 0; k < 7; ++k)
+        e.mem[node + k] = f32_rewrap(lo * 7 + k < outputs ? w[(lo * 7 + k) * inputs + j] : 0.f);
+      e.mem[node + 7] = tail;
+      tail = term_ctr(CID_JWVAL, node);
+    }
+    Loc leaf = heap_alloc(e, cls_fit(1));
+    e.mem[leaf] = tail;
+    return term_ctr(CID_JMLEAF, leaf);
+  }
+  u32 mid = lo + (hi - lo) / 2;
+  Term left = router_matrix(e, w, inputs, outputs, lo, mid);
+  Term right = router_matrix(e, w, inputs, outputs, mid, hi);
+  return io_node(e, CID_JMFORK, left, right);
+}
+static void router_free_matrix(Env e, Term tree) {
+  Loc node = term_loc(tree);
+  if (term_aux(tree) == CID_JMLEAF) {
+    Term ws = e.mem[node];
+    while (term_aux(ws) == CID_JWVAL) {
+      Loc item = term_loc(ws);
+      ws = e.mem[item + 7];
+      heap_free(e, cls_fit(8), item);
+    }
+    heap_free(e, cls_fit(1), node);
+  } else {
+    router_free_matrix(e, e.mem[node]);
+    router_free_matrix(e, e.mem[node + 1]);
+    heap_free(e, cls_fit(2), node);
+  }
+}
+/* Packed FP32 buffers: padding is explicit because Bend array indices wrap. */
+static Term router_buffer_raw(Env e, u32 cells) {
+  Cls depth = cls_fit(cells);
+  Loc loc = heap_alloc(e, buf_wcls(depth));
+  return term_buf(depth, loc);
+}
+static Term router_packed_weights(Env e, const float *w, u32 inputs, u32 outputs) {
+  u32 cols = (outputs + 7) / 8 * 8;
+  Term array = router_buffer_raw(e, inputs * cols);
+  memset((void *)(e.mem + term_loc(array)), 0, (size_t)inputs * cols * sizeof(float));
+  float *data = (float *)(e.mem + term_loc(array));
+  for (u32 j = 0; j < inputs; ++j)
+    for (u32 col = 0; col < outputs; ++col)
+      data[(col / 8 * inputs + j) * 8 + col % 8] = w[col * inputs + j];
+  return array;
+}
+/* Layout conversion only: transpose eight FP32 rows without doing arithmetic. */
+static void router_pack_input(float *restrict dst, const float *restrict src, u32 rows, u32 width) {
+  u32 row = 0;
+#if defined(__AVX2__)
+  for (; row + 8 <= rows; row += 8) {
+    u32 j = 0;
+    for (; j + 8 <= width; j += 8) {
+      __m256 r[8], t[8], v[8];
+      for (u32 k = 0; k < 8; ++k) r[k] = _mm256_loadu_ps(src + (row + k) * width + j);
+      for (u32 k = 0; k < 8; k += 2) {
+        t[k] = _mm256_unpacklo_ps(r[k], r[k+1]);
+        t[k+1] = _mm256_unpackhi_ps(r[k], r[k+1]);
+      }
+      for (u32 k = 0; k < 8; k += 4) {
+        v[k] = _mm256_shuffle_ps(t[k], t[k+2], 0x44);
+        v[k+1] = _mm256_shuffle_ps(t[k], t[k+2], 0xee);
+        v[k+2] = _mm256_shuffle_ps(t[k+1], t[k+3], 0x44);
+        v[k+3] = _mm256_shuffle_ps(t[k+1], t[k+3], 0xee);
+      }
+      for (u32 k = 0; k < 4; ++k) {
+        _mm256_storeu_ps(dst + (row / 8 * width + j + k) * 8,
+                        _mm256_permute2f128_ps(v[k], v[k+4], 0x20));
+        _mm256_storeu_ps(dst + (row / 8 * width + j + k + 4) * 8,
+                        _mm256_permute2f128_ps(v[k], v[k+4], 0x31));
+      }
+    }
+    for (; j < width; ++j)
+      for (u32 k = 0; k < 8; ++k) dst[(row / 8 * width + j) * 8 + k] = src[(row+k) * width + j];
+  }
+#endif
+  for (; row < rows; ++row)
+    for (u32 j = 0; j < width; ++j)
+      dst[(row / 8 * width + j) * 8 + row % 8] = src[row * width + j];
+}
+static void router_packed_linear(Env e, RouterMatrix *matrix, const float *x, u32 rows, float *out) {
+  double begin = router_profile_enabled ? router_clock_ms() : 0.0;
+  u32 cols = (matrix->outputs + 7) / 8 * 8;
+  u32 padded_rows = (rows + 7) / 8 * 8;
+  u32 count = padded_rows / 8 * (cols / 8);
+  Term input = router_buffer_raw(e, padded_rows * matrix->inputs);
+  Term output = router_buffer_raw(e, padded_rows * cols);
+  float *input_data = (float *)(e.mem + term_loc(input));
+  if (rows % 8)
+    memset(input_data + (rows / 8) * matrix->inputs * 8, 0, matrix->inputs * 8 * sizeof(float));
+  router_pack_input(input_data, x, rows, matrix->inputs);
+  Loc task = task_node(e, FID_PACKED_GEMM, TERM_HOLE, 0, 0);
+  e.mem[task + 0] = input;
+  e.mem[task + 1] = matrix->tree;
+  e.mem[task + 2] = output;
+  e.mem[task + 3] = 0;
+  e.mem[task + 4] = count;
+  e.mem[task + 5] = cols / 8;
+  const char *grain_setting = getenv("JULIA_BEND_TILE_GRAIN");
+  u32 automatic_grain = (count + pool_size * 2 - 1) / (pool_size * 2);
+  u32 grain = grain_setting ? strtoul(grain_setting, NULL, 10) : automatic_grain;
+  if (!grain || grain > 65536) grain = automatic_grain;
+  e.mem[task + 6] = grain;
+  e.mem[task + 7] = matrix->inputs;
+  e.mem[task + 8] = (count <= grain);
+  /* PackedBuffers is flattened to three result words by Bend 2.0.27.
+   * corpus_eval clears the ready flag but leaves these words intact. The
+   * runtime mutex prevents another evaluation from overwriting the mailbox. */
+  double dispatched = router_profile_enabled ? router_clock_ms() : 0.0;
+  corpus_eval(e.mem, term_tsk(FID_PACKED_GEMM, task));
+  double evaluated = router_profile_enabled ? router_clock_ms() : 0.0;
+  input = e.mem[H_ROOT_WORD];
+  matrix->tree = e.mem[H_ROOT_WORD + 1];
+  output = e.mem[H_ROOT_WORD + 2];
+  const float *data = (const float *)(e.mem + blk_loc(e.mem, output));
+  for (u32 row = 0; row < rows; ++row) {
+    const float *tiles = data + (row / 8 * (cols / 8)) * 64 + row % 8 * 8;
+    u32 col = 0;
+    for (; col + 8 <= matrix->outputs; col += 8)
+      memcpy(out + row * matrix->outputs + col, tiles + (col / 8) * 64, 8 * sizeof(float));
+    if (col < matrix->outputs)
+      memcpy(out + row * matrix->outputs + col, tiles + (col / 8) * 64,
+             (matrix->outputs - col) * sizeof(float));
+  }
+  blk_free(e, input);
+  blk_free(e, output);
+  if (router_profile_enabled) {
+    router_profile_totals[0] += dispatched - begin;
+    router_profile_totals[1] += evaluated - dispatched;
+    router_profile_totals[2] += router_clock_ms() - evaluated;
+    router_profile_totals[3] += 1;
+  }
+}
+void *julia_router_matrix_create(const float *weights, u32 inputs, u32 outputs) {
+  if (!inputs || !outputs || inputs > 65536 || outputs > 65536 ||
+      (u64)inputs * outputs > 16777216) return NULL;
+  if (!weights) return NULL;
+  for (u64 i = 0; i < (u64)inputs * outputs; ++i) if (!isfinite(weights[i])) return NULL;
+  RouterMatrix *matrix = malloc(sizeof(*matrix));
+  if (!matrix) return NULL;
+  pthread_mutex_lock(&router_mutex);
+  Env e = router_env();
+  matrix->inputs = inputs;
+  matrix->outputs = outputs;
+  const char *kernel = getenv("JULIA_BEND_KERNEL");
+  matrix->packed = !kernel || strcmp(kernel, "tree") != 0;
+  matrix->tree = matrix->packed ? router_packed_weights(e, weights, inputs, outputs)
+      : router_matrix(e, weights, inputs, outputs, 0, (outputs + 6) / 7);
+  pthread_mutex_unlock(&router_mutex);
+  return matrix;
+}
+void julia_router_matrix_free(void *handle) {
+  if (!handle) return;
+  RouterMatrix *matrix = handle;
+  pthread_mutex_lock(&router_mutex);
+  if (matrix->packed) blk_free(router_env(), matrix->tree);
+  else router_free_matrix(router_env(), matrix->tree);
+  pthread_mutex_unlock(&router_mutex);
+  free(matrix);
+}
+static void router_tile_result(Env e, Term tree, float *out, u32 rows, u32 outputs, u32 lo, u32 hi) {
+  Loc node = term_loc(tree);
+  if (hi - lo == 1) {
+    for (u32 row = 0; row < rows; ++row)
+      for (u32 k = 0; k < 7 && lo * 7 + k < outputs; ++k)
+        out[row * outputs + lo * 7 + k] = f32_unbox(e.mem[node + row * 7 + k]);
+    heap_free(e, cls_fit(28), node);
+  } else {
+    u32 mid = lo + (hi - lo) / 2;
+    router_tile_result(e, e.mem[node], out, rows, outputs, lo, mid);
+    router_tile_result(e, e.mem[node + 1], out, rows, outputs, mid, hi);
+    heap_free(e, cls_fit(2), node);
+  }
+}
+static Term router_input_tiles(Env e, const float *x, u32 rows, u32 inputs, u32 lo, u32 hi) {
+  if (hi - lo == 1) {
+    Term xs = term_ctr(CID_JTEND, 0);
+    for (u32 i = inputs; i-- > 0;) {
+      Loc item = heap_alloc(e, cls_fit(5));
+      for (u32 k = 0; k < 4; ++k)
+        e.mem[item + k] = f32_rewrap(lo * 4 + k < rows ? x[(lo * 4 + k) * inputs + i] : 0.f);
+      e.mem[item + 4] = xs;
+      xs = term_ctr(CID_JTVAL, item);
+    }
+    Loc leaf = heap_alloc(e, cls_fit(1));
+    e.mem[leaf] = xs;
+    return term_ctr(CID_JILEAF, leaf);
+  }
+  u32 mid = lo + (hi - lo) / 2;
+  Term left = router_input_tiles(e, x, rows, inputs, lo, mid);
+  Term right = router_input_tiles(e, x, rows, inputs, mid, hi);
+  return io_node(e, CID_JIFORK, left, right);
+}
+static void router_free_tiles(Env e, Term tree) {
+  Loc node = term_loc(tree);
+  if (term_aux(tree) == CID_JILEAF) {
+    Term xs = e.mem[node];
+    while (term_aux(xs) == CID_JTVAL) {
+      Loc item = term_loc(xs);
+      xs = e.mem[item + 4];
+      heap_free(e, cls_fit(5), item);
+    }
+    heap_free(e, cls_fit(1), node);
+  } else {
+    router_free_tiles(e, e.mem[node]);
+    router_free_tiles(e, e.mem[node + 1]);
+    heap_free(e, cls_fit(2), node);
+  }
+}
+static void router_output_tiles(Env e, Term tree, float *out, u32 rows, u32 outputs, u32 lo, u32 hi) {
+  Loc node = term_loc(tree);
+  if (hi - lo == 1) {
+    u32 count = rows - lo * 4 < 4 ? rows - lo * 4 : 4;
+    router_tile_result(e, e.mem[node], out + lo * 4 * outputs, count, outputs, 0, (outputs + 6) / 7);
+    heap_free(e, cls_fit(1), node);
+  } else {
+    u32 mid = lo + (hi - lo) / 2;
+    router_output_tiles(e, e.mem[node], out, rows, outputs, lo, mid);
+    router_output_tiles(e, e.mem[node + 1], out, rows, outputs, mid, hi);
+    heap_free(e, cls_fit(2), node);
+  }
+}
+static int router_linear(void *handle, const float *x, u32 rows, float *out, bool validate) {
+  if (!handle || !x || !out || !rows) return -1;
+  RouterMatrix *matrix = handle;
+  if (rows > 1048576 / matrix->inputs || rows > 1048576 / matrix->outputs) return -1;
+  int status = validate ? router_valid(x, rows * matrix->inputs) : 0;
+  if (status) return status;
+  pthread_mutex_lock(&router_mutex);
+  Env e = router_env();
+  if (matrix->packed) {
+    router_packed_linear(e, matrix, x, rows, out);
+    pthread_mutex_unlock(&router_mutex);
+    return validate ? router_valid(out, rows * matrix->outputs) : 0;
+  }
+  u32 count = (rows + 3) / 4;
+  Term xs = router_input_tiles(e, x, rows, matrix->inputs, 0, count);
+  Loc task = task_node(e, FID_DENSE_BATCH, TERM_HOLE, 0, 0);
+  e.mem[task] = xs;
+  e.mem[task + 1] = matrix->tree;
+  Term result = corpus_eval(e.mem, term_tsk(FID_DENSE_BATCH, task));
+  router_output_tiles(e, result, out, rows, matrix->outputs, 0, count);
+  router_free_tiles(e, xs);
+  pthread_mutex_unlock(&router_mutex);
+  return validate ? router_valid(out, rows * matrix->outputs) : 0;
+}
+
+int julia_router_linear(void *handle, const float *x, u32 rows, float *out) {
+  return router_linear(handle, x, rows, out, true);
+}
+/* Internal engine path: weights are validated once, logits at the model boundary.
+ * Shape, pointer, lifetime and buffer bounds checks remain mandatory. */
+int julia_router_linear_inference(void *handle, const float *x, u32 rows, float *out) {
+  return router_linear(handle, x, rows, out, false);
+}

julia/router/native/router.bend

@@ -0,0 +1,360 @@
+import Base
+
+type Candidates is Data:
+  Leaf{index: U32, score: F32}
+  Fork{left: Candidates, right: Candidates}
+
+def pick(flag: Bool, a: Candidates, b: Candidates) -> Candidates:
+  match flag:
+    case True{}:
+      a
+    case False{}:
+      b
+
+def better(a: Candidates, b: Candidates) -> Candidates:
+  match a b:
+    case Leaf{+i, +x} Leaf{+j, +y}:
+      pick(F32.is_gt(x, y) || (F32.is_eq(x, y) && U32.is_le(i, j)), Leaf{i, x}, Leaf{j, y})
+    case _ _:
+      a
+
+def winner(tree: Candidates) -> Candidates:
+  match tree:
+    case Leaf{i, x}:
+      Leaf{i, x}
+    case Fork{left, right}:
+      a b = winner(left) winner(right)
+      better(a, b)
+
+def input() -> IO(Candidates):
+  import "./bridge.c"
+
+def output(tree: Candidates) -> IO(Unit):
+  import "./bridge.c"
+
+# Transformer math uses the same affine trees. Forks expose independent work.
+def exponentials(tree: Candidates, +maximum: F32) -> Candidates:
+  match tree:
+    case Leaf{i, x}:
+      Leaf{i, F32.exp(F32.sub(x, maximum))}
+    case Fork{left, right}:
+      a b = exponentials(left, maximum) exponentials(right, maximum)
+      Fork{a, b}
+
+def total(tree: Candidates) -> F32:
+  match tree:
+    case Leaf{i, x}:
+      x
+    case Fork{left, right}:
+      a b = total(left) total(right)
+      F32.add(a, b)
+
+def divide(tree: Candidates, +sum: F32) -> Candidates:
+  match tree:
+    case Leaf{i, x}:
+      Leaf{i, F32.div(x, sum)}
+    case Fork{left, right}:
+      a b = divide(left, sum) divide(right, sum)
+      Fork{a, b}
+
+def softmax_best(tree: Candidates, best: Candidates) -> Candidates:
+  match best:
+    case Leaf{i, maximum}:
+      +values = exponentials(tree, maximum)
+      divide(values, total(values))
+    case Fork{left, right}:
+      tree
+
+def softmax(+tree: Candidates) -> Candidates:
+  softmax_best(tree, winner(tree))
+
+type Features is Data:
+  Feature{x: F32, gamma: F32, beta: F32}
+  Branch{left: Features, right: Features}
+
+def feature_sum(tree: Features) -> F32:
+  match tree:
+    case Feature{x, gamma, beta}:
+      x
+    case Branch{left, right}:
+      a b = feature_sum(left) feature_sum(right)
+      F32.add(a, b)
+
+def variance(tree: Features, +mean: F32) -> F32:
+  match tree:
+    case Feature{x, gamma, beta}:
+      F32.square(F32.sub(x, mean))
+    case Branch{left, right}:
+      a b = variance(left, mean) variance(right, mean)
+      F32.add(a, b)
+
+def affine(tree: Features, +mean: F32, +scale: F32) -> Features:
+  match tree:
+    case Feature{x, +gamma, +beta}:
+      Feature{F32.add(F32.mul(F32.mul(F32.sub(x, mean), scale), gamma), beta), gamma, beta}
+    case Branch{left, right}:
+      a b = affine(left, mean, scale) affine(right, mean, scale)
+      Branch{a, b}
+
+def layernorm(+tree: Features, +count: F32, epsilon: F32) -> Features:
+  +mean = F32.div(feature_sum(tree), count)
+  scale = F32.div(1.0, F32.sqrt(F32.add(F32.div(variance(tree, mean), count), epsilon)))
+  affine(tree, mean, scale)
+
+def features() -> IO(Features):
+  import "./bridge.c"
+
+def write_features(tree: Features) -> IO(Unit):
+  import "./bridge.c"
+
+# Coarse parallelism: fork over independent rows, flat tail loops within a row.
+# Scalar-level tasks cost more to schedule than the arithmetic they perform.
+type Vector is Data:
+  VNil{}
+  VCons{x: F32, gamma: F32, beta: F32, next: Vector}
+
+type NormRows is Data:
+  NLeaf{values: Vector}
+  NFork{left: NormRows, right: NormRows}
+
+def vector_sum(xs: Vector, acc: F32) -> F32:
+  match xs:
+    case VNil{}:
+      acc
+    case VCons{x, g, b, next}:
+      vector_sum(next, F32.add(acc, x))
+
+def vector_variance(xs: Vector, +mean: F32, acc: F32) -> F32:
+  match xs:
+    case VNil{}:
+      acc
+    case VCons{x, g, b, next}:
+      vector_variance(next, mean, F32.add(acc, F32.square(F32.sub(x, mean))))
+
+def vector_affine(xs: Vector, +mean: F32, +scale: F32, out: Vector) -> Vector:
+  match xs:
+    case VNil{}:
+      out
+    case VCons{x, +g, +b, next}:
+      value = F32.add(F32.mul(F32.mul(F32.sub(x, mean), scale), g), b)
+      vector_affine(next, mean, scale, VCons{value, g, b, out})
+
+def norm_vector(+xs: Vector, +count: F32, epsilon: F32) -> Vector:
+  +mean = F32.div(vector_sum(xs, 0.0), count)
+  scale = F32.div(1.0, F32.sqrt(F32.add(F32.div(vector_variance(xs, mean, 0.0), count), epsilon)))
+  vector_affine(xs, mean, scale, VNil{})
+
+def norm_rows(xs: NormRows, +count: F32, +epsilon: F32) -> NormRows:
+  match xs:
+    case NLeaf{values}:
+      NLeaf{norm_vector(values, count, epsilon)}
+    case NFork{left, right}:
+      a b = norm_rows(left, count, epsilon) norm_rows(right, count, epsilon)
+      NFork{a, b}
+
+def batch_features() -> IO(NormRows):
+  import "./bridge.c"
+
+def write_batch(tree: NormRows) -> IO(Unit):
+  import "./bridge.c"
+
+# Resident dense projections. Each leaf computes four output channels in one
+# flat loop; only independent output tiles fork. Inputs and weights are borrowed.
+type DenseWeights is Data:
+  JWEnd{}
+  JWVal{w0: F32, w1: F32, w2: F32, w3: F32, w4: F32, w5: F32, w6: F32, next: DenseWeights}
+
+type JuliaMatrix is Data:
+  JMLeaf{weights: DenseWeights}
+  JMFork{left: JuliaMatrix, right: JuliaMatrix}
+
+def dense_weights() -> IO(JuliaMatrix):
+  import "./bridge.c"
+
+# A 4x7 tile fits seven weights plus a link in one eight-word heap allocation.
+# Each weight is reused across four tokens; no half-empty 16-word allocations.
+type TileInput is Data:
+  JTEnd{}
+  JTVal{a: F32, b: F32, c: F32, d: F32, next: TileInput}
+
+type TileResult is Data:
+  JTLeaf{v0: F32, v1: F32, v2: F32, v3: F32, v4: F32, v5: F32, v6: F32, v7: F32, v8: F32, v9: F32, v10: F32, v11: F32, v12: F32, v13: F32, v14: F32, v15: F32, v16: F32, v17: F32, v18: F32, v19: F32, v20: F32, v21: F32, v22: F32, v23: F32, v24: F32, v25: F32, v26: F32, v27: F32}
+  JTFork{left: TileResult, right: TileResult}
+
+def dot_tile(xs: TileInput, ws: DenseWeights, s0: F32, s1: F32, s2: F32, s3: F32, s4: F32, s5: F32, s6: F32, s7: F32, s8: F32, s9: F32, s10: F32, s11: F32, s12: F32, s13: F32, s14: F32, s15: F32, s16: F32, s17: F32, s18: F32, s19: F32, s20: F32, s21: F32, s22: F32, s23: F32, s24: F32, s25: F32, s26: F32, s27: F32) -> TileResult:
+  match xs ws:
+    case JTVal{+x0, +x1, +x2, +x3, xt} JWVal{+w0, +w1, +w2, +w3, +w4, +w5, +w6, wt}:
+      dot_tile(xt, wt, F32.add(s0, F32.mul(x0, w0)),
+           F32.add(s1, F32.mul(x0, w1)),
+           F32.add(s2, F32.mul(x0, w2)),
+           F32.add(s3, F32.mul(x0, w3)),
+           F32.add(s4, F32.mul(x0, w4)),
+           F32.add(s5, F32.mul(x0, w5)),
+           F32.add(s6, F32.mul(x0, w6)),
+           F32.add(s7, F32.mul(x1, w0)),
+           F32.add(s8, F32.mul(x1, w1)),
+           F32.add(s9, F32.mul(x1, w2)),
+           F32.add(s10, F32.mul(x1, w3)),
+           F32.add(s11, F32.mul(x1, w4)),
+           F32.add(s12, F32.mul(x1, w5)),
+           F32.add(s13, F32.mul(x1, w6)),
+           F32.add(s14, F32.mul(x2, w0)),
+           F32.add(s15, F32.mul(x2, w1)),
+           F32.add(s16, F32.mul(x2, w2)),
+           F32.add(s17, F32.mul(x2, w3)),
+           F32.add(s18, F32.mul(x2, w4)),
+           F32.add(s19, F32.mul(x2, w5)),
+           F32.add(s20, F32.mul(x2, w6)),
+           F32.add(s21, F32.mul(x3, w0)),
+           F32.add(s22, F32.mul(x3, w1)),
+           F32.add(s23, F32.mul(x3, w2)),
+           F32.add(s24, F32.mul(x3, w3)),
+           F32.add(s25, F32.mul(x3, w4)),
+           F32.add(s26, F32.mul(x3, w5)),
+           F32.add(s27, F32.mul(x3, w6)))
+    case _ _:
+      JTLeaf{s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27}
+
+def dense_tile(+xs: TileInput, weights: JuliaMatrix) -> TileResult:
+  match weights:
+    case JMLeaf{ws}:
+      dot_tile(xs, ws, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+    case JMFork{left, right}:
+      a b = dense_tile(xs, left) dense_tile(xs, right)
+      JTFork{a, b}
+
+def tile_input() -> IO(TileInput):
+  import "./bridge.c"
+
+def tile_output(result: TileResult) -> IO(Unit):
+  import "./bridge.c"
+
+# One fork tree spans token tiles and output tiles; one runtime dispatch per matrix.
+type InputTiles is Data:
+  JILeaf{tile: TileInput}
+  JIFork{left: InputTiles, right: InputTiles}
+
+type OutputTiles is Data:
+  JOLeaf{tile: TileResult}
+  JOFork{left: OutputTiles, right: OutputTiles}
+
+def dense_batch(tiles: InputTiles, +weights: JuliaMatrix) -> OutputTiles:
+  match tiles:
+    case JILeaf{tile}:
+      JOLeaf{dense_tile(tile, weights)}
+    case JIFork{left, right}:
+      a b = dense_batch(left, weights) dense_batch(right, weights)
+      JOFork{a, b}
+
+def input_tiles() -> IO(InputTiles):
+  import "./bridge.c"
+
+def output_tiles(result: OutputTiles) -> IO(Unit):
+  import "./bridge.c"
+
+# Packed tiles expose contiguous lanes to the native compiler. All arithmetic
+# stays in Bend. Shared inputs are read-only; output tiles are disjoint.
+# Unsafe loops terminate at the positive, validated dimensions in the bridge.
+type Input8 is Data:
+  JInput8{v0: F32, v1: F32, v2: F32, v3: F32, v4: F32, v5: F32, v6: F32, v7: F32}
+
+type Weight8 is Data:
+  JWeight8{v0: F32, v1: F32, v2: F32, v3: F32, v4: F32, v5: F32, v6: F32, v7: F32}
+
+type Output64 is Data:
+  JOutput64{v0: F32, v1: F32, v2: F32, v3: F32, v4: F32, v5: F32, v6: F32, v7: F32, v8: F32, v9: F32, v10: F32, v11: F32, v12: F32, v13: F32, v14: F32, v15: F32, v16: F32, v17: F32, v18: F32, v19: F32, v20: F32, v21: F32, v22: F32, v23: F32, v24: F32, v25: F32, v26: F32, v27: F32, v28: F32, v29: F32, v30: F32, v31: F32, v32: F32, v33: F32, v34: F32, v35: F32, v36: F32, v37: F32, v38: F32, v39: F32, v40: F32, v41: F32, v42: F32, v43: F32, v44: F32, v45: F32, v46: F32, v47: F32, v48: F32, v49: F32, v50: F32, v51: F32, v52: F32, v53: F32, v54: F32, v55: F32, v56: F32, v57: F32, v58: F32, v59: F32, v60: F32, v61: F32, v62: F32, v63: F32}
+
+type PackedBuffers is Type:
+  JBuffers{x: Array<Input8>, w: Array<Weight8>, o: Array<Output64>}
+
+@unsafe
+def packed_dot(x: Array<Input8>, w: Array<Weight8>, o: Array<Output64>, +row: U32, +col: U32, +cols: U32, +inner: U32, +end: U32, +j: U32, +s0: F32, +s1: F32, +s2: F32, +s3: F32, +s4: F32, +s5: F32, +s6: F32, +s7: F32, +s8: F32, +s9: F32, +s10: F32, +s11: F32, +s12: F32, +s13: F32, +s14: F32, +s15: F32, +s16: F32, +s17: F32, +s18: F32, +s19: F32, +s20: F32, +s21: F32, +s22: F32, +s23: F32, +s24: F32, +s25: F32, +s26: F32, +s27: F32, +s28: F32, +s29: F32, +s30: F32, +s31: F32, +s32: F32, +s33: F32, +s34: F32, +s35: F32, +s36: F32, +s37: F32, +s38: F32, +s39: F32, +s40: F32, +s41: F32, +s42: F32, +s43: F32, +s44: F32, +s45: F32, +s46: F32, +s47: F32, +s48: F32, +s49: F32, +s50: F32, +s51: F32, +s52: F32, +s53: F32, +s54: F32, +s55: F32, +s56: F32, +s57: F32, +s58: F32, +s59: F32, +s60: F32, +s61: F32, +s62: F32, +s63: F32, active: Bool) -> PackedBuffers:
+  match active:
+    case True{}:
+      packed_read_x(Array.get(Input8, x, U32.add(U32.mul(row, inner), j)), w, o, row, col, cols, inner, end, j, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s40, s41, s42, s43, s44, s45, s46, s47, s48, s49, s50, s51, s52, s53, s54, s55, s56, s57, s58, s59, s60, s61, s62, s63)
+    case False{}:
+      o = Array.set(Output64, o, U32.add(U32.mul(row, cols), col), JOutput64{s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s40, s41, s42, s43, s44, s45, s46, s47, s48, s49, s50, s51, s52, s53, s54, s55, s56, s57, s58, s59, s60, s61, s62, s63})
+      packed_step(x, w, o, U32.add(U32.add(U32.mul(row, cols), col), 1), end, cols, inner, U32.is_lt(U32.add(U32.add(U32.mul(row, cols), col), 1), end))
+
+@unsafe
+def packed_read_x(pair: Array<Input8> & Input8, w: Array<Weight8>, o: Array<Output64>, +row: U32, +col: U32, +cols: U32, +inner: U32, +end: U32, +j: U32, +s0: F32, +s1: F32, +s2: F32, +s3: F32, +s4: F32, +s5: F32, +s6: F32, +s7: F32, +s8: F32, +s9: F32, +s10: F32, +s11: F32, +s12: F32, +s13: F32, +s14: F32, +s15: F32, +s16: F32, +s17: F32, +s18: F32, +s19: F32, +s20: F32, +s21: F32, +s22: F32, +s23: F32, +s24: F32, +s25: F32, +s26: F32, +s27: F32, +s28: F32, +s29: F32, +s30: F32, +s31: F32, +s32: F32, +s33: F32, +s34: F32, +s35: F32, +s36: F32, +s37: F32, +s38: F32, +s39: F32, +s40: F32, +s41: F32, +s42: F32, +s43: F32, +s44: F32, +s45: F32, +s46: F32, +s47: F32, +s48: F32, +s49: F32, +s50: F32, +s51: F32, +s52: F32, +s53: F32, +s54: F32, +s55: F32, +s56: F32, +s57: F32, +s58: F32, +s59: F32, +s60: F32, +s61: F32, +s62: F32, +s63: F32) -> PackedBuffers:
+  (x, input) = pair
+  JInput8{+x0, +x1, +x2, +x3, +x4, +x5, +x6, +x7} = input
+  packed_read_w(Array.get(Weight8, w, U32.add(U32.mul(col, inner), j)), x, o, row, col, cols, inner, end, j, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s40, s41, s42, s43, s44, s45, s46, s47, s48, s49, s50, s51, s52, s53, s54, s55, s56, s57, s58, s59, s60, s61, s62, s63, x0, x1, x2, x3, x4, x5, x6, x7)
+
+@unsafe
+def packed_read_w(pair: Array<Weight8> & Weight8, x: Array<Input8>, o: Array<Output64>, +row: U32, +col: U32, +cols: U32, +inner: U32, +end: U32, +j: U32, +s0: F32, +s1: F32, +s2: F32, +s3: F32, +s4: F32, +s5: F32, +s6: F32, +s7: F32, +s8: F32, +s9: F32, +s10: F32, +s11: F32, +s12: F32, +s13: F32, +s14: F32, +s15: F32, +s16: F32, +s17: F32, +s18: F32, +s19: F32, +s20: F32, +s21: F32, +s22: F32, +s23: F32, +s24: F32, +s25: F32, +s26: F32, +s27: F32, +s28: F32, +s29: F32, +s30: F32, +s31: F32, +s32: F32, +s33: F32, +s34: F32, +s35: F32, +s36: F32, +s37: F32, +s38: F32, +s39: F32, +s40: F32, +s41: F32, +s42: F32, +s43: F32, +s44: F32, +s45: F32, +s46: F32, +s47: F32, +s48: F32, +s49: F32, +s50: F32, +s51: F32, +s52: F32, +s53: F32, +s54: F32, +s55: F32, +s56: F32, +s57: F32, +s58: F32, +s59: F32, +s60: F32, +s61: F32, +s62: F32, +s63: F32, +x0: F32, +x1: F32, +x2: F32, +x3: F32, +x4: F32, +x5: F32, +x6: F32, +x7: F32) -> PackedBuffers:
+  (w, weight) = pair
+  JWeight8{+w0, +w1, +w2, +w3, +w4, +w5, +w6, +w7} = weight
+  packed_dot(x, w, o, row, col, cols, inner, end, U32.add(j, 1), F32.add(s0, F32.mul(x0, w0)), F32.add(s1, F32.mul(x0, w1)), F32.add(s2, F32.mul(x0, w2)), F32.add(s3, F32.mul(x0, w3)), F32.add(s4, F32.mul(x0, w4)), F32.add(s5, F32.mul(x0, w5)), F32.add(s6, F32.mul(x0, w6)), F32.add(s7, F32.mul(x0, w7)), F32.add(s8, F32.mul(x1, w0)), F32.add(s9, F32.mul(x1, w1)), F32.add(s10, F32.mul(x1, w2)), F32.add(s11, F32.mul(x1, w3)), F32.add(s12, F32.mul(x1, w4)), F32.add(s13, F32.mul(x1, w5)), F32.add(s14, F32.mul(x1, w6)), F32.add(s15, F32.mul(x1, w7)), F32.add(s16, F32.mul(x2, w0)), F32.add(s17, F32.mul(x2, w1)), F32.add(s18, F32.mul(x2, w2)), F32.add(s19, F32.mul(x2, w3)), F32.add(s20, F32.mul(x2, w4)), F32.add(s21, F32.mul(x2, w5)), F32.add(s22, F32.mul(x2, w6)), F32.add(s23, F32.mul(x2, w7)), F32.add(s24, F32.mul(x3, w0)), F32.add(s25, F32.mul(x3, w1)), F32.add(s26, F32.mul(x3, w2)), F32.add(s27, F32.mul(x3, w3)), F32.add(s28, F32.mul(x3, w4)), F32.add(s29, F32.mul(x3, w5)), F32.add(s30, F32.mul(x3, w6)), F32.add(s31, F32.mul(x3, w7)), F32.add(s32, F32.mul(x4, w0)), F32.add(s33, F32.mul(x4, w1)), F32.add(s34, F32.mul(x4, w2)), F32.add(s35, F32.mul(x4, w3)), F32.add(s36, F32.mul(x4, w4)), F32.add(s37, F32.mul(x4, w5)), F32.add(s38, F32.mul(x4, w6)), F32.add(s39, F32.mul(x4, w7)), F32.add(s40, F32.mul(x5, w0)), F32.add(s41, F32.mul(x5, w1)), F32.add(s42, F32.mul(x5, w2)), F32.add(s43, F32.mul(x5, w3)), F32.add(s44, F32.mul(x5, w4)), F32.add(s45, F32.mul(x5, w5)), F32.add(s46, F32.mul(x5, w6)), F32.add(s47, F32.mul(x5, w7)), F32.add(s48, F32.mul(x6, w0)), F32.add(s49, F32.mul(x6, w1)), F32.add(s50, F32.mul(x6, w2)), F32.add(s51, F32.mul(x6, w3)), F32.add(s52, F32.mul(x6, w4)), F32.add(s53, F32.mul(x6, w5)), F32.add(s54, F32.mul(x6, w6)), F32.add(s55, F32.mul(x6, w7)), F32.add(s56, F32.mul(x7, w0)), F32.add(s57, F32.mul(x7, w1)), F32.add(s58, F32.mul(x7, w2)), F32.add(s59, F32.mul(x7, w3)), F32.add(s60, F32.mul(x7, w4)), F32.add(s61, F32.mul(x7, w5)), F32.add(s62, F32.mul(x7, w6)), F32.add(s63, F32.mul(x7, w7)), U32.is_lt(U32.add(j, 1), inner))
+
+def packed_join(a: PackedBuffers, b: PackedBuffers) -> PackedBuffers:
+  JBuffers{xa, wa, oa} = a
+  JBuffers{xb, wb, ob} = b
+  JBuffers{Array.join(Input8, xa, xb), Array.join(Weight8, wa, wb), Array.join(Output64, oa, ob)}
+
+@unsafe
+def packed_step(x: Array<Input8>, w: Array<Weight8>, o: Array<Output64>,
+                 +lo: U32, +hi: U32, +tiles_col: U32, +inner: U32, active: Bool) -> PackedBuffers:
+  match active:
+    case False{}:
+      JBuffers{x, w, o}
+    case True{}:
+      row = U32.div(lo, tiles_col)
+      col = U32.mod(lo, tiles_col)
+      packed_dot(x, w, o, row, col, tiles_col, inner, hi, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, True{})
+
+@unsafe
+def packed_split(x: Array<Input8> & Array<Input8>, w: Array<Weight8> & Array<Weight8>, o: Array<Output64> & Array<Output64>,
+                 +lo: U32, +hi: U32, +tiles_col: U32, +grain: U32, +inner: U32) -> PackedBuffers:
+  (xa, xb) = x
+  (wa, wb) = w
+  (oa, ob) = o
+  +mid = U32.add(lo, U32.div(U32.sub(hi, lo), 2))
+  left right = packed_gemm(xa, wa, oa, lo, mid, tiles_col, grain, inner, U32.is_le(U32.sub(mid, lo), grain)) packed_gemm(xb, wb, ob, mid, hi, tiles_col, grain, inner, U32.is_le(U32.sub(hi, mid), grain))
+  packed_join(left, right)
+
+@unsafe
+def packed_gemm(x: Array<Input8>, w: Array<Weight8>, o: Array<Output64>,
+                +lo: U32, +hi: U32, +tiles_col: U32, +grain: U32, +inner: U32, leaf: Bool) -> PackedBuffers:
+  match leaf:
+    case True{}:
+      row = U32.div(lo, tiles_col)
+      col = U32.mod(lo, tiles_col)
+      packed_dot(x, w, o, row, col, tiles_col, inner, hi, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, True{})
+    case False{}:
+      packed_split(Array.fork(Input8, x), Array.fork(Weight8, w), Array.fork(Output64, o), lo, hi, tiles_col, grain, inner)
+
+def packed_input() -> IO(Array<Input8>):
+  import "./bridge.c"
+
+def packed_weights() -> IO(Array<Weight8>):
+  import "./bridge.c"
+
+def packed_out() -> IO(Array<Output64>):
+  import "./bridge.c"
+
+def packed_output(result: PackedBuffers) -> IO(Unit):
+  import "./bridge.c"
+
+def main() -> IO(Unit):
+  do IO<Unit>:
+    +tree : Candidates <- input()
+    output(winner(tree))
+    output(softmax(tree))
+    vector : Features <- features()
+    write_features(layernorm(vector, 384.0, 0.00001))
+    rows : NormRows <- batch_features()
+    write_batch(norm_rows(rows, 384.0, 0.00001))
+    +tile : TileInput <- tile_input()
+    +w : JuliaMatrix <- dense_weights()
+    tile_output(dense_tile(tile, w))
+    tile_output(dense_tile(tile, w))
+    +tiles : InputTiles <- input_tiles()
+    +matrix : JuliaMatrix <- dense_weights()
+    output_tiles(dense_batch(tiles, matrix))
+    output_tiles(dense_batch(tiles, matrix))
+    px : Array<Input8> <- packed_input()
+    pw : Array<Weight8> <- packed_weights()
+    po : Array<Output64> <- packed_out()
+    packed_output(packed_gemm(px, pw, po, 0, 1, 1, 1, 1, True{}))

julia/router/router.py

@@ -0,0 +1,173 @@
+"""Bounded Julia inference with a Bend candidate-tree reducer."""
+from collections import OrderedDict
+from dataclasses import dataclass
+import json
+import math
+import threading
+
+from ..probabilities import display_probabilities
+from .native import BendReducer
+
+
+@dataclass(frozen=True)
+class RouteResult:
+    index: int
+    candidates: tuple[int, ...]
+    probabilities: tuple[float, ...]
+    rounds: int
+    model_rows: int
+    cache_hits: int
+    hierarchical: bool
+    # Probabilities are conditional on candidates, never global for a tournament.
+    probability_scope: str
+
+
+class Router:
+    """Wrap an Engine-compatible logits(rows) implementation.
+
+    Up to width options: one unchanged model request. Larger choice requests:
+    retain survivors per group and rerank until one final group remains.
+    This increases supported option count, not the model's trained capacity.
+    """
+    def __init__(self, engine, *, library=None, width=20, survivors=2,
+                 batch_size=16, cache_size=0, max_options=4096):
+        for name, value in [('width', width), ('survivors', survivors),
+                            ('batch_size', batch_size), ('cache_size', cache_size),
+                            ('max_options', max_options)]:
+            if type(value) is not int:
+                raise ValueError(f'{name} must be an integer')
+        if not 2 <= width <= 20 or not 1 <= survivors < width:
+            raise ValueError('Require 2 <= width <= 20 and 1 <= survivors < width')
+        if batch_size < 1 or cache_size < 0 or max_options < width:
+            raise ValueError('Invalid batch/cache/capacity limit')
+        self.engine, self.reducer = engine, BendReducer(library)
+        self.width, self.survivors = width, survivors
+        self.batch_size, self.cache_size, self.max_options = batch_size, cache_size, max_options
+        self._cache = OrderedDict()
+        self._lock = threading.RLock()
+
+    def clear_cache(self):
+        """Call after modifying model weights or inference settings."""
+        with self._lock:
+            self._cache.clear()
+
+    def _validate(self, row):
+        if not isinstance(row, dict):
+            raise ValueError('A request must be a dictionary')
+        if not isinstance(row.get('state'), (str, dict, list)) or not isinstance(row.get('question'), str):
+            raise ValueError('state must be text/JSON and question must be text')
+        options = row.get('options')
+        if not isinstance(options, list) or not 2 <= len(options) <= self.max_options:
+            raise ValueError(f'Expected 2–{self.max_options} options')
+        if not all(isinstance(x, str) and x for x in options):
+            raise ValueError('Options must be nonempty strings')
+        kind = row.get('type', 'choice')
+        if kind not in ('choice', 'score', 'noul'):
+            raise ValueError('Unknown decision type')
+        if kind == 'noul' and len(options) != 2:
+            raise ValueError('noul requires [false, true]')
+        if kind != 'choice' and len(options) > self.width:
+            raise ValueError('Hierarchical routing supports choice decisions only')
+        clean = dict(state=row['state'], question=row['question'], options=options, type=kind)
+        # Snapshot mutable state; preserve dict order used by Julia serialization.
+        return json.loads(json.dumps(clean, ensure_ascii=False, allow_nan=False))
+
+    def _score(self, jobs):
+        values = [None] * len(jobs)
+        missing = OrderedDict()
+        hits = 0
+        for i, row in enumerate(jobs):
+            key = json.dumps(row, ensure_ascii=False, separators=(',', ':'), allow_nan=False)
+            if key in self._cache:
+                values[i] = self._cache[key]
+                self._cache.move_to_end(key)
+                hits += 1
+            elif key in missing:
+                missing[key][1].append(i)
+                hits += 1
+            else:
+                missing[key] = (row, [i])
+        pending = list(missing.items())
+        for offset in range(0, len(pending), self.batch_size):
+            chunk = pending[offset:offset + self.batch_size]
+            output = list(self.engine.logits([entry[1][0] for entry in chunk]))
+            if len(output) != len(chunk):
+                raise ValueError('Engine returned the wrong number of rows')
+            for (key, (row, indices)), scores in zip(chunk, output):
+                scores = tuple(float(x) for x in scores)
+                if len(scores) != len(row['options']) or not all(math.isfinite(x) for x in scores):
+                    raise ValueError('Engine logits must be finite and match option count')
+                for i in indices:
+                    values[i] = scores
+                if self.cache_size:
+                    self._cache[key] = scores
+                    self._cache.move_to_end(key)
+                    while len(self._cache) > self.cache_size:
+                        self._cache.popitem(last=False)
+        return values, len(pending), hits
+
+    @staticmethod
+    def _confident_winner(scores, best):
+        """Keep one candidate when its local softmax dominates the group."""
+        runner_up = max(score for i, score in enumerate(scores) if i != best)
+        if runner_up - scores[best] >= math.log(0.045 / 0.95):
+            return False
+        total = sum(math.exp(score - scores[best]) for score in scores)
+        return 1 / total > 0.95 and math.exp(runner_up - scores[best]) / total < 0.045
+
+    def route(self, row):
+        return self.route_many([row])[0]
+
+    def route_many(self, rows):
+        """Batch independent groups across requests; preserve request/option order.
+
+        Calls on one Router serialize because most model engines and the LRU are
+        mutable. The C bridge also serializes access to Bend's global runtime.
+        """
+        with self._lock:
+            requests = [self._validate(row) for row in rows]
+            candidates = [list(range(len(row['options']))) for row in requests]
+            results = [None] * len(requests)
+            rounds = [0] * len(requests)
+            model_rows = hits = 0
+            while any(result is None for result in results):
+                jobs, layout = [], []
+                for i, row in enumerate(requests):
+                    if results[i] is not None:
+                        continue
+                    rounds[i] += 1
+                    current = candidates[i]
+                    final = len(current) <= self.width
+                    groups = [current[j:j + self.width] for j in range(0, len(current), self.width)]
+                    candidates[i] = []
+                    for group in groups:
+                        if len(group) == 1:
+                            candidates[i].extend(group)
+                            continue
+                        jobs.append(dict(row, options=[row['options'][k] for k in group]))
+                        layout.append((i, group, final))
+                scored, used, cached = self._score(jobs)
+                model_rows += used
+                hits += cached
+                for (i, group, final), scores in zip(layout, scored):
+                    best = self.reducer.argmax(scores)
+                    if final:
+                        maximum = max(scores)
+                        weights = [math.exp(x - maximum) for x in scores]
+                        total = sum(weights)
+                        results[i] = RouteResult(group[best], tuple(group),
+                            tuple(display_probabilities([x / total for x in weights])), rounds[i], 0, 0,
+                            len(requests[i]['options']) > self.width,
+                            'final_candidates' if len(requests[i]['options']) > self.width else 'all_options')
+                    elif self._confident_winner(scores, best):
+                        candidates[i].append(group[best])
+                    else:
+                        remaining = list(range(len(group)))
+                        chosen = []
+                        for _ in range(min(self.survivors, len(group))):
+                            position = self.reducer.argmax([scores[k] for k in remaining])
+                            chosen.append(group[remaining.pop(position)])
+                        candidates[i].extend(sorted(chosen))
+            # These counters are shared batch totals, not per-request attribution.
+            from dataclasses import replace
+            return [replace(result, model_rows=model_rows, cache_hits=hits) for result in results]

julia/router/specialize.py

@@ -0,0 +1,38 @@
+"""Bounds/alias specialization for the validated packed Bend CPU entry point.
+
+Arithmetic and iteration order remain generated from router.bend. This pass is
+valid only for bridge.c's distinct packed buffers and checked tile dimensions.
+"""
+import re
+
+
+def packed_cpu(source):
+    marker = '  WL_CASE(FID_PACKED_DOT)'
+    start = source.index(marker)
+    stop = source.index('#endif', start)
+    body = source[start:stop]
+    # Do not generalize this to Array.get: ordinary Bend arrays wrap indices.
+    # The bridge pads the full tile ranges and enforces positive bounded sizes.
+    specs = {'x': ('const ', 3), 'w': ('const ', 3), 'o': ('', 6)}
+    declarations = []
+    for name, (qualifier, shift) in specs.items():
+        var = f'_{name}_0'
+        locs = re.findall(rf'Term (_at_\d+) = blk_loc\(e.mem, {var}\);', body)
+        if len(locs) != 1:
+            raise RuntimeError(f'Unsupported packed {name} buffer lowering')
+        loc = locs[0]
+        declarations.append(f'    {qualifier}u32a *restrict julia_{name} = '
+                            f'({qualifier}u32a *)(e.mem + blk_loc(e.mem, {var}));')
+        body = body.replace(f'Term {loc} = blk_loc(e.mem, {var});', '')
+        pattern = rf'blk_at\({var}, (.+), {shift}\)'
+        body, count = re.subn(pattern, rf'((u32)(\1) << {shift})', body)
+        if count != 1:
+            raise RuntimeError(f'Unsupported packed {name} index lowering')
+        body = re.sub(rf'blk_read\(e.mem, 0, {loc}, ([^)]+)\)',
+                      rf'julia_{name}[\1]', body)
+        body = re.sub(rf'blk_write\(e.mem, 0, {loc}, ([^,]+), ([^)]+)\);',
+                      rf'julia_{name}[\1] = \2;', body)
+    if 'blk_at(' in body or 'blk_read(' in body or 'blk_write(' in body:
+        raise RuntimeError('Unrecognized packed buffer access; refusing specialization')
+    body = body.replace('    WL_OPEN', '\n'.join(declarations) + '\n    WL_OPEN', 1)
+    return source[:start] + body + source[stop:]

julia/router/tests/synthetic.py

@@ -0,0 +1,36 @@
+"""Deterministic RANDOM-weight fixtures, never trained-quality evidence."""
+from pathlib import Path
+
+
+def make_checkpoint(directory, *, tiny=False):
+    import torch
+    from tokenizers import Tokenizer
+    from tokenizers.models import WordLevel
+    from tokenizers.pre_tokenizers import Whitespace
+    from transformers import PreTrainedTokenizerFast, ModernBertConfig, AutoModel
+    from julia.model import JuliaDecisionModel
+    root = Path(directory)
+    torch.manual_seed(42)
+    width, layers, heads = (64, 2, 2) if tiny else (384, 22, 6)
+    vocabulary = {'[PAD]': 0, '[CLS]': 1, '[SEP]': 2, '[UNK]': 3, '[MASK]': 4}
+    vocabulary.update({f'word{i}': i + 5 for i in range(507)})
+    backend = Tokenizer(WordLevel(vocabulary, unk_token='[UNK]'))
+    backend.pre_tokenizer = Whitespace()
+    tokenizer = PreTrainedTokenizerFast(tokenizer_object=backend, pad_token='[PAD]',
+        cls_token='[CLS]', sep_token='[SEP]', unk_token='[UNK]', mask_token='[MASK]')
+    tokenizer.save_pretrained(root / 'tokenizer')
+    config = ModernBertConfig(vocab_size=512, hidden_size=width,
+        intermediate_size=width * 3, num_hidden_layers=layers, num_attention_heads=heads,
+        max_position_embeddings=1024, local_attention=128, global_attn_every_n_layers=3,
+        pad_token_id=0, cls_token_id=1, sep_token_id=2, reference_compile=False)
+    encoder = AutoModel.from_config(config, attn_implementation='sdpa')
+    model = JuliaDecisionModel(encoder, head_layers=2)
+    model.save_pretrained(root)
+    return root
+
+
+def sample_rows(count=16):
+    lengths = [8, 160, 24, 96]
+    return [dict(state=' '.join(f'word{(j + i) % 500}' for j in range(lengths[i % 4])),
+                 question='Choose the matching option', type='choice',
+                 options=[f'word{k + i}' for k in range(2 + i % 7)]) for i in range(count)]

julia/router/tests/test_engine.py

@@ -0,0 +1,367 @@
+import tempfile
+import unittest
+from unittest.mock import patch
+import numpy as np
+import torch
+
+from julia.data import Collator, sequence
+from julia.inference import TransformerEngine as Engine
+from julia.router.engine import FastEngine
+from julia.router.native import BendReducer
+from synthetic import make_checkpoint, sample_rows
+
+
+class NativeMathTests(unittest.TestCase):
+    def test_transformer_math(self):
+        reducer = BendReducer()
+        rng = np.random.default_rng(42)
+        for width in [1, 7, 64, 384]:
+            x = rng.normal(size=(3, width)).astype('float32')
+            gamma = rng.normal(size=width).astype('float32')
+            beta = rng.normal(size=width).astype('float32')
+            expected = torch.nn.functional.layer_norm(torch.from_numpy(x), (width,),
+                        torch.from_numpy(gamma), torch.from_numpy(beta)).numpy()
+            np.testing.assert_allclose(reducer.layernorm(x, gamma, beta), expected, atol=2e-6, rtol=2e-5)
+            for row in x:
+                index, probs = reducer.softmax(row)
+                self.assertEqual(index, int(row.argmax()))
+                np.testing.assert_allclose(probs, torch.from_numpy(row).softmax(-1).numpy(), atol=2e-7)
+        _, probabilities = reducer.softmax(np.array([10000, 10001, -10000], np.float32))
+        self.assertAlmostEqual(float(probabilities.sum()), 1.0)
+
+    def test_resident_dense_tiles_reuse_and_partial_edges(self):
+        from julia.router.native import BendMatrix
+        rng = np.random.default_rng(52)
+        for inputs, outputs, rows in [(1, 1, 1), (7, 5, 9), (64, 17, 7), (33, 65, 19), (384, 1152, 5)]:
+            weights = rng.normal(size=(outputs, inputs)).astype('float32')
+            values = rng.normal(size=(rows, inputs)).astype('float32')
+            matrix = BendMatrix(weights)
+            reference = values @ weights.T
+            first = matrix(values)
+            np.testing.assert_allclose(first, reference, atol=1e-4, rtol=1e-4)
+            for _ in range(8):
+                np.testing.assert_array_equal(matrix(values), first)
+            with self.assertRaises(ValueError): matrix(np.ones((2, inputs + 1), np.float32))
+            with self.assertRaises(ValueError): matrix(np.full((1, inputs), np.nan, np.float32))
+            matrix.close()
+            matrix.close()
+            with self.assertRaises(RuntimeError): matrix(values)
+        with self.assertRaises(ValueError): BendMatrix([[float('nan')]])
+
+    def test_tensor_chunks_and_opt_in_native_profile(self):
+        from julia.router.native import BendMatrix
+        reducer = BendReducer()
+        weights = np.random.default_rng(8).normal(size=(257, 3)).astype('float32')
+        matrix = BendMatrix(weights, reducer)
+        # Noncontiguous input and > 1M output cells require two native chunks.
+        values = torch.arange(4090 * 6, dtype=torch.float32).reshape(4090, 6)[:, ::2] / 1000
+        try:
+            reducer.profile(enabled=True, reset=True)
+            actual = matrix.tensor(values)
+            measured = reducer.profile(enabled=False)
+            self.assertEqual(measured['calls'], 2)
+            self.assertTrue(all(measured[k] >= 0 for k in ('pack_ms', 'execute_ms', 'unpack_ms')))
+            torch.testing.assert_close(actual, values @ torch.from_numpy(weights).T, rtol=1e-5, atol=1e-5)
+            matrix.tensor(values[:1])
+            self.assertEqual(reducer.profile(), measured)
+            with self.assertRaises(ValueError):
+                matrix.tensor(torch.full((1, 3), float('nan')))
+        finally:
+            reducer.profile(enabled=False, reset=True)
+            matrix.close()
+
+    def test_layernorm_parallel_callers_and_large_rows(self):
+        import concurrent.futures
+        reducer = BendReducer()
+        rng = np.random.default_rng(19)
+        values = [rng.normal(size=(rows, 384)).astype('float32') for rows in (1, 7, 32, 128)]
+        references = [torch.nn.functional.layer_norm(torch.from_numpy(x), (384,)).numpy() for x in values]
+        with concurrent.futures.ThreadPoolExecutor(4) as pool:
+            actual = list(pool.map(reducer.layernorm, values * 8))
+        for i, result in enumerate(actual):
+            np.testing.assert_allclose(result, references[i % len(values)], atol=3e-6, rtol=2e-5)
+
+    def test_packed_matrix_concurrent_owners(self):
+        from concurrent.futures import ThreadPoolExecutor
+        from julia.router.native import BendMatrix
+        rng = np.random.default_rng(2026)
+        weights = [rng.normal(size=(n, 33)).astype('float32') for n in (5, 17, 128)]
+        matrices = [BendMatrix(w) for w in weights]
+        values = rng.normal(size=(19, 33)).astype('float32')
+        try:
+            with ThreadPoolExecutor(6) as pool:
+                results = list(pool.map(lambda i: matrices[i % 3](values), range(96)))
+            for i, actual in enumerate(results):
+                np.testing.assert_allclose(actual, values @ weights[i % 3].T, atol=2e-5, rtol=2e-5)
+        finally:
+            for matrix in matrices:
+                matrix.close()
+
+    def test_rejected_native_math(self):
+        reducer = BendReducer()
+        for x in [[], [float('nan')], [float('inf')]]:
+            with self.assertRaises(ValueError):
+                reducer.softmax(x)
+        for kwargs in [dict(epsilon=0), dict(gamma=[1]), dict(beta=[0]), dict(epsilon=float('nan'))]:
+            with self.assertRaises(ValueError):
+                reducer.layernorm([[1, 2, 3]], **kwargs)
+
+
+class ProbabilityDisplayTests(unittest.TestCase):
+    def test_rounds_decisive_answer_to_certain(self):
+        from julia.probabilities import display_probabilities
+
+        self.assertEqual(display_probabilities([0.955, 0.044, 0.001]), [1.0, 0.0, 0.0])
+        self.assertNotEqual(display_probabilities([0.951, 0.049]), [1.0, 0.0])
+
+    def test_redistributes_sub_one_percent_values(self):
+        from julia.probabilities import display_probabilities
+
+        result = display_probabilities([0.6, 0.395, 0.005])
+        self.assertEqual(result[2], 0.0)
+        self.assertAlmostEqual(sum(result), 1.0)
+        self.assertAlmostEqual(result[0] / result[1], 0.6 / 0.395)
+
+
+class InputValidationTests(unittest.TestCase):
+    def test_public_loader_rejects_invalid_backend(self):
+        from julia import load_model
+        from julia.inference import Engine
+
+        self.assertIs(load_model, Engine)
+        with self.assertRaisesRegex(ValueError, 'backend'):
+            load_model('unused', backend='unknown')
+
+    def test_rejects_malformed_requests(self):
+        from julia.data import validate_row
+
+        valid = {'state': 'context', 'question': 'Choose', 'options': ['A', 'B']}
+        for row in (None, [], {**valid, 'teacher_logits': 'bad'},
+                    {**valid, 'teacher_logits': [0.0, float('nan')]},
+                    {**valid, 'teacher_logits': [True, 0.0]}):
+            with self.subTest(row=row), self.assertRaises(ValueError):
+                validate_row(row, 1)
+
+
+class InferenceTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        torch.set_num_threads(2)
+        cls.temp = tempfile.TemporaryDirectory()
+        cls.path = make_checkpoint(cls.temp.name, tiny=True)
+        cls.baseline = Engine(cls.path, device='cpu')
+        with patch('julia.router.native.BendReducer', side_effect=AssertionError('Default CPU must not load Bend')):
+            cls.fast = FastEngine(cls.path, device='cpu', batch_size=2)
+        cls.rows = sample_rows(5)
+        cls.rows[0]['state'] = {'text': 'Olá 世界 [MASK]', 'items': [1, 2]}
+
+    @classmethod
+    def tearDownClass(cls):
+        del cls.baseline, cls.fast
+        cls.temp.cleanup()
+
+    def test_modernbert_decision_encoder_deduplicates_rope(self):
+        from transformers import ModernBertConfig, ModernBertModel
+        from julia.model import JuliaDecisionModel
+        from julia.router.encoder import specialize_decision_encoder
+        config = ModernBertConfig(vocab_size=64, pad_token_id=0, bos_token_id=1, eos_token_id=2, hidden_size=32, intermediate_size=64,
+            num_hidden_layers=4, num_attention_heads=4, max_position_embeddings=128,
+            local_attention=16, global_attn_every_n_layers=3, attention_dropout=0.,
+            embedding_dropout=0., mlp_dropout=0.)
+        config._attn_implementation = 'sdpa'
+        model = JuliaDecisionModel(ModernBertModel(config), head_layers=0).eval()
+        ids = torch.arange(24).reshape(2,12) % 64
+        mask = torch.ones_like(ids); mask[1,8:] = 0
+        calls=[]
+        hook=model.encoder.rotary_emb.register_forward_hook(lambda *args: calls.append(1))
+        with torch.inference_mode():
+            expected=model.encoder(input_ids=ids,attention_mask=mask).last_hidden_state
+            self.assertEqual(len(calls), 4)
+            calls.clear()
+            self.assertTrue(specialize_decision_encoder(model))
+            actual=model.encoder(input_ids=ids,attention_mask=mask).last_hidden_state
+            self.assertEqual(len(calls), 2)
+            torch.testing.assert_close(actual, expected, rtol=0, atol=0)
+        hook.remove()
+
+    def test_default_backend_and_padding_budget(self):
+        self.assertEqual(self.fast.transformer_backend, 'torch')
+        self.assertIsNone(self.fast.bend)
+        self.assertFalse(hasattr(self.fast, 'bend_projection_count'))
+        rows = [dict(self.rows[0], state='short'), dict(self.rows[1], state='long context ' * 100),
+                dict(self.rows[2], state='another short state')]
+        encoded = self.fast._encode(rows)
+        groups = list(self.fast._batch_indices(encoded))
+        self.assertEqual(sorted(i for group in groups for i in group), list(range(3)))
+        for group in groups:
+            lengths = [len(encoded[i]['ids']) for i in group]
+            self.assertLessEqual(max(lengths) * len(group), self.fast.padding_ratio * sum(lengths))
+        actual = self.fast.predict(rows)
+        expected = self.baseline.predict(rows)
+        for a, b in zip(actual, expected):
+            np.testing.assert_allclose(a['probabilities'], b['probabilities'], atol=2e-6)
+
+    def test_lfs_pointer_error(self):
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as directory:
+            (Path(directory) / 'model.safetensors').write_text('version https://git-lfs.github.com/spec/v1\n')
+            with self.assertRaisesRegex(ValueError, 'Git LFS pointers'):
+                FastEngine(directory)
+
+    def test_serialization_and_pack(self):
+        encoded = self.fast._encode(self.rows)
+        self.assertEqual(encoded, [sequence(self.baseline.tokenizer, row) for row in self.rows])
+        packed = self.fast._pack(encoded)
+        reference = Collator(self.baseline.tokenizer, 1024, 256)(self.rows)
+        for name in packed:
+            self.assertTrue(torch.equal(packed[name], reference[name]), name)
+        self.assertEqual(self.fast.predict([]), [])
+        self.assertEqual(self.fast.logits([]), [])
+
+    def test_inference_collation_omits_training_tensors(self):
+        rows = [dict(row, target=0, teacher_logits=[0.] * len(row['options']))
+                for row in self.rows]
+        collate = self.baseline.collate
+        training = collate(rows)
+        inference = collate(rows, include_targets=False)
+        self.assertIn('labels', training)
+        self.assertIn('teacher_logits', training)
+        self.assertEqual(set(training) - set(inference), {'labels', 'teacher_logits'})
+        for name, value in inference.items():
+            self.assertTrue(torch.equal(value, training[name]), name)
+        self.assertEqual(self.baseline.predict(rows), self.baseline.predict(self.rows))
+
+    def test_nonfinite_real_scores_are_rejected(self):
+        original = self.fast.forward
+        try:
+            for invalid in (float('nan'), float('inf'), -float('inf')):
+                def forward(**batch):
+                    result = torch.zeros_like(batch['marker_pos'], dtype=torch.float32)
+                    result[0, 0] = invalid
+                    return result
+                self.fast.forward = forward
+                with self.assertRaises(FloatingPointError):
+                    self.fast.predict(self.rows)
+        finally:
+            self.fast.forward = original
+
+    def test_memory_mapped_checkpoint_dtype_and_logits(self):
+        from julia.model import JuliaDecisionModel
+        for dtype in (torch.float32, torch.bfloat16):
+            with tempfile.TemporaryDirectory() as directory:
+                model = JuliaDecisionModel.from_pretrained(self.path).to(dtype=dtype)
+                model.save_pretrained(directory)
+                loaded = JuliaDecisionModel.from_pretrained(directory, memory_map=True)
+                copied = JuliaDecisionModel.from_pretrained(directory, memory_map=False)
+                for name, value in loaded.state_dict().items():
+                    self.assertEqual(value.dtype, copied.state_dict()[name].dtype)
+                    torch.testing.assert_close(value, copied.state_dict()[name], rtol=0, atol=0)
+                if dtype == torch.float32:
+                    batch = self.baseline.collate(self.rows)
+                    with torch.inference_mode():
+                        torch.testing.assert_close(loaded.eval()(**batch), copied.eval()(**batch), rtol=0, atol=0)
+
+    def test_selected_head_scores_actions_and_training(self):
+        model = self.baseline.model
+        batch = self.baseline.collate(self.rows)
+        batch['qtype'] = torch.arange(len(self.rows)) % 3
+        with torch.inference_mode():
+            model.marker_only_head = False
+            expected = model(**batch, return_actions=True)
+            model.marker_only_head = True
+            actual = model(**batch, return_actions=True)
+        for a, b in zip(expected, actual):
+            torch.testing.assert_close(a, b, atol=2e-6, rtol=2e-5)
+        # Training must retain the original full-sequence/dropout path.
+        model.train()
+        torch.manual_seed(123)
+        model.marker_only_head = False
+        expected = model(**batch)
+        torch.manual_seed(123)
+        model.marker_only_head = True
+        actual = model(**batch)
+        torch.testing.assert_close(expected, actual, atol=0, rtol=0)
+        actual.sum().backward()
+        self.assertTrue(torch.isfinite(model.scorer[-1].weight.grad).all())
+        model.zero_grad(set_to_none=True)
+        model.eval()
+        model.marker_only_head = False
+
+    def test_strict_encoding_reuses_audit_and_rejects_loss(self):
+        engine = FastEngine(self.path, device='cpu', strict_encoding=True)
+        row = dict(self.rows[1], state='word1 word2')
+        audit = engine.encoding_info([row])[0]
+        self.assertFalse(audit['stateTruncated'])
+        encoded = next(iter(engine._encoded.values()))
+        engine.predict([row])
+        self.assertIs(next(iter(engine._encoded.values())), encoded)
+        for bad in [dict(row, state='[MASK]'),
+                    dict(row, state={'value': '[MASK]'}),
+                    dict(row, options=['word1 ' * 49, 'word2']),
+                    dict(row, state='word1 ' * 2000)]:
+            with self.assertRaises(ValueError):
+                engine.predict([bad])
+        # Changes in the encoding budget must not reuse stale cached IDs.
+        engine.max_length = 32
+        with self.assertRaises(ValueError):
+            engine.predict([dict(row, state='word1 ' * 100)])
+        engine.head_length = 16
+        with self.assertRaises(ValueError):
+            engine.predict([dict(row, question='word1 ' * 40)])
+
+    def test_inference_parity_and_order(self):
+        reference = self.baseline.predict(self.rows)
+        actual = self.fast.predict(self.rows)
+        self.assertEqual([x['index'] for x in reference], [x['index'] for x in actual])
+        for a, b in zip(reference, actual):
+            np.testing.assert_allclose(a['probabilities'], b['probabilities'], atol=2e-6)
+        self.assertEqual(self.fast.predict(self.rows, probabilities=False),
+                         [dict(index=x['index']) for x in actual])
+        self.assertTrue(self.fast._encoded)
+        self.fast.clear_cache()
+        self.assertFalse(self.fast._encoded)
+        self.assertFalse(self.fast._tokens.cache)
+
+    def test_bend_transformer_parity(self):
+        bend = FastEngine(self.path, device='cpu', batch_size=2,
+                          transformer_backend='bend', bend_postprocess=True)
+        reference = self.baseline.predict(self.rows)
+        actual = bend.predict(self.rows)
+        # Different reduction orders can break an exact FP32 tie. Require the
+        # selected reference probability to be within tolerance of its maximum.
+        for a, b in zip(reference, actual):
+            p = a['probabilities']
+            self.assertLessEqual(max(p) - p[b['index']], 2e-6)
+        for a, b in zip(reference, actual):
+            np.testing.assert_allclose(a['probabilities'], b['probabilities'], atol=2e-6)
+        self.assertEqual(bend.predict(self.rows, probabilities=False),
+                         [dict(index=x['index']) for x in actual])
+
+    def test_bend_dense_encoder_parity(self):
+        dense = FastEngine(self.path, device='cpu', batch_size=2,
+                           transformer_backend='bend-dense')
+        self.assertGreater(dense.bend_projection_count, 0)
+        expected = self.baseline.predict(self.rows)
+        actual = dense.predict(self.rows)
+        for a, b in zip(expected, actual):
+            np.testing.assert_allclose(a['probabilities'], b['probabilities'], atol=2e-6)
+            self.assertLessEqual(max(a['probabilities']) - a['probabilities'][b['index']], 2e-6)
+        from julia.router.transformer import BendLinear
+        layer = next(m for m in dense.model.modules() if isinstance(m, BendLinear))
+        with torch.no_grad():
+            layer.weight.add_(1)
+        with self.assertRaisesRegex(RuntimeError, 'resident weights changed'):
+            dense.predict(self.rows)
+
+    @unittest.skipUnless(torch.cuda.is_available(), 'CUDA hardware unavailable')
+    def test_cuda(self):
+        baseline = Engine(self.path, device='cuda')
+        fast = FastEngine(self.path, device='cuda', batch_size=2)
+        reference, actual = baseline.predict(self.rows), fast.predict(self.rows)
+        self.assertEqual([x['index'] for x in reference], [x['index'] for x in actual])
+        for a, b in zip(reference, actual):
+            np.testing.assert_allclose(a['probabilities'], b['probabilities'], atol=5e-3)
+
+
+if __name__ == '__main__':
+    unittest.main()

julia/router/tests/test_router.py

@@ -0,0 +1,108 @@
+import concurrent.futures
+import math
+import os
+import random
+import unittest
+
+from julia.router import BendReducer, Router
+
+LIB = os.environ.get('JULIA_ROUTER_LIBRARY', str(__import__('pathlib').Path(__file__).resolve().parents[1] / 'build/libjulia_router.so'))
+
+
+class Engine:
+    def __init__(self):
+        self.batches = []
+
+    def logits(self, rows):
+        self.batches.append(rows)
+        return [[float(x) for x in row['options']] for row in rows]
+
+
+def request(n):
+    return dict(state='Olá, 世界', question='Choose the largest number',
+                options=[str(i) for i in range(n)])
+
+
+class Tests(unittest.TestCase):
+    def test_native_reference_and_reuse(self):
+        reducer = BendReducer(LIB)
+        rng = random.Random(10)
+        for n in [1, 2, 3, 20, 77, 1000]:
+            for _ in range(20):
+                values = [rng.randrange(-100, 100) for _ in range(n)]
+                self.assertEqual(reducer.argmax(values), max(range(n), key=values.__getitem__))
+        self.assertEqual(reducer.argmax([3, 3, -1]), 0)
+
+    def test_native_threads(self):
+        reducer = BendReducer(LIB)
+        with concurrent.futures.ThreadPoolExecutor(8) as pool:
+            self.assertEqual(list(pool.map(lambda _: reducer.argmax([1, 9, 2]), range(1000))), [1]*1000)
+
+    def test_invalid(self):
+        for scores in [[], [math.nan], [math.inf], [1e100]]:
+            with self.assertRaises(ValueError):
+                BendReducer(LIB).argmax(scores)
+        r = Router(Engine(), library=LIB)
+        for row in [request(1), dict(request(30), type='score'), dict(request(3), type='noul')]:
+            with self.assertRaises(ValueError):
+                r.route(row)
+
+    def test_direct_and_hierarchical(self):
+        engine = Engine()
+        router = Router(engine, library=LIB, batch_size=3)
+        results = router.route_many([request(n) for n in [2, 20, 21, 77, 4096]])
+        self.assertEqual([r.index for r in results], [1, 19, 20, 76, 4095])
+        for result in results:
+            self.assertAlmostEqual(sum(result.probabilities), 1)
+            self.assertIn(result.index, result.candidates)
+        self.assertEqual(results[0].probability_scope, 'all_options')
+        self.assertEqual(results[-1].probability_scope, 'final_candidates')
+        self.assertTrue(all(len(batch) <= 3 for batch in engine.batches))
+        self.assertTrue(all(2 <= len(row['options']) <= 20 for batch in engine.batches for row in batch))
+        self.assertEqual(router.route_many([]), [])
+
+    def test_confident_group_shortcut(self):
+        self.assertTrue(Router._confident_winner([0.0, 4.0, -3.0], 1))
+        self.assertFalse(Router._confident_winner([0.0, 3.0, -3.0], 1))
+
+        class DecisiveEngine(Engine):
+            def logits(self, rows):
+                self.batches.append(rows)
+                return [[10.0 * float(x) for x in row['options']] for row in rows]
+
+        engine = DecisiveEngine()
+        router = Router(engine, library=LIB)
+        result = router.route(request(2001))
+        self.assertEqual(result.index, 2000)
+        self.assertEqual(result.rounds, 3)
+        self.assertEqual(result.model_rows, 106)
+
+        baseline = Router(DecisiveEngine(), library=LIB)
+        baseline._confident_winner = lambda scores, best: False
+        original = baseline.route(request(2001))
+        self.assertEqual(original.index, result.index)
+        self.assertLess(result.rounds, original.rounds)
+        self.assertLess(result.model_rows, original.model_rows)
+
+    def test_cache_and_dedup(self):
+        engine = Engine()
+        router = Router(engine, library=LIB, cache_size=1)
+        results = router.route_many([request(5), request(5)])
+        self.assertEqual(results[0].model_rows, 1)
+        self.assertEqual(results[0].cache_hits, 1)
+        self.assertEqual(router.route(request(5)).model_rows, 0)
+        router.clear_cache()
+        self.assertEqual(router.route(request(5)).model_rows, 1)
+        router.route(request(6))
+        self.assertEqual(router.route(request(5)).model_rows, 1)
+
+    def test_engine_failure(self):
+        class Bad:
+            def logits(self, rows):
+                return [[0]] * len(rows)
+        with self.assertRaises(ValueError):
+            Router(Bad(), library=LIB).route(request(4))
+
+
+if __name__ == '__main__':
+    unittest.main()

julia/router/transformer.py

@@ -0,0 +1,97 @@
+"""Resident Bend encoder projections and optional decision-head normalization.
+
+The packed FP32 kernels own matrix arithmetic and coarse parallel scheduling.
+PyTorch supplies embedding lookup, SDPA, activations and the selected-output head.
+"""
+import numpy as np
+import torch
+from torch import nn
+
+
+class BendLayerNorm(nn.Module):
+    def __init__(self, original, reducer):
+        super().__init__()
+        self.weight, self.bias = original.weight, original.bias
+        self.eps = original.eps
+        self.normalized_shape = original.normalized_shape
+        self.reducer = reducer
+
+    def forward(self, x):
+        if x.device.type != 'cpu' or x.dtype != torch.float32:
+            raise ValueError('Bend LayerNorm requires CPU float32; use torch backend for CUDA')
+        if torch.is_grad_enabled():
+            raise RuntimeError('Bend transformer kernels require torch.inference_mode()')
+        width = x.shape[-1]
+        values = x.detach().contiguous().numpy().reshape(-1, width)
+        gamma = self.weight.detach().numpy() if self.weight is not None else None
+        beta = self.bias.detach().numpy() if self.bias is not None else None
+        parts = [self.reducer.layernorm(values[start:start + 1048576 // width], gamma, beta, self.eps)
+                 for start in range(0, len(values), 1048576 // width)]
+        result = parts[0] if len(parts) == 1 else np.concatenate(parts)
+        return torch.from_numpy(result.reshape(x.shape))
+
+
+class BendHeadLayer(nn.Module):
+    """Explicit pre-norm block; prevents fused MHA from bypassing Bend norms."""
+    def __init__(self, layer, reducer):
+        super().__init__()
+        if not layer.norm_first:
+            raise ValueError('Julia expects pre-norm transformer layers')
+        self.layer = layer
+        self.norm1 = BendLayerNorm(layer.norm1, reducer)
+        self.norm2 = BendLayerNorm(layer.norm2, reducer)
+
+    def forward(self, x, src_key_padding_mask=None):
+        normalized = self.norm1(x)
+        attention = self.layer.self_attn(normalized, normalized, normalized,
+                    key_padding_mask=src_key_padding_mask, need_weights=False)[0]
+        x = x + self.layer.dropout1(attention)
+        hidden = self.layer.linear2(self.layer.dropout(
+            self.layer.activation(self.layer.linear1(self.norm2(x)))))
+        return x + self.layer.dropout2(hidden)
+
+
+def install_bend_head(model, reducer):
+    if model.head is not None:
+        model.head.layers = nn.ModuleList([BendHeadLayer(layer, reducer) for layer in model.head.layers])
+    model.scorer[0] = BendLayerNorm(model.scorer[0], reducer)
+    model.eval()
+
+
+class BendLinear(nn.Module):
+    """Inference-only CPU projection using resident weights and Bend arithmetic."""
+    def __init__(self, original, reducer):
+        super().__init__()
+        from .native import BendMatrix
+        self.weight, self.bias = original.weight, original.bias
+        self.in_features, self.out_features = original.in_features, original.out_features
+        self.matrix = BendMatrix(original.weight.detach().numpy(), reducer)
+        self._weight_version = self.weight._version
+        self._weight_pointer = self.weight.data_ptr()
+
+    def _check_weight(self):
+        if self.weight._version != self._weight_version or self.weight.data_ptr() != self._weight_pointer:
+            raise RuntimeError('Bend resident weights changed; recreate the inference backend')
+
+    def forward(self, x):
+        if x.device.type != 'cpu' or x.dtype != torch.float32 or torch.is_grad_enabled():
+            raise ValueError('Bend dense projections require CPU FP32 inference_mode')
+        self._check_weight()
+        result = self.matrix.tensor(x, validate=False)
+        return result if self.bias is None else result + self.bias
+
+
+def install_bend_encoder(model, reducer):
+    """Route all encoder linear projections through Bend; attention remains SDPA."""
+    count = 0
+    def install(module):
+        nonlocal count
+        for name, child in list(module.named_children()):
+            if type(child) is nn.Linear:
+                setattr(module, name, BendLinear(child, reducer))
+                count += 1
+            else:
+                install(child)
+    install(model.encoder)
+    model.eval()
+    return count

julia_config.json

@@ -0,0 +1,8 @@
+{
+  "format_version": 1,
+  "architecture": "JuliaDecisionModel",
+  "weight_dtype": "float32",
+  "head_layers": 2,
+  "n_act": 2,
+  "dropout": 0.1
+}

metrics/accuracy-20260924.json

@@ -0,0 +1,434 @@
+{
+  "date": "2026-09-24",
+  "weights_sha256": "df853bf7fe424420011f3d0c47a05d7341aa9eefa7fb9f203ea4aada4ad95b72",
+  "benchmarks": {
+    "typed-decisions": {
+      "count": 2000,
+      "correct": 1463,
+      "answered": 2000,
+      "accuracy": 0.7315,
+      "coverage": 1.0,
+      "jev_reference": 0.727,
+      "delta": 0.0045000000000000595,
+      "statuses": {
+        "ok": 2000
+      }
+    },
+    "agnews": {
+      "count": 100,
+      "correct": 94,
+      "answered": 100,
+      "accuracy": 0.94,
+      "coverage": 1.0,
+      "jev_reference": 0.91,
+      "delta": 0.029999999999999916,
+      "statuses": {
+        "ok": 100
+      }
+    },
+    "emotiondair": {
+      "count": 100,
+      "correct": 86,
+      "answered": 100,
+      "accuracy": 0.86,
+      "coverage": 1.0,
+      "jev_reference": 0.48,
+      "delta": 0.38,
+      "statuses": {
+        "ok": 100
+      }
+    },
+    "banking77": {
+      "count": 100,
+      "correct": 64,
+      "answered": 99,
+      "accuracy": 0.64,
+      "coverage": 0.99,
+      "jev_reference": 0.87,
+      "delta": -0.22999999999999998,
+      "statuses": {
+        "ok": 99,
+        "abstained": 1
+      }
+    }
+  },
+  "typed": {
+    "choice": {
+      "count": 600,
+      "correct": 428,
+      "accuracy": 0.7133333333333334
+    },
+    "noul": {
+      "count": 600,
+      "correct": 484,
+      "accuracy": 0.8066666666666666
+    },
+    "score": {
+      "count": 800,
+      "correct": 551,
+      "accuracy": 0.68875
+    }
+  },
+  "massive": {
+    "per_language": {
+      "mn-MN": {
+        "count": 2974,
+        "correct": 1618,
+        "unsupported": 0,
+        "accuracy": 0.5440484196368527
+      },
+      "af-ZA": {
+        "count": 2974,
+        "correct": 2253,
+        "unsupported": 0,
+        "accuracy": 0.7575655682582381
+      },
+      "el-GR": {
+        "count": 2974,
+        "correct": 2244,
+        "unsupported": 0,
+        "accuracy": 0.7545393409549428
+      },
+      "ta-IN": {
+        "count": 2974,
+        "correct": 1840,
+        "unsupported": 0,
+        "accuracy": 0.6186953597848016
+      },
+      "ar-SA": {
+        "count": 2974,
+        "correct": 2118,
+        "unsupported": 0,
+        "accuracy": 0.7121721587088097
+      },
+      "ca-ES": {
+        "count": 2974,
+        "correct": 2259,
+        "unsupported": 0,
+        "accuracy": 0.7595830531271015
+      },
+      "ur-PK": {
+        "count": 2974,
+        "correct": 2057,
+        "unsupported": 0,
+        "accuracy": 0.691661062542031
+      },
+      "pl-PL": {
+        "count": 2974,
+        "correct": 2377,
+        "unsupported": 0,
+        "accuracy": 0.7992602555480834
+      },
+      "ko-KR": {
+        "count": 2974,
+        "correct": 2296,
+        "unsupported": 0,
+        "accuracy": 0.7720242098184263
+      },
+      "az-AZ": {
+        "count": 2974,
+        "correct": 2166,
+        "unsupported": 0,
+        "accuracy": 0.7283120376597175
+      },
+      "da-DK": {
+        "count": 2974,
+        "correct": 2416,
+        "unsupported": 0,
+        "accuracy": 0.812373907195696
+      },
+      "kn-IN": {
+        "count": 2974,
+        "correct": 1654,
+        "unsupported": 0,
+        "accuracy": 0.5561533288500337
+      },
+      "tl-PH": {
+        "count": 2974,
+        "correct": 2146,
+        "unsupported": 0,
+        "accuracy": 0.7215870880968392
+      },
+      "is-IS": {
+        "count": 2974,
+        "correct": 1961,
+        "unsupported": 0,
+        "accuracy": 0.6593813046402152
+      },
+      "lv-LV": {
+        "count": 2974,
+        "correct": 1960,
+        "unsupported": 0,
+        "accuracy": 0.6590450571620713
+      },
+      "it-IT": {
+        "count": 2974,
+        "correct": 2432,
+        "unsupported": 0,
+        "accuracy": 0.8177538668459986
+      },
+      "es-ES": {
+        "count": 2974,
+        "correct": 2531,
+        "unsupported": 0,
+        "accuracy": 0.8510423671822461
+      },
+      "fr-FR": {
+        "count": 2974,
+        "correct": 2515,
+        "unsupported": 0,
+        "accuracy": 0.8456624075319435
+      },
+      "ml-IN": {
+        "count": 2974,
+        "correct": 1653,
+        "unsupported": 0,
+        "accuracy": 0.5558170813718897
+      },
+      "km-KH": {
+        "count": 2974,
+        "correct": 1421,
+        "unsupported": 0,
+        "accuracy": 0.47780766644250167
+      },
+      "fa-IR": {
+        "count": 2974,
+        "correct": 2382,
+        "unsupported": 0,
+        "accuracy": 0.800941492938803
+      },
+      "sw-KE": {
+        "count": 2974,
+        "correct": 1655,
+        "unsupported": 0,
+        "accuracy": 0.5564895763281775
+      },
+      "en-US": {
+        "count": 2974,
+        "correct": 2580,
+        "unsupported": 0,
+        "accuracy": 0.867518493611298
+      },
+      "tr-TR": {
+        "count": 2974,
+        "correct": 2388,
+        "unsupported": 0,
+        "accuracy": 0.8029589778076665
+      },
+      "bn-BD": {
+        "count": 2974,
+        "correct": 1972,
+        "unsupported": 0,
+        "accuracy": 0.6630800268997983
+      },
+      "he-IL": {
+        "count": 2974,
+        "correct": 2046,
+        "unsupported": 0,
+        "accuracy": 0.6879623402824478
+      },
+      "te-IN": {
+        "count": 2974,
+        "correct": 1900,
+        "unsupported": 0,
+        "accuracy": 0.6388702084734365
+      },
+      "pt-PT": {
+        "count": 2974,
+        "correct": 2565,
+        "unsupported": 0,
+        "accuracy": 0.8624747814391392
+      },
+      "ka-GE": {
+        "count": 2974,
+        "correct": 1501,
+        "unsupported": 0,
+        "accuracy": 0.5047074646940148
+      },
+      "ja-JP": {
+        "count": 2974,
+        "correct": 2446,
+        "unsupported": 0,
+        "accuracy": 0.8224613315400134
+      },
+      "id-ID": {
+        "count": 2974,
+        "correct": 2415,
+        "unsupported": 0,
+        "accuracy": 0.8120376597175522
+      },
+      "ru-RU": {
+        "count": 2974,
+        "correct": 2450,
+        "unsupported": 0,
+        "accuracy": 0.8238063214525891
+      },
+      "hy-AM": {
+        "count": 2974,
+        "correct": 1818,
+        "unsupported": 0,
+        "accuracy": 0.6112979152656355
+      },
+      "nb-NO": {
+        "count": 2974,
+        "correct": 2391,
+        "unsupported": 0,
+        "accuracy": 0.8039677202420982
+      },
+      "ms-MY": {
+        "count": 2974,
+        "correct": 2306,
+        "unsupported": 0,
+        "accuracy": 0.7753866845998655
+      },
+      "sq-AL": {
+        "count": 2974,
+        "correct": 2035,
+        "unsupported": 0,
+        "accuracy": 0.6842636180228648
+      },
+      "sv-SE": {
+        "count": 2974,
+        "correct": 2362,
+        "unsupported": 0,
+        "accuracy": 0.7942165433759247
+      },
+      "fi-FI": {
+        "count": 2974,
+        "correct": 2096,
+        "unsupported": 0,
+        "accuracy": 0.7047747141896435
+      },
+      "th-TH": {
+        "count": 2974,
+        "correct": 2299,
+        "unsupported": 0,
+        "accuracy": 0.7730329522528581
+      },
+      "de-DE": {
+        "count": 2974,
+        "correct": 2426,
+        "unsupported": 0,
+        "accuracy": 0.8157363819771352
+      },
+      "vi-VN": {
+        "count": 2974,
+        "correct": 2224,
+        "unsupported": 0,
+        "accuracy": 0.7478143913920645
+      },
+      "my-MM": {
+        "count": 2974,
+        "correct": 1513,
+        "unsupported": 0,
+        "accuracy": 0.5087424344317417
+      },
+      "jv-ID": {
+        "count": 2974,
+        "correct": 1802,
+        "unsupported": 0,
+        "accuracy": 0.6059179556153329
+      },
+      "sl-SL": {
+        "count": 2974,
+        "correct": 2147,
+        "unsupported": 0,
+        "accuracy": 0.7219233355749832
+      },
+      "hi-IN": {
+        "count": 2974,
+        "correct": 2237,
+        "unsupported": 0,
+        "accuracy": 0.7521856086079355
+      },
+      "nl-NL": {
+        "count": 2974,
+        "correct": 2449,
+        "unsupported": 0,
+        "accuracy": 0.8234700739744452
+      },
+      "zh-CN": {
+        "count": 2974,
+        "correct": 2487,
+        "unsupported": 0,
+        "accuracy": 0.8362474781439139
+      },
+      "hu-HU": {
+        "count": 2974,
+        "correct": 2161,
+        "unsupported": 0,
+        "accuracy": 0.726630800268998
+      },
+      "ro-RO": {
+        "count": 2974,
+        "correct": 2265,
+        "unsupported": 0,
+        "accuracy": 0.761600537995965
+      },
+      "zh-TW": {
+        "count": 2974,
+        "correct": 2365,
+        "unsupported": 0,
+        "accuracy": 0.7952252858103565
+      },
+      "cy-GB": {
+        "count": 2974,
+        "correct": 1639,
+        "unsupported": 0,
+        "accuracy": 0.551109616677875
+      },
+      "am-ET": {
+        "count": 2974,
+        "correct": 1334,
+        "unsupported": 0,
+        "accuracy": 0.4485541358439812
+      }
+    },
+    "macro_accuracy": 0.7149979307847499,
+    "count": 154648,
+    "seconds": 192.6575419740002,
+    "examples_per_second": 802.7092965863246
+  },
+  "diagnostics": {
+    "diagnostic:pt": {
+      "count": 3,
+      "accuracy": 1.0,
+      "worst_order_accuracy": 1.0,
+      "consistency": 1.0,
+      "brier_regret": 7.886988304767776e-10,
+      "worst_order_brier": 2.467773398956191e-09,
+      "nll": 2.103891552285609e-05,
+      "ece": 2.1038666961015196e-05
+    },
+    "diagnostic:en": {
+      "count": 3,
+      "accuracy": 1.0,
+      "worst_order_accuracy": 1.0,
+      "consistency": 1.0,
+      "brier_regret": 1.1595274914276354e-11,
+      "worst_order_brier": 5.446226103608541e-11,
+      "nll": 2.528017219883227e-06,
+      "ece": 2.528013180791433e-06
+    },
+    "diagnostic-alias:pt": {
+      "count": 2,
+      "accuracy": 1.0,
+      "worst_order_accuracy": 1.0,
+      "consistency": 1.0,
+      "brier_regret": 2.7625965108563243e-06,
+      "worst_order_brier": 5.561015463157067e-06,
+      "nll": 0.000956396971946862,
+      "ece": 0.0009555747324743735
+    },
+    "diagnostic-alias:en": {
+      "count": 2,
+      "accuracy": 1.0,
+      "worst_order_accuracy": 1.0,
+      "consistency": 1.0,
+      "brier_regret": 1.0381946113714448e-06,
+      "worst_order_brier": 2.0757069438387377e-06,
+      "nll": 0.0005331441533180119,
+      "ece": 0.0005328709204919235
+    }
+  }
+}

metrics/validation.json

@@ -0,0 +1,45 @@
+{
+  "count": 3814,
+  "accuracy": 0.6982170949134766,
+  "nll": 0.7055923721868408,
+  "per_source": {
+    "agnews": {
+      "count": 505,
+      "accuracy": 0.8792079207920792,
+      "nll": 0.34157273733644883
+    },
+    "banking77": {
+      "count": 476,
+      "accuracy": 0.9495798319327731,
+      "nll": 0.13563624952062953
+    },
+    "emotion": {
+      "count": 483,
+      "accuracy": 0.9130434782608695,
+      "nll": 0.27308556848896093
+    },
+    "gsm8k": {
+      "count": 404,
+      "accuracy": 1.0,
+      "nll": 0.0004848763044099426
+    },
+    "hellaswag": {
+      "count": 489,
+      "accuracy": 0.36400817995910023,
+      "nll": 1.406457885786678
+    },
+    "mmlu": {
+      "count": 958,
+      "accuracy": 0.48643006263048016,
+      "nll": 1.342455263134215
+    },
+    "winogrande": {
+      "count": 499,
+      "accuracy": 0.5571142284569138,
+      "nll": 0.6976872796682789
+    }
+  },
+  "step": 900,
+  "checkpoint": "runs/julia-auto-1000/checkpoint-00000900",
+  "validation_sha256": "8f089f6bed53b85e9a839ce0210a867ebfa108f63bb2200bd291400d0af9d9f5"
+}

model.safetensors

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

provenance.json

@@ -0,0 +1,527 @@
+{
+  "family": "Julia-1",
+  "variant": "posttrained-candidate",
+  "parent_weights_sha256": "e0fce3f70bc1add0fc5ea1555728129775f313dd8beb40bb4d0284b9cc4582e0",
+  "weights_sha256": "df853bf7fe424420011f3d0c47a05d7341aa9eefa7fb9f203ea4aada4ad95b72",
+  "step": 500,
+  "validation": {
+    "agnews": {
+      "count": 500,
+      "correct": 461,
+      "accuracy": 0.922,
+      "nll": 0.2361866206965157
+    },
+    "banking-joint": {
+      "count": 500,
+      "correct": 453,
+      "accuracy": 0.906,
+      "nll": 0.4732417627487641
+    },
+    "banking-rank": {
+      "count": 500,
+      "correct": 483,
+      "accuracy": 0.966,
+      "nll": 0.12442472780195588
+    },
+    "bilingual:en": {
+      "count": 409,
+      "correct": 396,
+      "accuracy": 0.9682151589242054,
+      "nll": 0.1019394528733742
+    },
+    "bilingual:pt": {
+      "count": 409,
+      "correct": 399,
+      "accuracy": 0.9755501222493888,
+      "nll": 0.07665246521243735
+    },
+    "emotiondair": {
+      "count": 500,
+      "correct": 457,
+      "accuracy": 0.914,
+      "nll": 0.4869592022011608
+    },
+    "jev:arc_challenge": {
+      "count": 200,
+      "correct": 57,
+      "accuracy": 0.285,
+      "nll": 4.898485339760228
+    },
+    "jev:mmlu": {
+      "count": 198,
+      "correct": 52,
+      "accuracy": 0.26262626262626265,
+      "nll": 5.022009487458182
+    },
+    "jev:mnli": {
+      "count": 200,
+      "correct": 121,
+      "accuracy": 0.605,
+      "nll": 2.405353136634182
+    },
+    "jev:sst5": {
+      "count": 200,
+      "correct": 81,
+      "accuracy": 0.405,
+      "nll": 3.058030146173687
+    },
+    "massive:af-ZA": {
+      "count": 200,
+      "correct": 160,
+      "accuracy": 0.8,
+      "nll": 0.7254367060870702
+    },
+    "massive:am-ET": {
+      "count": 200,
+      "correct": 91,
+      "accuracy": 0.455,
+      "nll": 1.8078553098358898
+    },
+    "massive:ar-SA": {
+      "count": 200,
+      "correct": 143,
+      "accuracy": 0.715,
+      "nll": 0.9127131833431383
+    },
+    "massive:az-AZ": {
+      "count": 200,
+      "correct": 150,
+      "accuracy": 0.75,
+      "nll": 0.8805768398220111
+    },
+    "massive:bn-BD": {
+      "count": 200,
+      "correct": 135,
+      "accuracy": 0.675,
+      "nll": 1.0898693716287062
+    },
+    "massive:ca-ES": {
+      "count": 200,
+      "correct": 149,
+      "accuracy": 0.745,
+      "nll": 0.9042317060852588
+    },
+    "massive:cy-GB": {
+      "count": 200,
+      "correct": 107,
+      "accuracy": 0.535,
+      "nll": 1.5896150314416113
+    },
+    "massive:da-DK": {
+      "count": 200,
+      "correct": 155,
+      "accuracy": 0.775,
+      "nll": 0.7864874714409028
+    },
+    "massive:de-DE": {
+      "count": 200,
+      "correct": 163,
+      "accuracy": 0.815,
+      "nll": 0.6609104527319621
+    },
+    "massive:el-GR": {
+      "count": 200,
+      "correct": 146,
+      "accuracy": 0.73,
+      "nll": 0.9561585124287475
+    },
+    "massive:en-US": {
+      "count": 200,
+      "correct": 171,
+      "accuracy": 0.855,
+      "nll": 0.4239840084077537
+    },
+    "massive:es-ES": {
+      "count": 200,
+      "correct": 170,
+      "accuracy": 0.85,
+      "nll": 0.4821026878847341
+    },
+    "massive:fa-IR": {
+      "count": 200,
+      "correct": 153,
+      "accuracy": 0.765,
+      "nll": 0.7513568875009335
+    },
+    "massive:fi-FI": {
+      "count": 200,
+      "correct": 136,
+      "accuracy": 0.68,
+      "nll": 1.0470849014139052
+    },
+    "massive:fr-FR": {
+      "count": 200,
+      "correct": 172,
+      "accuracy": 0.86,
+      "nll": 0.5079110052088927
+    },
+    "massive:he-IL": {
+      "count": 200,
+      "correct": 137,
+      "accuracy": 0.685,
+      "nll": 1.1409396331540986
+    },
+    "massive:hi-IN": {
+      "count": 200,
+      "correct": 148,
+      "accuracy": 0.74,
+      "nll": 0.8160677297670518
+    },
+    "massive:hu-HU": {
+      "count": 200,
+      "correct": 142,
+      "accuracy": 0.71,
+      "nll": 0.9946744119686869
+    },
+    "massive:hy-AM": {
+      "count": 200,
+      "correct": 117,
+      "accuracy": 0.585,
+      "nll": 1.3989824168977554
+    },
+    "massive:id-ID": {
+      "count": 200,
+      "correct": 162,
+      "accuracy": 0.81,
+      "nll": 0.7148022617771757
+    },
+    "massive:is-IS": {
+      "count": 200,
+      "correct": 140,
+      "accuracy": 0.7,
+      "nll": 1.0531424324651082
+    },
+    "massive:it-IT": {
+      "count": 200,
+      "correct": 152,
+      "accuracy": 0.76,
+      "nll": 0.7013908650180337
+    },
+    "massive:ja-JP": {
+      "count": 200,
+      "correct": 157,
+      "accuracy": 0.785,
+      "nll": 0.7928279227610233
+    },
+    "massive:jv-ID": {
+      "count": 200,
+      "correct": 124,
+      "accuracy": 0.62,
+      "nll": 1.349707674896094
+    },
+    "massive:ka-GE": {
+      "count": 200,
+      "correct": 96,
+      "accuracy": 0.48,
+      "nll": 1.7132205322599072
+    },
+    "massive:km-KH": {
+      "count": 200,
+      "correct": 96,
+      "accuracy": 0.48,
+      "nll": 1.6912345944473137
+    },
+    "massive:kn-IN": {
+      "count": 200,
+      "correct": 122,
+      "accuracy": 0.61,
+      "nll": 1.5155959311408833
+    },
+    "massive:ko-KR": {
+      "count": 200,
+      "correct": 158,
+      "accuracy": 0.79,
+      "nll": 0.677267845838551
+    },
+    "massive:lv-LV": {
+      "count": 200,
+      "correct": 130,
+      "accuracy": 0.65,
+      "nll": 1.0922244557466885
+    },
+    "massive:ml-IN": {
+      "count": 200,
+      "correct": 113,
+      "accuracy": 0.565,
+      "nll": 1.5063557911660717
+    },
+    "massive:mn-MN": {
+      "count": 200,
+      "correct": 100,
+      "accuracy": 0.5,
+      "nll": 1.578224376673286
+    },
+    "massive:ms-MY": {
+      "count": 200,
+      "correct": 158,
+      "accuracy": 0.79,
+      "nll": 0.7296966203279017
+    },
+    "massive:my-MM": {
+      "count": 200,
+      "correct": 100,
+      "accuracy": 0.5,
+      "nll": 1.6915851091994594
+    },
+    "massive:nb-NO": {
+      "count": 200,
+      "correct": 156,
+      "accuracy": 0.78,
+      "nll": 0.7617846100042545
+    },
+    "massive:nl-NL": {
+      "count": 200,
+      "correct": 167,
+      "accuracy": 0.835,
+      "nll": 0.5973099173809344
+    },
+    "massive:pl-PL": {
+      "count": 200,
+      "correct": 154,
+      "accuracy": 0.77,
+      "nll": 0.6892870971949061
+    },
+    "massive:pt-PT": {
+      "count": 200,
+      "correct": 169,
+      "accuracy": 0.845,
+      "nll": 0.5603875439414431
+    },
+    "massive:ro-RO": {
+      "count": 200,
+      "correct": 153,
+      "accuracy": 0.765,
+      "nll": 0.8143788994751282
+    },
+    "massive:ru-RU": {
+      "count": 200,
+      "correct": 169,
+      "accuracy": 0.845,
+      "nll": 0.4346364665858552
+    },
+    "massive:sl-SL": {
+      "count": 200,
+      "correct": 139,
+      "accuracy": 0.695,
+      "nll": 0.9863898763288126
+    },
+    "massive:sq-AL": {
+      "count": 200,
+      "correct": 144,
+      "accuracy": 0.72,
+      "nll": 1.008332237904707
+    },
+    "massive:sv-SE": {
+      "count": 200,
+      "correct": 157,
+      "accuracy": 0.785,
+      "nll": 0.775370210089804
+    },
+    "massive:sw-KE": {
+      "count": 200,
+      "correct": 97,
+      "accuracy": 0.485,
+      "nll": 1.7013354790948956
+    },
+    "massive:ta-IN": {
+      "count": 200,
+      "correct": 131,
+      "accuracy": 0.655,
+      "nll": 1.1463096412760028
+    },
+    "massive:te-IN": {
+      "count": 200,
+      "correct": 124,
+      "accuracy": 0.62,
+      "nll": 1.2817266688502815
+    },
+    "massive:th-TH": {
+      "count": 200,
+      "correct": 147,
+      "accuracy": 0.735,
+      "nll": 0.8718785998410745
+    },
+    "massive:tl-PH": {
+      "count": 200,
+      "correct": 140,
+      "accuracy": 0.7,
+      "nll": 0.9638123165387646
+    },
+    "massive:tr-TR": {
+      "count": 200,
+      "correct": 157,
+      "accuracy": 0.785,
+      "nll": 0.6703527633025136
+    },
+    "massive:ur-PK": {
+      "count": 200,
+      "correct": 131,
+      "accuracy": 0.655,
+      "nll": 1.1953078716722099
+    },
+    "massive:vi-VN": {
+      "count": 200,
+      "correct": 144,
+      "accuracy": 0.72,
+      "nll": 0.9832935351908162
+    },
+    "massive:zh-CN": {
+      "count": 200,
+      "correct": 156,
+      "accuracy": 0.78,
+      "nll": 0.6844688390764435
+    },
+    "massive:zh-TW": {
+      "count": 200,
+      "correct": 154,
+      "accuracy": 0.77,
+      "nll": 0.7012105530022036
+    },
+    "open-jev:customer-control-v1": {
+      "count": 96,
+      "correct": 93,
+      "accuracy": 0.96875,
+      "nll": 0.11922412518095221
+    },
+    "open-jev:painting-geometry-v1": {
+      "count": 192,
+      "correct": 153,
+      "accuracy": 0.796875,
+      "nll": 0.4879071857538497
+    },
+    "open-jev:reasoning-control-v1": {
+      "count": 131,
+      "correct": 68,
+      "accuracy": 0.5190839694656488,
+      "nll": 1.5929976853600538
+    },
+    "open-jev:snake-v1": {
+      "count": 200,
+      "correct": 158,
+      "accuracy": 0.79,
+      "nll": 0.4846087664592145
+    },
+    "open-jev:tic_tac_toe-v1": {
+      "count": 115,
+      "correct": 47,
+      "accuracy": 0.40869565217391307,
+      "nll": 1.2158676274170932
+    },
+    "open-jev:tile_platformer-v1": {
+      "count": 22,
+      "correct": 20,
+      "accuracy": 0.9090909090909091,
+      "nll": 0.09021685084244535
+    },
+    "open-jev:trex_runner-v1": {
+      "count": 2,
+      "correct": 1,
+      "accuracy": 0.5,
+      "nll": 1.2663163314336559
+    },
+    "open-jev:vizdoom-basic-v1": {
+      "count": 153,
+      "correct": 149,
+      "accuracy": 0.9738562091503268,
+      "nll": 0.03614709415145343
+    },
+    "open-jev:workflow-controls-v1/agent_trace_observability": {
+      "count": 71,
+      "correct": 71,
+      "accuracy": 1.0,
+      "nll": 0.0011360287241133358
+    },
+    "open-jev:workflow-controls-v1/customer_service": {
+      "count": 137,
+      "correct": 136,
+      "accuracy": 0.9927007299270073,
+      "nll": 0.030294906363817344
+    },
+    "open-jev:workflow-controls-v1/invoice_processing": {
+      "count": 112,
+      "correct": 110,
+      "accuracy": 0.9821428571428571,
+      "nll": 0.10505136013108395
+    },
+    "open-jev:workflow-controls-v1/security_incidents": {
+      "count": 121,
+      "correct": 121,
+      "accuracy": 1.0,
+      "nll": 0.009351040906769742
+    },
+    "replay:agnews": {
+      "count": 29,
+      "correct": 23,
+      "accuracy": 0.7931034482758621,
+      "nll": 0.5144041118900763
+    },
+    "replay:banking77": {
+      "count": 52,
+      "correct": 50,
+      "accuracy": 0.9615384615384616,
+      "nll": 0.1474100871587149
+    },
+    "replay:emotion": {
+      "count": 15,
+      "correct": 12,
+      "accuracy": 0.8,
+      "nll": 0.5748594660688843
+    },
+    "replay:gsm8k": {
+      "count": 200,
+      "correct": 196,
+      "accuracy": 0.98,
+      "nll": 0.047936887727627886
+    },
+    "replay:hellaswag": {
+      "count": 119,
+      "correct": 46,
+      "accuracy": 0.3865546218487395,
+      "nll": 3.136717304436293
+    },
+    "replay:mmlu": {
+      "count": 182,
+      "correct": 93,
+      "accuracy": 0.510989010989011,
+      "nll": 2.17472550274021
+    },
+    "replay:winogrande": {
+      "count": 200,
+      "correct": 107,
+      "accuracy": 0.535,
+      "nll": 1.151156462092322
+    },
+    "typed": {
+      "count": 500,
+      "correct": 365,
+      "accuracy": 0.73,
+      "nll": 2.027869497306916
+    },
+    "typed:choice": {
+      "count": 155,
+      "correct": 108,
+      "accuracy": 0.6967741935483871,
+      "nll": 2.5421524021866317
+    },
+    "typed:noul": {
+      "count": 142,
+      "correct": 115,
+      "accuracy": 0.8098591549295775,
+      "nll": 1.5555020525764138
+    },
+    "typed:score": {
+      "count": 203,
+      "correct": 142,
+      "accuracy": 0.6995073891625616,
+      "nll": 1.9656149499935025
+    },
+    "banking77": {
+      "count": 100,
+      "correct": 83,
+      "accuracy": 0.83,
+      "recall_at_16": 0.99,
+      "unsupported": 0
+    }
+  },
+  "quality_gate": false
+}

pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=70"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "supersonic-julia"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = ["torch>=2.6", "transformers>=5.0,<5.1", "safetensors>=0.5", "numpy>=1.26"]
+
+[tool.setuptools.packages.find]
+include = ["julia*"]
+exclude = ["julia.router.tests*"]
+
+[project.optional-dependencies]
+cuda = ["bitsandbytes>=0.48,<0.50", "accelerate>=1.10,<2"]
+
+[tool.setuptools.package-data]
+"julia.router" = ["native/*.bend", "native/*.c", "README.md"]
+"julia" = ["native/*.c", "native/*.bend", "native/*.json"]

tokenizer/tokenizer.json

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

tokenizer/tokenizer_config.json

@@ -0,0 +1,28 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<bos>",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "<bos>",
+  "eos_token": "<eos>",
+  "extra_special_tokens": [
+    "<start_of_turn>",
+    "<end_of_turn>"
+  ],
+  "is_local": true,
+  "mask_token": "<mask>",
+  "max_length": 512,
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 8192,
+  "pad_token": "<pad>",
+  "padding_side": "right",
+  "sep_token": "<eos>",
+  "spaces_between_special_tokens": false,
+  "stride": 0,
+  "tokenizer_class": "TokenizersBackend",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "<unk>"
+}