feat: consolidate model variants in crivo-web

README.md

@@ -1,6 +1,12 @@
 ---
 license: cc-by-nc-4.0
-base_model: tardellirs/crivo-150m
+base_model:
+- tardellirs/crivo-17m
+- tardellirs/crivo-32m
+- tardellirs/crivo-68m
+- tardellirs/crivo-150m
+- tardellirs/crivo-400m
+- tardellirs/crivo-1b
 library_name: transformers.js
 language:
 - en
@@ -74,8 +80,8 @@ const run = decide(input, {
 })
 ```
 
-The default size is 150M **v2**, served from `dizyann/crivo-150m-v2-web`.
-The original `dizyann/crivo-150m-web` weights remain unchanged for existing consumers.
+The default size is 150M **v2**, served from `dizyann/crivo-web/models/150m`.
+All variants live in `models/<size>/` in this repository. The legacy root weights remain unchanged; Hugging Face redirects the former `dizyann/crivo-150m-web` URL.
 The only runtime export remains `decide`; `ModelSize` and `ModelOptions` are types.
 An injected `decisionRuntime` takes precedence over `model` options. When composing
 through a Layer, provide `model: {}` alongside a runtime provider if using defaults.
@@ -88,12 +94,12 @@ conversion fixtures on native CPU, not an accuracy score.
 
 | Model | FP32 (MiB) | INT8 (MiB) | Training context (tokens) | INT8 max probability difference |
 | --- | ---: | ---: | ---: | ---: |
-| [17M](https://huggingface.co/dizyann/crivo-17m-web) | 64.5 | 16.6 | 8,192 | 0.0270 |
-| [32M](https://huggingface.co/dizyann/crivo-32m-web) | 122.4 | 31.2 | 2,048 | 0.0260 |
-| [68M](https://huggingface.co/dizyann/crivo-68m-web) | 261.4 | 66.4 | 8,192 | 0.0321 |
-| [150M](https://huggingface.co/dizyann/crivo-150m-v2-web) | 571.3 | 144.3 | 8,192 | 0.0863 |
-| [400M](https://huggingface.co/dizyann/crivo-400m-web) | 1510.8 | 380.1 | 8,192 | 0.0341 |
-| [1B](https://huggingface.co/dizyann/crivo-1b-web) | 3935.0 | 987.3 | 8,192 | 0.0088 |
+| [17M](https://huggingface.co/dizyann/crivo-web/tree/main/models/17m) | 64.5 | 16.6 | 8,192 | 0.0270 |
+| [32M](https://huggingface.co/dizyann/crivo-web/tree/main/models/32m) | 122.4 | 31.2 | 2,048 | 0.0260 |
+| [68M](https://huggingface.co/dizyann/crivo-web/tree/main/models/68m) | 261.4 | 66.4 | 8,192 | 0.0321 |
+| [150M](https://huggingface.co/dizyann/crivo-web/tree/main/models/150m) | 571.3 | 144.3 | 8,192 | 0.0863 |
+| [400M](https://huggingface.co/dizyann/crivo-web/tree/main/models/400m) | 1510.8 | 380.1 | 8,192 | 0.0341 |
+| [1B](https://huggingface.co/dizyann/crivo-web/tree/main/models/1b) | 3935.0 | 987.3 | 8,192 | 0.0088 |
 
 FP32 was checked against PyTorch, native JavaScript ONNX Runtime, and WebGPU for
 all six variants. INT8 was checked on native CPU and WASM; WASM probabilities differed
@@ -108,7 +114,7 @@ Install Bun 1.4+ and the Hugging Face CLI (`hf`), then download the source witho
 model weights. This includes nested source files, examples, configuration and the lockfile:
 
 ```bash
-hf download dizyann/crivo-150m-web --exclude 'onnx/*' --exclude 'tokenizer.json' --local-dir crivo-web
+hf download dizyann/crivo-web --exclude 'onnx/*' --exclude 'models/*' --exclude 'tokenizer.json' --local-dir crivo-web
 cd crivo-web
 bun install --frozen-lockfile
 bun run decide examples/basic/input.json --device cpu
@@ -373,7 +379,10 @@ bun scripts/conversion/verify.ts 68m
 ```
 
 Repeat the last two commands for each size. Output stays in `.cache/variants/<size>`;
-source weights and generated graphs are not committed to the application repository.
+source weights stay local. Publish generated graphs and metadata into this repository’s
+`models/<size>/` directories with `python scripts/conversion/publish.py 17m 32m 68m 150m 400m 1b`.
+The Hub stores the large binaries through Git LFS/Xet. Use `GIT_LFS_SKIP_SMUDGE=1 git clone`
+when cloning only to work on source code.
 The exporter checks varied sequence lengths, option counts and all three question types
 against the original PyTorch model. The JavaScript verifier checks the same fixtures
 against native ONNX Runtime. These are numerical smoke tests, not a rerun of Decision Index.

biome.jsonc

@@ -2,7 +2,7 @@
   "$schema": "https://biomejs.dev/schemas/2.5.15/schema.json",
   "files": {
     "ignoreUnknown": true,
-    "includes": ["**", "!**/*.md", "!tokenizer.json", "!!**/.cache", "!!dist"]
+    "includes": ["**", "!**/*.md", "!tokenizer.json", "!!**/.cache", "!!dist", "!!models"]
   },
   "formatter": {
     "indentStyle": "space",

scripts/benchmark/README.md

@@ -0,0 +1,31 @@
+# Playground benchmark
+
+Run `bun run browser`, open `http://localhost:4180` in a fresh browser tab, and paste
+`playground.js` into DevTools before the first inference. Leave the default example
+unchanged. The script operates the actual selectors and Run button and observes the
+production worker messages; it does not substitute an inference implementation.
+
+Inspect `window.crivoBenchmark.status` and `.error`. Once status is `complete`, save
+`JSON.stringify(window.crivoBenchmark, null, 2)`. Each of the 17 supported configurations
+runs once to initialize, three additional times to warm up, then 20 measured times.
+All three questions are sent together in one request. Warm samples must report zero
+model loading time. A 50 ms pause between requests lets the UI finish handling results.
+Keep other workloads idle; hardware, power mode, browser and background activity affect timing.
+
+`browser.json` records the measured input and all timing samples from the local playground.
+Inference timing includes tokenization, the batched ONNX forward pass and answer mapping.
+Worker total includes validation and other worker overhead, but excludes rendering and
+main-thread messaging. First-run model setup and first inference are retained separately.
+The README reports median and nearest-rank p95 inference times (19th of 20 sorted samples).
+
+For the recorded run, exact locally converted weights were preloaded into the browser's
+`transformers-cache` CacheStorage under their production Hugging Face resolve URLs.
+These were the same artifacts published at the revision recorded in `browser.json`.
+Model setup therefore measures cached asset reads and session initialization, **not downloads**.
+To reproduce cached setup without local artifacts, run each selection once to download
+its assets, reload the page, and then start the script. Do not clear browser storage.
+Network speed is deliberately excluded. ONNX Runtime/CDN files may also be browser-cached.
+
+The 1B FP32/WASM configuration is excluded because it exceeds the tested WASM memory
+budget. INT8/WebGPU is unsupported. INT8 here is weight-only storage with FP32 arithmetic;
+it is not expected to consistently outperform FP32.

scripts/benchmark/playground.js

@@ -0,0 +1,85 @@
+// Run in a fresh `bun run browser` page's DevTools console. Uses the actual UI and worker.
+window.crivoBenchmark = {
+  runs: [],
+  status: 'starting',
+  userAgent: navigator.userAgent,
+  threads: navigator.hardwareConcurrency
+}
+;(async () => {
+  const report = window.crivoBenchmark
+  const adapter = await navigator.gpu?.requestAdapter()
+  report.gpu = adapter
+    ? {
+        ...Object.fromEntries(
+          ['vendor', 'architecture', 'device', 'description'].map((k) => [k, adapter.info[k]])
+        )
+      }
+    : null
+  const NativeWorker = window.Worker
+  let pending
+  let metrics
+  window.Worker = class extends NativeWorker {
+    constructor(...args) {
+      super(...args)
+      this.addEventListener('message', ({ data }) => {
+        if (data.kind === 'metrics') metrics = data.metrics
+        if (data.kind === 'error') pending?.reject(Error(data.message))
+        if (data.kind === 'result') {
+          if (!data.result.ok) pending?.reject(Error(JSON.stringify(data.result.error)))
+          else pending?.resolve({ ...metrics, totalMs: data.totalMs })
+        }
+      })
+      this.addEventListener('error', () => pending?.reject(Error('Worker stopped')))
+    }
+    postMessage(data, ...args) {
+      report.input = data.input
+      super.postMessage(data, ...args)
+    }
+  }
+  const run = () =>
+    new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(Error('Run timed out')), 240000)
+      pending = {
+        resolve: (data) => {
+          clearTimeout(timeout)
+          resolve(data)
+        },
+        reject: (error) => {
+          clearTimeout(timeout)
+          reject(error)
+        }
+      }
+      document.getElementById('run').click()
+    })
+  for (const size of ['17m', '32m', '68m', '150m', '400m', '1b']) {
+    for (const [device, dtype] of [
+      ['cpu', 'q8'],
+      ...(size === '1b' ? [] : [['cpu', 'fp32']]),
+      ['gpu', 'fp32']
+    ]) {
+      const entry = { size, device, dtype, samples: [] }
+      report.runs.push(entry)
+      report.status = `${size} ${device} ${dtype}`
+      for (const [id, value] of [
+        ['size', size],
+        ['device', device],
+        ['dtype', dtype]
+      ]) {
+        const select = document.getElementById(id)
+        select.value = value
+        select.dispatchEvent(new Event('change'))
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50))
+      entry.first = await run()
+      for (let i = 0; i < 23; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 50))
+        const result = await run()
+        if (result.loadMs !== 0) throw Error('Session was not reused')
+        if (i >= 3) entry.samples.push(result)
+      }
+    }
+  }
+  report.status = 'complete'
+})().catch((error) => {
+  window.crivoBenchmark.error = String(error)
+})

scripts/conversion/publish.py

@@ -5,7 +5,7 @@ parser=argparse.ArgumentParser();parser.add_argument('sizes',nargs='+');args=par
 for size in args.sizes:
  directory=Path('.cache/variants')/size
  report=json.loads((directory/'parity.json').read_text())
- repo=f'dizyann/crivo-{size if size != "150m" else "150m-v2"}-web'
+ repo='dizyann/crivo-web'
  source=report['source']
  card=f'''---
 license: cc-by-nc-4.0
@@ -20,7 +20,7 @@ Original architecture, training and weights by [tardellirs](https://huggingface.
 No additional training was performed. Weights retain the CC BY-NC 4.0 license.
 
 [Playground](https://huggingface.co/spaces/dizyann/crivo-demo) ·
-[TypeScript library, CLI and model comparison](https://huggingface.co/dizyann/crivo-150m-web)
+[TypeScript library, CLI and model comparison](https://huggingface.co/dizyann/crivo-web)
 
 Source revision: `{source['revision']}`.
 See the [pinned original card](https://huggingface.co/{source['repo']}/blob/{source['revision']}/README.md)
@@ -41,4 +41,4 @@ older native ONNX Runtime versions can produce materially different INT8 probabi
 '''
  (directory/'README.md').write_text(card)
  subprocess.run(['hf','repos','create',repo,'--type','model','--exist-ok'],check=True)
- subprocess.run(['hf','upload',repo,str(directory),'--commit-message',f'Publish pinned Crivo {size} FP32 and INT8 web conversion'],check=True)
+ subprocess.run(['hf','upload',repo,str(directory),f'models/{size}','--commit-message',f'Publish pinned Crivo {size} FP32 and INT8 web conversion'],check=True)

space/README.md

@@ -7,18 +7,13 @@ sdk: static
 app_file: index.html
 short_description: Typed decisions running locally in your browser
 models:
-- dizyann/crivo-17m-web
-- dizyann/crivo-32m-web
-- dizyann/crivo-68m-web
-- dizyann/crivo-150m-v2-web
-- dizyann/crivo-400m-web
-- dizyann/crivo-1b-web
+- dizyann/crivo-web
 license: cc-by-nc-4.0
 ---
 
 # Crivo Decision Playground
 
-Explore choice, noul (probability of true), and ordered score decisions with [Crivo Web](https://huggingface.co/dizyann/crivo-150m-web).
+Explore choice, noul (probability of true), and ordered score decisions with [Crivo Web](https://huggingface.co/dizyann/crivo-web).
 
 Edit the JSON state and decision definitions, then select **Run decisions**. Inference happens in your browser; request contents are not sent to a hosted inference service. Model and runtime assets download from the Hub and runtime CDN.
 
@@ -26,7 +21,7 @@ Choose 17M, 32M v2, 68M, 150M v2, 400M, or 1B. CPU/WASM supports INT8 weight sto
 
 Scores are expected zero-based level indices. Probabilities are model estimates, not guarantees. The original model is primarily English. Weights retain the original CC BY-NC 4.0 license and non-commercial restriction. Original model: [tardellirs/crivo-150m](https://huggingface.co/collections/tardellirs/crivo).
 
-Source and build instructions live in the [model repository](https://huggingface.co/dizyann/crivo-150m-web). Build with `bun run space:build`; upload `dist/space` to a Static Space.
+Source and build instructions live in the [model repository](https://huggingface.co/dizyann/crivo-web). Build with `bun run space:build`; upload `dist/space` to a Static Space.
 
 ## Credits
 
@@ -38,4 +33,4 @@ Questions follow the [official TypeSafe System One reference](https://docs.types
 
 The Space translates this format into the local Crivo API. Structured descriptions are serialized as JSON, null choice descriptions use the option name, and omitted noul descriptions use true/false statements. Crivo requires at least two choices and retains its own token limit. This is format compatibility, not identical model preprocessing or predictions. Responses use `model` and `answers`, with `choice`, `noul`, or `score`/`legend` fields. Confidence and token usage are omitted because Crivo does not expose them.
 
-All questions run together in a single ONNX batch. Dynamic INT8 quantization can make probabilities depend on the other questions in that batch; compare equivalent batches. FP32 batch/single equivalence is covered by the model integration tests.
+All questions run together in a single ONNX batch. Compare equivalent batches and precision settings when evaluating probabilities. FP32 batch/single equivalence is covered by the model integration tests.

space/app.ts

@@ -114,7 +114,7 @@ function render(answers: Record<string, DecisionAnswer<Decision>>) {
     results.append(section)
   }
   outputEditor.value = JSON.stringify(
-    toResponse(answers, runDecisions, modelFor(size.value as ModelSize).modelId),
+    toResponse(answers, runDecisions, modelFor(size.value as ModelSize).modelId, size.value),
     null,
     2
   )
@@ -196,7 +196,7 @@ element<HTMLFormElement>('form').onsubmit = (event) => {
         }
         render(data.result.answers)
         element('metrics').textContent =
-          `${seconds(data.totalMs)} total · ${timings.loadMs === 0 ? 'session reused' : `${seconds(timings.loadMs)} model setup`} · ${seconds(timings.inferenceMs)} inference · ${dtype.value === 'q8' ? 'INT8' : 'FP32'} / ${device.value === 'gpu' ? 'WebGPU' : 'WASM'} · ${modelFor(size.value as ModelSize).modelId}`
+          `${seconds(data.totalMs)} total · ${timings.loadMs === 0 ? 'session reused' : `${seconds(timings.loadMs)} model setup`} · ${seconds(timings.inferenceMs)} inference · ${dtype.value === 'q8' ? 'INT8' : 'FP32'} / ${device.value === 'gpu' ? 'WebGPU' : 'WASM'} · ${modelFor(size.value as ModelSize).modelId} / ${size.value}`
         finish('Finished locally. Model stays ready for the next run.')
       }
     }

space/index.html

@@ -2,7 +2,7 @@
 <html lang="en">
 <head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Crivo — Decision playground</title><link rel="stylesheet" href="./style.css"><script type="module" src="./app.ts"></script></head>
 <body>
-<header><a class="brand" href="https://huggingface.co/dizyann/crivo-150m-web">crivo<span> / decision playground</span></a><a href="https://huggingface.co/dizyann/crivo-150m-web">Model & documentation ↗</a></header>
+<header><a class="brand" href="https://huggingface.co/dizyann/crivo-web">crivo<span> / decision playground</span></a><a href="https://huggingface.co/dizyann/crivo-web">Model & documentation ↗</a></header>
 <main>
 <section class="intro"><h1>Give context.<br>Get a decision.</h1><div><p>A small model for explicit choices.<br>Explore classification, yes/no probability, and ordered scores — right in your browser.</p><span class="local">Your input stays on this device.</span></div></section>
 <div class="workspace">

space/system-one.ts

@@ -74,10 +74,12 @@ export function fromQuestions(state: unknown, questions: unknown): DecideInput {
 export function toResponse(
   answers: Record<string, DecisionAnswer<Decision>>,
   decisions: readonly Decision[],
-  modelId = 'dizyann/crivo-150m-web'
+  modelId = 'dizyann/crivo-web',
+  variant?: string
 ) {
   return {
     model: modelId,
+    ...(variant ? { variant } : {}),
     answers: Object.fromEntries(
       Object.entries(answers).map(([id, answer]) => {
         if (answer.type === 'choice')

space/worker.ts

@@ -45,9 +45,7 @@ self.onmessage = async ({ data }) => {
                 ? 'unknown'
                 : cachedPaths.some(
                       (path) =>
-                        path.includes(
-                          `/${data.size === '150m' ? 'crivo-150m-v2-web' : `crivo-${data.size}-web`}/`
-                        ) && path.endsWith(`/${progress.file}`)
+                        path.includes('/dizyann/crivo-web/') && path.endsWith(`/${progress.file}`)
                     )
                   ? 'cache'
                   : 'network'

src/cli/progress.ts

@@ -34,7 +34,7 @@ export class TerminalProgress {
     )
     this.missing = new Set(files.filter((_, index) => !cached[index]))
     this.write(
-      `Model: ${info.modelId} | precision: ${info.dtype} | providers: ${info.providers.join(', ')}`
+      `Model: ${info.modelId}${info.variant ? ` / ${info.variant}` : ''} | precision: ${info.dtype} | providers: ${info.providers.join(', ')}`
     )
     if (this.missing.size) {
       const weightMiB =
@@ -81,7 +81,7 @@ export class TerminalProgress {
     )
     if (this.info)
       this.write(
-        `Model: ${this.info.modelId} | precision: ${this.info.dtype} | providers: ${this.info.providers.join(', ')}`
+        `Model: ${this.info.modelId}${this.info.variant ? ` / ${this.info.variant}` : ''} | precision: ${this.info.dtype} | providers: ${this.info.providers.join(', ')}`
       )
   }
 }

src/decisions/adapters/crivo.ts

@@ -10,6 +10,7 @@ export type { CrivoDevice } from './devices.js'
 
 export interface ModelLoadInfo {
   modelId: string
+  variant?: ModelSize
   dtype: 'q8' | 'fp32'
   providers: string[]
   weightMiB?: number
@@ -99,11 +100,13 @@ export class Crivo {
   static async load(options: CrivoLoadOptions = {}): Promise<Crivo> {
     const selected = modelFor(options.size)
     const modelId = options.modelId ?? selected.modelId
+    const family = !options.modelId || options.modelId === selected.modelId
     const execution = await resolveExecution(options)
     const native = typeof process !== 'undefined' && process.release?.name === 'node'
     if (
       !native &&
-      modelId === modelFor('1b').modelId &&
+      family &&
+      selected.size === '1b' &&
       execution.device === 'wasm' &&
       execution.dtype === 'fp32'
     )
@@ -120,10 +123,13 @@ export class Crivo {
     const cacheDir = options.cacheDir ?? (native ? './.cache/crivo' : undefined)
     await options.onLoadStart?.({
       modelId,
-      ...(!options.modelId
+      ...(family
         ? {
             weightMiB: Math.ceil(selected.assets[execution.dtype].bytes / 1024 ** 2),
-            weightFiles: selected.assets[execution.dtype].files
+            variant: selected.size,
+            weightFiles: selected.assets[execution.dtype].files.map(
+              (file) => `models/${selected.size}/${file}`
+            )
           }
         : {}),
       dtype: execution.dtype,
@@ -140,7 +146,13 @@ export class Crivo {
     const tokenizer = await AutoTokenizer.from_pretrained(modelId, loading)
     const model = await PreTrainedModel.from_pretrained(modelId, {
       ...loading,
-      ...execution
+      ...execution,
+      ...(family
+        ? {
+            subfolder: selected.subfolder,
+            use_external_data_format: selected.assets[execution.dtype].files.length - 1
+          }
+        : {})
     })
     // An encoder-only export cannot reproduce the Crivo decision interface.
     const session = model.sessions.model as {

src/decisions/models.ts

@@ -1,5 +1,5 @@
 import { MODEL_ASSETS } from './model-assets.js'
-/** Latest upstream checkpoints. The legacy 150M repository remains addressable by modelId. */
+/** Latest upstream checkpoints. All sizes share one Hub repository and tokenizer. */
 export const MODEL_SIZES = ['17m', '32m', '68m', '150m', '400m', '1b'] as const
 export type ModelSize = (typeof MODEL_SIZES)[number]
 export interface ModelOptions {
@@ -7,16 +7,9 @@ export interface ModelOptions {
   dtype?: 'q8' | 'fp32'
   device?: 'cpu' | 'gpu' | 'auto'
 }
-const MODELS = {
-  '17m': { modelId: 'dizyann/crivo-17m-web' },
-  '32m': { modelId: 'dizyann/crivo-32m-web' },
-  '68m': { modelId: 'dizyann/crivo-68m-web' },
-  '150m': { modelId: 'dizyann/crivo-150m-v2-web' },
-  '400m': { modelId: 'dizyann/crivo-400m-web' },
-  '1b': { modelId: 'dizyann/crivo-1b-web' }
-} satisfies Record<ModelSize, { modelId: string }>
+export const MODEL_REPO = 'dizyann/crivo-web'
 
 export function modelFor(size: ModelSize = '150m') {
-  if (!Object.hasOwn(MODELS, size)) throw new Error(`Unknown Crivo size: ${size}`)
-  return { ...MODELS[size], assets: MODEL_ASSETS[size] }
+  if (!Object.hasOwn(MODEL_ASSETS, size)) throw new Error(`Unknown Crivo size: ${size}`)
+  return { modelId: MODEL_REPO, size, subfolder: `models/${size}/onnx`, assets: MODEL_ASSETS[size] }
 }

tests/models.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from 'bun:test'
+import { MODEL_REPO, MODEL_SIZES, modelFor } from '../src/decisions/models.js'
+
+test('every variant resolves to its own graph folder in the shared repository', () => {
+  expect(MODEL_REPO).toBe('dizyann/crivo-web')
+  expect(modelFor().size).toBe('150m')
+  const folders = MODEL_SIZES.map((size) => {
+    const model = modelFor(size)
+    expect(model.modelId).toBe(MODEL_REPO)
+    expect(model.subfolder).toBe(`models/${size}/onnx`)
+    return model.subfolder
+  })
+  expect(new Set(folders).size).toBe(6)
+  expect(modelFor('1b').assets.fp32.files).toHaveLength(5)
+  expect(modelFor('1b').assets.q8.files).toHaveLength(2)
+})

tests/system-one.test.ts

@@ -37,7 +37,7 @@ test('System One questions map to all three local decision types', () => {
       request.decisions
     )
   ).toEqual({
-    model: 'dizyann/crivo-150m-web',
+    model: 'dizyann/crivo-web',
     answers: {
       route: { type: 'choice', choice: 'billing', probabilities: { billing: 0.8, support: 0.2 } },
       urgent: { type: 'noul', noul: 0.9 },