Spaces:

aleada
/

pack-precision-map

Running

App Files Files Community

aleada commited on 10 days ago

Commit

e73d8ef

verified ·

1 Parent(s): 1fab703

pack precision map

Browse files

Files changed (2) hide show

index.html +255 -258
precision_map.js +390 -384

index.html CHANGED Viewed

@@ -1,258 +1,255 @@
-<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>How much of this pack is actually 4-bit?</title>
-<!-- The Space renders inside an iframe and huggingface.co sends
-     x-frame-options: DENY, so any link without a target tries to load a
-     refused page in the frame and reads as broken. -->
-<base target="_blank">
-<style>
-  :root {
-    --bg: #fbfbfa; --panel: #ffffff; --ink: #1a1a19; --muted: #6b6b66;
-    --line: #e4e3df; --accent: #3d5a80;
-    --problem: #a03030; --problem-bg: #fdf3f2;
-    --check: #8a6212; --check-bg: #fdf9ee;
-    --clear: #2f6b45; --clear-bg: #f1f8f3;
-    --q: #3d5a80; --m: #9a9790; --f: #b5793a; --bfr: #d9d6d0;
-    --mono: ui-monospace, "SF Mono", "Cascadia Mono", Menlo, monospace;
-  }
-  @media (prefers-color-scheme: dark) {
-    :root {
-      --bg: #16171a; --panel: #1d1f23; --ink: #e8e6e3; --muted: #9a978f;
-      --line: #2e3137; --accent: #8ab0d9;
-      --problem: #e08a86; --problem-bg: #2a1e1e;
-      --check: #d9b76a; --check-bg: #29241a;
-      --clear: #8fc9a6; --clear-bg: #1b2620;
-      --q: #7fa3cc; --m: #6f6c66; --f: #d19a5e; --bfr: #3a3d43;
-    }
-  }
-  * { box-sizing: border-box; }
-  body {
-    margin: 0; background: var(--bg); color: var(--ink);
-    font: 16px/1.65 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif;
-    -webkit-font-smoothing: antialiased;
-  }
-  .wrap { max-width: 50rem; margin: 0 auto; padding: 3.5rem 1.25rem 5rem; }
-  .brand { display: inline-block; margin-bottom: 1.75rem; }
-  .brand img { height: 1.5rem; width: auto; display: block; filter: invert(1); opacity: .78; }
-  @media (prefers-color-scheme: dark) { .brand img { filter: none; opacity: .9; } }
-  header h1 {
-    font-size: clamp(1.6rem, 4.5vw, 2.2rem); line-height: 1.2;
-    letter-spacing: -0.02em; margin: 0 0 .75rem; font-weight: 620;
-  }
-  header p { color: var(--muted); margin: 0 0 .5rem; max-width: 42rem; }
-  form { display: flex; gap: .5rem; flex-wrap: wrap; margin: 2rem 0 .75rem; }
-  input[type=text] {
-    flex: 1 1 20rem; min-width: 0; padding: .7rem .85rem;
-    border: 1px solid var(--line); border-radius: .5rem;
-    background: var(--panel); color: var(--ink);
-    font: inherit; font-family: var(--mono); font-size: .92rem;
-  }
-  input[type=text]:focus { outline: 2px solid var(--accent); outline-offset: -1px; border-color: transparent; }
-  button {
-    padding: .7rem 1.4rem; border: 0; border-radius: .5rem;
-    background: var(--accent); color: #fff; font: inherit; font-weight: 560; cursor: pointer;
-  }
-  button:hover { filter: brightness(1.08); }
-  button:disabled { opacity: .55; cursor: progress; }
-  .examples { font-size: .86rem; color: var(--muted); margin-bottom: 2.5rem; line-height: 2; }
-  .examples .group { display: inline-block; min-width: 8.5rem; }
-  .examples button {
-    background: none; color: var(--accent); padding: 0 .15rem; font-size: .86rem;
-    font-family: var(--mono); text-decoration: underline; text-underline-offset: 2px; font-weight: 400;
-  }
-  .card {
-    background: var(--panel); border: 1px solid var(--line);
-    border-radius: .7rem; padding: 1.1rem 1.3rem; margin: .85rem 0;
-  }
-  .card h3 { margin: 0 0 .5rem; font-size: 1.02rem; font-weight: 600; }
-  .card h4 { margin: 1.4rem 0 .4rem; font-size: .85rem; font-weight: 600;
-             text-transform: uppercase; letter-spacing: .05em; color: var(--muted); }
-  .card p { margin: .5rem 0; }
-  .problem { border-left: 3px solid var(--problem); background: var(--problem-bg); }
-  .problem h3 { color: var(--problem); }
-  .check { border-left: 3px solid var(--check); background: var(--check-bg); }
-  .check h3 { color: var(--check); }
-  .clear { border-left: 3px solid var(--clear); background: var(--clear-bg); }
-  .clear h3 { color: var(--clear); }
-  .warn { color: var(--problem); }
-  .note { color: var(--muted); font-size: .92rem; }
-  .bar {
-    display: flex; height: 1.15rem; border-radius: .3rem; overflow: hidden;
-    margin: 1rem 0 .3rem; background: var(--line);
-  }
-  .seg { display: block; height: 100%; }
-  .seg + .seg { box-shadow: inset 2px 0 0 var(--panel); }
-  .seg.q { background: var(--q); }
-  .seg.m { background: var(--m); }
-  .seg.f { background: var(--f); }
-  .seg.b { background: var(--bfr); }
-  .key { display: flex; flex-wrap: wrap; gap: .35rem 1.1rem; font-size: .82rem;
-         color: var(--muted); margin: .6rem 0 0; }
-  .key i { display: inline-block; width: .62rem; height: .62rem; border-radius: .15rem;
-           margin-right: .35rem; vertical-align: baseline; }
-  .meta {
-    display: flex; flex-wrap: wrap; gap: .35rem 1.5rem; font-size: .86rem;
-    color: var(--muted); padding-bottom: .9rem; margin-bottom: .3rem;
-    border-bottom: 1px solid var(--line);
-  }
-  .meta code { color: var(--ink); }
-  code { font-family: var(--mono); font-size: .86em; }
-  .muted { color: var(--muted); }
-  .small { font-size: .84rem; color: var(--muted); }
-  h2 { font-size: 1.05rem; font-weight: 600; letter-spacing: -0.01em; margin: 3rem 0 .75rem; }
-  table { border-collapse: collapse; width: 100%; font-size: .87rem; }
-  th, td { text-align: left; padding: .45rem .7rem .45rem 0; border-bottom: 1px solid var(--line); vertical-align: top; }
-  th { font-weight: 600; color: var(--muted); font-size: .8rem; text-transform: uppercase; letter-spacing: .04em; }
-  td.num { text-align: right; font-family: var(--mono); font-size: .85rem; white-space: nowrap; }
-  table.rows { margin: .5rem 0; }
-  table.rows td:first-child { width: 45%; }
-  .scroll { overflow-x: auto; }
-  footer { margin-top: 3.5rem; padding-top: 1.5rem; border-top: 1px solid var(--line); font-size: .87rem; color: var(--muted); }
-  footer a { color: var(--accent); }
-  .spin { color: var(--muted); font-size: .9rem; }
-</style>
-</head>
-<body>
-<div class="wrap">
-<header>
-  <a class="brand" href="https://assert.gr" rel="noopener">
-    <img src="./assert-logo.png" alt="ASSERT" width="420" height="87">
-  </a>
-  <h1>How much of this pack is actually 4-bit?</h1>
-  <p>
-    A name like <code>W4A16</code> or <code>-AWQ-4bit</code> reads as though
-    everything in the file is four bits. It never is. Embeddings, the output
-    head, the norms and any preserved auxiliary head stay at the source's
-    precision — commonly a fifth to two fifths of the bytes — and no model page
-    says which, or how much.
-  </p>
-  <p>
-    <strong>The set matters more than the total.</strong> An <code>lm_head</code>
-    left whole is a deliberate, defensible cost. An <code>lm_head</code>
-    quantized is a decision the pack made on your behalf without mentioning it:
-    measured on our own weights, quantizing it flips the model's chosen token on
-    about a fifth of positions.
-  </p>
-  <p>
-    This reads <strong>safetensors headers only</strong>, over ranged requests
-    from your browser — a few hundred kilobytes against packs of many gigabytes.
-    It never loads the model and never runs it.
-  </p>
-</header>
-<form id="form">
-  <input type="text" id="repo" value="aleada/Nemotron-3.5-Lightning-30B-A3B-W4A16"
-         placeholder="owner/model" autocomplete="off" spellcheck="false"
-         aria-label="Model repo id">
-  <button type="submit" id="go">Inspect</button>
-</form>
-<div class="examples">
-  <span class="group">Different tools:</span>
-  <button type="button" data-ex="casperhansen/llama-3-8b-instruct-awq">AutoAWQ</button> ·
-  <button type="button" data-ex="TheBloke/Llama-2-7B-Chat-GPTQ">GPTQ</button> ·
-  <button type="button" data-ex="unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit">bitsandbytes</button> ·
-  <button type="button" data-ex="nvidia/Llama-3.3-70B-Instruct-FP4">ModelOpt&nbsp;NVFP4</button> ·
-  <button type="button" data-ex="openai/gpt-oss-20b">MXFP4</button>
-  <br>
-  <span class="group">Worth comparing:</span>
-  <button type="button" data-ex="cyankiwi/Qwen3-VL-8B-Instruct-AWQ-4bit">a pack whose name says AWQ</button> ·
-  <button type="button" data-ex="Qwen/Qwen2.5-0.5B-Instruct">an unquantized model</button>
-  <br>
-  <span class="group">Our packs:</span>
-  <button type="button" data-ex="aleada/Nemotron-3.5-Lightning-30B-A3B-W4A16">Nemotron-3.5</button> ·
-  <button type="button" data-ex="aleada/Qwen3.8-27B-W4A16">Qwen3.8-27B</button>
-</div>
-<div id="out"></div>
-<div class="key">
-  <span><i style="background:var(--q)"></i>quantized payload</span>
-  <span><i style="background:var(--m)"></i>quantization data</span>
-  <span><i style="background:var(--f)"></i>full precision</span>
-  <span><i style="background:var(--bfr)"></i>index buffers</span>
-</div>
-<h2>Why this reads dtypes, not tensor names</h2>
-<p>
-  The first version of this tool classified tensors by <em>name</em>, learned
-  from compressed-tensors packs where the payload is called
-  <code>weight_packed</code>. Probing nine toolchains showed that convention is
-  the minority. <strong>bitsandbytes, ModelOpt FP8, ModelOpt NVFP4 and
-  compressed-tensors' own <code>int-quantized</code> and
-  <code>naive-quantized</code> formats all store the quantized payload under the
-  plain name <code>weight</code></strong> — so a name-driven reader calls every
-  one of those packs 100% full precision, confidently, and about most of what is
-  published.
-</p>
-<p>
-  So the dtype decides: an <code>I32</code>, <code>I8</code>, <code>U8</code> or
-  <code>F8</code> tensor is not full precision whatever it is called. Names are
-  used only to separate quantization metadata — scales, zero points, group
-  indices — from model weights, a distinction that genuinely has no dtype
-  signature.
-</p>
-<p>
-  The declared method is read from <code>config.json</code>, or from
-  <code>hf_quant_config.json</code> where the tool writes it there — never from
-  the repo name. <code>cyankiwi/Qwen3-VL-8B-Instruct-<strong>AWQ</strong>-4bit</code>
-  declares <code>compressed-tensors</code>.
-</p>
-<h2>Conventions, and where each was verified</h2>
-<p>
-  None of these naming conventions is a stable public API — they are internal
-  choices of each tool, and they have moved before. Two versions therefore
-  appear, answering different questions: the <strong>producer's</strong>, read
-  out of the pack itself wherever that tool records it, which is the version
-  that actually wrote those bytes; and <strong>this reader's</strong>, the date
-  below, which says how stale the table is rather than leaving a wrong answer
-  looking authoritative.
-</p>
-<div class="scroll">
-<table>
-  <thead><tr><th>Declared as</th><th>Tool</th><th>Records its version in</th><th>Verified against</th></tr></thead>
-  <tbody id="formats"></tbody>
-</table>
-</div>
-<footer>
-  <p>
-    <strong>A high full-precision share is not a fault.</strong> It is usually
-    the pack being careful — an output head or a vision tower left whole costs
-    size and buys accuracy. This says what was kept and what it cost in bytes;
-    it does not say whether the trade was a good one.
-  </p>
-  <p>
-    Conventions verified <strong id="measured">—</strong> against one published
-    pack per tool, listed above. AutoAWQ's <code>version</code> field is
-    deliberately not reported as a tool version: it holds <code>gemm</code>, the
-    kernel variant. Packs that ship a <code>.pt</code> or <code>.bin</code>
-    instead of safetensors — torchao and HQQ commonly do — cannot be read from
-    metadata and are reported as unreadable rather than as unquantized. Gated
-    and private repos cannot be read.
-  </p>
-  <p>
-    Built from the tooling behind the
-    <a href="https://huggingface.co/aleada" rel="noopener">aleada</a> W4A16 packs.
-    See also the
-    <a href="https://huggingface.co/spaces/aleada/pack-integrity-check" rel="noopener">pack integrity checker</a>
-    and the
-    <a href="https://huggingface.co/spaces/aleada/reasoning-parser-advisor" rel="noopener">reasoning-parser advisor</a>.
-  </p>
-</footer>
-</div>
-<script type="module" src="./app.js"></script>
-</body>
-</html>

+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>How much of this pack is actually 4-bit?</title>
+<!-- The Space renders inside an iframe and huggingface.co sends
+     x-frame-options: DENY, so any link without a target tries to load a
+     refused page in the frame and reads as broken. -->
+<base target="_blank">
+<style>
+  :root {
+    --bg: #fbfbfa; --panel: #ffffff; --ink: #1a1a19; --muted: #6b6b66;
+    --line: #e4e3df; --accent: #3d5a80;
+    --problem: #a03030; --problem-bg: #fdf3f2;
+    --check: #8a6212; --check-bg: #fdf9ee;
+    --clear: #2f6b45; --clear-bg: #f1f8f3;
+    --q: #3d5a80; --m: #9a9790; --f: #b5793a; --bfr: #d9d6d0;
+    --mono: ui-monospace, "SF Mono", "Cascadia Mono", Menlo, monospace;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #16171a; --panel: #1d1f23; --ink: #e8e6e3; --muted: #9a978f;
+      --line: #2e3137; --accent: #8ab0d9;
+      --problem: #e08a86; --problem-bg: #2a1e1e;
+      --check: #d9b76a; --check-bg: #29241a;
+      --clear: #8fc9a6; --clear-bg: #1b2620;
+      --q: #7fa3cc; --m: #6f6c66; --f: #d19a5e; --bfr: #3a3d43;
+    }
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; background: var(--bg); color: var(--ink);
+    font: 16px/1.65 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif;
+    -webkit-font-smoothing: antialiased;
+  }
+  .wrap { max-width: 50rem; margin: 0 auto; padding: 3.5rem 1.25rem 5rem; }
+  .brand { display: inline-block; margin-bottom: 1.75rem; }
+  .brand img { height: 1.5rem; width: auto; display: block; filter: invert(1); opacity: .78; }
+  @media (prefers-color-scheme: dark) { .brand img { filter: none; opacity: .9; } }
+  header h1 {
+    font-size: clamp(1.6rem, 4.5vw, 2.2rem); line-height: 1.2;
+    letter-spacing: -0.02em; margin: 0 0 .75rem; font-weight: 620;
+  }
+  header p { color: var(--muted); margin: 0 0 .5rem; max-width: 42rem; }
+  form { display: flex; gap: .5rem; flex-wrap: wrap; margin: 2rem 0 .75rem; }
+  input[type=text] {
+    flex: 1 1 20rem; min-width: 0; padding: .7rem .85rem;
+    border: 1px solid var(--line); border-radius: .5rem;
+    background: var(--panel); color: var(--ink);
+    font: inherit; font-family: var(--mono); font-size: .92rem;
+  }
+  input[type=text]:focus { outline: 2px solid var(--accent); outline-offset: -1px; border-color: transparent; }
+  button {
+    padding: .7rem 1.4rem; border: 0; border-radius: .5rem;
+    background: var(--accent); color: #fff; font: inherit; font-weight: 560; cursor: pointer;
+  }
+  button:hover { filter: brightness(1.08); }
+  button:disabled { opacity: .55; cursor: progress; }
+  .examples { font-size: .86rem; color: var(--muted); margin-bottom: 2.5rem; line-height: 2; }
+  .examples .group { display: inline-block; min-width: 8.5rem; }
+  .examples button {
+    background: none; color: var(--accent); padding: 0 .15rem; font-size: .86rem;
+    font-family: var(--mono); text-decoration: underline; text-underline-offset: 2px; font-weight: 400;
+  }
+  .card {
+    background: var(--panel); border: 1px solid var(--line);
+    border-radius: .7rem; padding: 1.1rem 1.3rem; margin: .85rem 0;
+  }
+  .card h3 { margin: 0 0 .5rem; font-size: 1.02rem; font-weight: 600; }
+  .card h4 { margin: 1.4rem 0 .4rem; font-size: .85rem; font-weight: 600;
+             text-transform: uppercase; letter-spacing: .05em; color: var(--muted); }
+  .card p { margin: .5rem 0; }
+  .problem { border-left: 3px solid var(--problem); background: var(--problem-bg); }
+  .problem h3 { color: var(--problem); }
+  .check { border-left: 3px solid var(--check); background: var(--check-bg); }
+  .check h3 { color: var(--check); }
+  .clear { border-left: 3px solid var(--clear); background: var(--clear-bg); }
+  .clear h3 { color: var(--clear); }
+  .warn { color: var(--problem); }
+  .note { color: var(--muted); font-size: .92rem; }
+  .bar {
+    display: flex; height: 1.15rem; border-radius: .3rem; overflow: hidden;
+    margin: 1rem 0 .3rem; background: var(--line);
+  }
+  .seg { display: block; height: 100%; }
+  .seg + .seg { box-shadow: inset 2px 0 0 var(--panel); }
+  .seg.q { background: var(--q); }
+  .seg.m { background: var(--m); }
+  .seg.f { background: var(--f); }
+  .seg.b { background: var(--bfr); }
+  .key { display: flex; flex-wrap: wrap; gap: .35rem 1.1rem; font-size: .82rem;
+         color: var(--muted); margin: .6rem 0 0; }
+  .key i { display: inline-block; width: .62rem; height: .62rem; border-radius: .15rem;
+           margin-right: .35rem; vertical-align: baseline; }
+  .meta {
+    display: flex; flex-wrap: wrap; gap: .35rem 1.5rem; font-size: .86rem;
+    color: var(--muted); padding-bottom: .9rem; margin-bottom: .3rem;
+    border-bottom: 1px solid var(--line);
+  }
+  .meta code { color: var(--ink); }
+  code { font-family: var(--mono); font-size: .86em; }
+  .muted { color: var(--muted); }
+  .small { font-size: .84rem; color: var(--muted); }
+  h2 { font-size: 1.05rem; font-weight: 600; letter-spacing: -0.01em; margin: 3rem 0 .75rem; }
+  table { border-collapse: collapse; width: 100%; font-size: .87rem; }
+  th, td { text-align: left; padding: .45rem .7rem .45rem 0; border-bottom: 1px solid var(--line); vertical-align: top; }
+  th { font-weight: 600; color: var(--muted); font-size: .8rem; text-transform: uppercase; letter-spacing: .04em; }
+  td.num { text-align: right; font-family: var(--mono); font-size: .85rem; white-space: nowrap; }
+  table.rows { margin: .5rem 0; }
+  table.rows td:first-child { width: 45%; }
+  .scroll { overflow-x: auto; }
+  footer { margin-top: 3.5rem; padding-top: 1.5rem; border-top: 1px solid var(--line); font-size: .87rem; color: var(--muted); }
+  footer a { color: var(--accent); }
+  .spin { color: var(--muted); font-size: .9rem; }
+</style>
+</head>
+<body>
+<div class="wrap">
+<header>
+  <a class="brand" href="https://assert.gr" rel="noopener">
+    <img src="./assert-logo.png" alt="ASSERT" width="420" height="87">
+  </a>
+  <h1>How much of this pack is actually 4-bit?</h1>
+  <p>
+    A name like <code>W4A16</code> or <code>-AWQ-4bit</code> reads as though
+    everything in the file is four bits. It never is. Embeddings, the output
+    head, the norms and any preserved auxiliary head stay at the source's
+    precision — commonly a fifth to two fifths of the bytes — and no model page
+    says which, or how much.
+  </p>
+  <p>
+    <strong>The set matters more than the total.</strong> An <code>lm_head</code>
+    left whole is a deliberate, defensible cost. An <code>lm_head</code>
+    quantized is a decision the pack made on your behalf without mentioning it:
+    measured on our own weights, quantizing it flips the model's chosen token on
+    about a fifth of positions.
+  </p>
+  <p>
+    This reads <strong>safetensors headers only</strong>, over ranged requests
+    from your browser — a few hundred kilobytes against packs of many gigabytes.
+    It never loads the model and never runs it.
+  </p>
+</header>
+<form id="form">
+  <input type="text" id="repo" value="aleada/Nemotron-3.5-Lightning-30B-A3B-W4A16"
+         placeholder="owner/model" autocomplete="off" spellcheck="false"
+         aria-label="Model repo id">
+  <button type="submit" id="go">Inspect</button>
+</form>
+<div class="examples">
+  <span class="group">Different tools:</span>
+  <button type="button" data-ex="casperhansen/llama-3-8b-instruct-awq">AutoAWQ</button> ·
+  <button type="button" data-ex="TheBloke/Llama-2-7B-Chat-GPTQ">GPTQ</button> ·
+  <button type="button" data-ex="unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit">bitsandbytes</button> ·
+  <button type="button" data-ex="nvidia/Llama-3.3-70B-Instruct-FP4">ModelOpt&nbsp;NVFP4</button> ·
+  <button type="button" data-ex="openai/gpt-oss-20b">MXFP4</button>
+  <br>
+  <span class="group">Worth comparing:</span>
+  <button type="button" data-ex="cyankiwi/Qwen3-VL-8B-Instruct-AWQ-4bit">a pack whose name says AWQ</button> ·
+  <button type="button" data-ex="Qwen/Qwen2.5-0.5B-Instruct">an unquantized model</button>
+  <br>
+  <span class="group">Our packs:</span>
+  <button type="button" data-ex="aleada/Nemotron-3.5-Lightning-30B-A3B-W4A16">Nemotron-3.5</button> ·
+  <button type="button" data-ex="aleada/Qwen3.8-27B-W4A16">Qwen3.8-27B</button>
+</div>
+<div id="out"></div>
+<div class="key">
+  <span><i style="background:var(--q)"></i>quantized payload</span>
+  <span><i style="background:var(--m)"></i>quantization data</span>
+  <span><i style="background:var(--f)"></i>full precision</span>
+  <span><i style="background:var(--bfr)"></i>index buffers</span>
+</div>
+<h2>Why this reads dtypes, not tensor names</h2>
+<p>
+  The first version of this tool classified tensors by <em>name</em>, learned
+  from compressed-tensors packs where the payload is called
+  <code>weight_packed</code>. Probing nine toolchains showed that convention is
+  the minority. <strong>bitsandbytes, ModelOpt FP8, ModelOpt NVFP4 and
+  compressed-tensors' own <code>int-quantized</code> and
+  <code>naive-quantized</code> formats all store the quantized payload under the
+  plain name <code>weight</code></strong> — so a name-driven reader calls every
+  one of those packs 100% full precision, confidently, and about most of what is
+  published.
+</p>
+<p>
+  So the dtype decides: an <code>I32</code>, <code>I8</code>, <code>U8</code> or
+  <code>F8</code> tensor is not full precision whatever it is called. Names are
+  used only to separate quantization metadata — scales, zero points, group
+  indices — from model weights, a distinction that genuinely has no dtype
+  signature.
+</p>
+<p>
+  The declared method is read from <code>config.json</code>, or from
+  <code>hf_quant_config.json</code> where the tool writes it there — never from
+  the repo name. <code>cyankiwi/Qwen3-VL-8B-Instruct-<strong>AWQ</strong>-4bit</code>
+  declares <code>compressed-tensors</code>.
+</p>
+<h2>Conventions, and where each was verified</h2>
+<p>
+  None of these naming conventions is a stable public API — they are internal
+  choices of each tool, and they have moved before. Two versions therefore
+  appear, answering different questions: the <strong>producer's</strong>, read
+  out of the pack itself wherever that tool records it, which is the version
+  that actually wrote those bytes; and <strong>this reader's</strong>, the date
+  below, which says how stale the table is rather than leaving a wrong answer
+  looking authoritative.
+</p>
+<div class="scroll">
+<table>
+  <thead><tr><th>Declared as</th><th>Tool</th><th>Records its version in</th><th>Verified against</th></tr></thead>
+  <tbody id="formats"></tbody>
+</table>
+</div>
+<footer>
+  <p>
+    <strong>A high full-precision share is not a fault.</strong> It is usually
+    the pack being careful — an output head or a vision tower left whole costs
+    size and buys accuracy. This says what was kept and what it cost in bytes;
+    it does not say whether the trade was a good one.
+  </p>
+  <p>
+    Conventions verified <strong id="measured">—</strong> against one published
+    pack per tool, listed above. AutoAWQ's <code>version</code> field is
+    deliberately not reported as a tool version: it holds <code>gemm</code>, the
+    kernel variant. Packs that ship a <code>.pt</code> or <code>.bin</code>
+    instead of safetensors — torchao and HQQ commonly do — cannot be read from
+    metadata and are reported as unreadable rather than as unquantized. Gated
+    and private repos cannot be read.
+  </p>
+  <p>
+    Built from the tooling behind the
+    <a href="https://huggingface.co/aleada" rel="noopener">aleada</a> W4A16 packs.
+    See also the <a href="https://huggingface.co/spaces/aleada/pack-integrity-check" rel="noopener">pack integrity checker</a>, the <a href="https://huggingface.co/spaces/aleada/reasoning-parser-advisor" rel="noopener">reasoning-parser advisor</a> and the <a href="https://huggingface.co/spaces/aleada/model-search-that-answers" rel="noopener">model search</a>.
+  </p>
+</footer>
+</div>
+<script type="module" src="./app.js"></script>
+</body>
+</html>

precision_map.js CHANGED Viewed

@@ -1,384 +1,390 @@
-/**
- * What precision a pack is actually in — the browser half.
- *
- * The JavaScript port of `tools/quantize/precision_map.py`. Both are held
- * together by `parity.mjs`, which runs real tensor names harvested from
- * nine toolchains through each and diffs. The rules took a wrong answer
- * to get right, and a port that drifted from them would bring it back
- * silently.
- *
- * The wrong answer is worth stating, because it is the whole reason this
- * file classifies the way it does. The first version keyed on tensor
- * NAMES, learned from compressed-tensors packs where the payload is
- * called `weight_packed`. Probing the ecosystem showed that convention is
- * the minority: bitsandbytes, ModelOpt FP8, ModelOpt NVFP4 and
- * compressed-tensors' own int-quantized and naive-quantized formats all
- * store the quantized payload under the plain name `weight`. A
- * name-driven reader reports every one of those packs as 100% full
- * precision — confidently, and about most of what is published.
- *
- * So dtype is the primary evidence here. Names are used only to separate
- * quantization metadata from model weights, a distinction that genuinely
- * has no dtype signature.
- */
-/** Bytes per element, keyed by the safetensors dtype string. */
-export const DTYPE_BYTES = {
-  BF16: 2, F16: 2, F32: 4, F64: 8, F8_E4M3: 1, F8_E5M2: 1, F4: 1,
-  I8: 1, U8: 1, I16: 2, I32: 4, I64: 8, BOOL: 1,
-};
-/**
- * A tensor in one of these dtypes is carrying quantized payload. Every
- * packing scheme measured lands here: compressed-tensors packs into I32,
- * GPTQ/AWQ/AutoRound into I32, bitsandbytes and MXFP4 and NVFP4 into U8,
- * FP8 into F8_E4M3, int8 into I8.
- */
-export const PAYLOAD_DTYPES = new Set(
-  ['I32', 'I8', 'U8', 'F8_E4M3', 'F8_E5M2', 'F4', 'I16']);
-/**
- * Excluded on purpose: index buffers and masks (`position_ids`, causal
- * masks, `weight_shape`), never packed weights.
- */
-export const BUFFER_DTYPES = new Set(['I64', 'BOOL']);
-/**
- * Quantization metadata: scales, zero points, group permutations, the
- * stored original shape. Real bytes, reported as their own category —
- * counting them as full precision would overstate what stayed whole, and
- * counting them as payload would hide the overhead.
- *
- * One union across all toolchains rather than a table per format: these
- * names do not collide, so a reader that misidentifies the format still
- * gets the metadata right.
- */
-export const METADATA_SUFFIXES = [
-  // compressed-tensors
-  'weight_scale', 'weight_shape', 'weight_zero_point', 'weight_g_idx',
-  'input_scale', 'output_scale',
-  // gptq / awq / autoround
-  'qzeros', 'scales', 'g_idx',
-  // bitsandbytes — double quantization, so the scales are themselves quantized
-  'absmax', 'quant_map', 'nested_absmax', 'nested_quant_map',
-  'quant_state.bitsandbytes__nf4', 'quant_state.bitsandbytes__fp4',
-  // ModelOpt / native fp8 + fp4
-  'weight_scale_2', 'k_scale', 'v_scale', 'q_scale', 'prob_scale',
-  // mxfp4
-  '_scales',
-];
-/** Formats that give the payload its own name; the rest reuse `weight`. */
-export const PAYLOAD_SUFFIXES = ['weight_packed', 'qweight', '_blocks'];
-/**
- * Every format here was verified by reading a real published pack of it.
- *
- * `producer` says where that pack records the version of the tool that
- * wrote it, and `null` means the tool records nothing — which is worth
- * reporting rather than hiding, since it tells the reader no version
- * evidence exists for those bytes.
- *
- * AutoAWQ is deliberately `null` even though its config has a `version`
- * field: that field holds `"gemm"`, the kernel variant. Printing it as a
- * release number would be a small invented fact.
- */
-export const FORMATS = {
-  'compressed-tensors': {
-    tool: 'llm-compressor / compressed-tensors',
-    producer: ['config', 'version'],
-    verifiedOn: 'aleada/Qwen3.8-27B-W4A16 (0.17.1), RedHatAI w8a8, RedHatAI FP8',
-    note: 'pack-quantized names the payload weight_packed; int-quantized and naive-quantized reuse `weight`',
-  },
-  gptq: {
-    tool: 'GPTQModel / AutoGPTQ',
-    producer: ['config', 'meta.quantizer'],
-    verifiedOn: 'ModelCloud vortex-v3 (gptqmodel:1.4.4), TheBloke/Llama-2-7B-Chat-GPTQ',
-    note: 'qweight + qzeros + scales + g_idx',
-  },
-  awq: {
-    tool: 'AutoAWQ',
-    producer: null,
-    verifiedOn: 'casperhansen/llama-3-8b-instruct-awq, Qwen/Qwen3-8B-AWQ',
-    note: 'qweight + qzeros + scales, no g_idx',
-  },
-  'auto-round': {
-    tool: 'Intel AutoRound',
-    producer: ['config', 'autoround_version'],
-    verifiedOn: 'OPEA/Qwen2.5-7B-Instruct-int4-sym-inc (0.4.0.dev)',
-    note: 'exports in gptq or compressed-tensors layout',
-  },
-  'intel/auto-round': {
-    tool: 'Intel AutoRound',
-    producer: ['config', 'autoround_version'],
-    verifiedOn: 'Intel/Qwen2-7B-int4-inc',
-    note: 'same layout, older method spelling',
-  },
-  bitsandbytes: {
-    tool: 'bitsandbytes',
-    producer: null,
-    verifiedOn: 'unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit',
-    note: 'payload is U8 under the plain name `weight`; absmax/quant_map are the scales',
-  },
-  mxfp4: {
-    tool: 'MXFP4 (native export)',
-    producer: null,
-    verifiedOn: 'openai/gpt-oss-20b',
-    note: '*_blocks payload + *_scales, per fused expert tensor',
-  },
-  modelopt: {
-    tool: 'NVIDIA TensorRT ModelOpt',
-    producer: ['hf_quant_config', 'producer.version'],
-    verifiedOn: 'nvidia/Llama-3.3-70B-Instruct-FP4 (0.23.0), nvidia/Llama-3.1-8B-Instruct-FP8',
-    note: 'config.json declares nothing — the method lives in hf_quant_config.json',
-  },
-};
-export const RULES_MEASURED_ON = '2026-09-07';
-/**
- * Which module a full-precision tensor belongs to. Ordered: the first
- * match wins, so specific patterns precede general ones.
- */
-export const FAMILIES = [
-  [/(^|\.)mtp\.|(^|\.)draft/, 'auxiliary head (MTP / draft)'],
-  [/(^|\.)(lm_head|output_layer)\b/, 'output head (lm_head)'],
-  [/embed|embeddings?\b|wte\b/, 'embeddings'],
-  [/vision_tower|vision_model|visual|image_encoder|patch_embed/, 'vision tower'],
-  [/multi_modal_projector|mm_projector|merger/, 'multimodal projector'],
-  [/norm|layernorm|rmsnorm/, 'norms'],
-  [/A_log|dt_bias|conv1d|\.D$/, 'state-space parameters'],
-  [/(^|\.)(gate|router)\b|e_score_correction|sinks/, 'routers and sinks'],
-  [/rotary|inv_freq|position/, 'position buffers'],
-  [/\.bias$/, 'biases'],
-  [/experts?\./, 'experts (left unquantized)'],
-];
-const HEAD_RE = /lm_head|output_layer/;
-/**
- * quantized | metadata | full | buffer.
- *
- * Name first, but only to pull metadata out — a scale is a scale whatever
- * its dtype. Then dtype, which is what actually decides whether a tensor
- * holds full-precision weights.
- */
-export function classify(name, dtype) {
-  for (const suf of METADATA_SUFFIXES) if (name.endsWith(suf)) return 'metadata';
-  for (const suf of PAYLOAD_SUFFIXES) if (name.endsWith(suf)) return 'quantized';
-  if (BUFFER_DTYPES.has(dtype)) return 'buffer';
-  if (PAYLOAD_DTYPES.has(dtype)) return 'quantized';
-  return 'full';
-}
-export function family(name) {
-  for (const [pattern, label] of FAMILIES) if (pattern.test(name)) return label;
-  return 'other linear weights';
-}
-/**
- * `meta.quantizer` out of a nested object, tolerating a list value:
- * GPTQModel writes that field as a bare string in some releases and a
- * one-element array in others, and both are in the wild.
- */
-export function dig(obj, path) {
-  let cur = obj;
-  for (const part of path.split('.')) {
-    if (cur === null || typeof cur !== 'object' || Array.isArray(cur)) return null;
-    cur = cur[part];
-    if (cur === undefined) return null;
-  }
-  if (Array.isArray(cur)) return cur.length ? cur.map(String).join(', ') : null;
-  return cur === undefined ? null : cur;
-}
-/**
- * The quantization method, from wherever the tool chose to record it.
- *
- * Never from the repo name: `cyankiwi/Qwen3-VL-8B-Instruct-AWQ-4bit`
- * declares `compressed-tensors`, and a reader that trusted the name would
- * apply the wrong convention to it.
- */
-export function declaredMethod(cfg, hfQuant) {
-  let q = cfg?.quantization_config;
-  if (!q && cfg?.text_config && typeof cfg.text_config === 'object') {
-    q = cfg.text_config.quantization_config;
-  }
-  const m = q?.quant_method;
-  if (m) return String(m);
-  if (hfQuant) return 'modelopt';
-  return 'none';
-}
-/**
- * Fold a list of `{name, dtype, shape}` into the report.
- *
- * Split out from any fetching so the parity gate can run it on fixtures
- * and so the same arithmetic serves whichever transport reads the header.
- */
-export function summarize(tensors, method) {
-  const spec = FORMATS[method] || null;
-  const buckets = { quantized: 0, metadata: 0, full: 0, buffer: 0 };
-  const families = {};
-  const dtypeBytes = {};
-  const unknownDtypes = new Set();
-  let headQuantized = false;
-  for (const t of tensors) {
-    if (!(t.dtype in DTYPE_BYTES)) unknownDtypes.add(t.dtype);
-    let n = 1;
-    for (const d of t.shape) n *= d;
-    const size = n * (DTYPE_BYTES[t.dtype] ?? 2);
-    const kind = classify(t.name, t.dtype);
-    buckets[kind] += size;
-    dtypeBytes[t.dtype] = (dtypeBytes[t.dtype] || 0) + size;
-    if (kind === 'full') {
-      const fam = family(t.name);
-      families[fam] = (families[fam] || 0) + size;
-    } else if (kind === 'quantized' && HEAD_RE.test(t.name)) {
-      headQuantized = true;
-    }
-  }
-  const total = Object.values(buckets).reduce((a, b) => a + b, 0) || 1;
-  // Largest first, ties broken by name. The tie is not hypothetical: an
-  // untied model's embeddings and output head are the same tensor
-  // transposed, so their byte counts are equal exactly. Shards are read
-  // concurrently, so without the second key those two rows would swap
-  // between runs of the same pack — and a report that changes when
-  // nothing changed is a report nobody can quote.
-  //
-  // Compared by code point, not localeCompare: Python's `sorted` orders
-  // by code point, and a locale-aware comparison disagrees with it on
-  // case and punctuation. The parity gate can only catch that when a
-  // fixture happens to contain a tie, so the two are made to agree by
-  // construction instead of by luck.
-  const byName = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
-  const sortDesc = (o) => Object.fromEntries(
-    Object.entries(o).sort((a, b) => b[1] - a[1] || byName(a[0], b[0])));
-  return {
-    method,
-    tool: spec ? spec.tool : null,
-    verifiedOn: spec ? spec.verifiedOn : null,
-    note: spec ? spec.note : null,
-    totalBytes: total,
-    buckets,
-    dtypeBytes: sortDesc(dtypeBytes),
-    fullByFamily: sortDesc(families),
-    fullPct: (buckets.full / total) * 100,
-    headQuantized,
-    unknownDtypes: [...unknownDtypes].sort(),
-    // A declared method with no payload found means this reader does not
-    // understand that tool's layout — not that the pack is unquantized.
-    // Saying so is the one guard that keeps a future convention change
-    // from producing a confident wrong answer.
-    recognised: buckets.quantized > 0 || method === 'none',
-    knownFormat: spec !== null || method === 'none',
-  };
-}
-// ------------------------------------------------------------- transport
-const HF = 'https://huggingface.co';
-async function json(url) {
-  const r = await fetch(url);
-  if (!r.ok) return null;
-  try { return await r.json(); } catch { return null; }
-}
-/**
- * Read one safetensors file's header without downloading the file.
- *
- * The format opens with a little-endian u64 giving the header length,
- * then that many bytes of JSON describing every tensor. Two ranged
- * requests fetch it — typically a few hundred kilobytes against shards
- * of many gigabytes, which is what makes this possible from a browser
- * at all.
- */
-export async function readHeader(repoId, file) {
-  const url = `${HF}/${repoId}/resolve/main/${file}`;
-  const head = await fetch(url, { headers: { Range: 'bytes=0-7' } });
-  if (!head.ok) throw new Error(`cannot read ${file} (HTTP ${head.status})`);
-  const len = Number(new DataView(await head.arrayBuffer()).getBigUint64(0, true));
-  if (!Number.isFinite(len) || len <= 0 || len > 200_000_000) {
-    throw new Error(`${file} does not look like a safetensors file`);
-  }
-  const body = await fetch(url, { headers: { Range: `bytes=8-${7 + len}` } });
-  if (!body.ok) throw new Error(`cannot read ${file} header (HTTP ${body.status})`);
-  const parsed = JSON.parse(new TextDecoder().decode(await body.arrayBuffer()));
-  const tensors = [];
-  for (const [name, info] of Object.entries(parsed)) {
-    if (name === '__metadata__') continue;
-    tensors.push({ name, dtype: info.dtype, shape: info.shape || [] });
-  }
-  return tensors;
-}
-/** Which safetensors files a repo publishes, sharded or not. */
-export async function shardList(repoId) {
-  const index = await json(`${HF}/${repoId}/resolve/main/model.safetensors.index.json`);
-  if (index?.weight_map) return [...new Set(Object.values(index.weight_map))];
-  const head = await fetch(`${HF}/${repoId}/resolve/main/model.safetensors`,
-    { headers: { Range: 'bytes=0-7' } });
-  if (head.ok) return ['model.safetensors'];
-  return [];
-}
-/** Everything the page needs about one repo. */
-export async function inspect(repoId, onProgress = () => {}) {
-  const cfg = await json(`${HF}/${repoId}/resolve/main/config.json`);
-  if (!cfg) throw new Error('no config.json — gated, private, or not a model repo');
-  const hfQuant = await json(`${HF}/${repoId}/resolve/main/hf_quant_config.json`);
-  const method = declaredMethod(cfg, hfQuant);
-  let producerVersion = null;
-  const spec = FORMATS[method];
-  if (spec?.producer) {
-    const [where, path] = spec.producer;
-    const src = where === 'config' ? (cfg.quantization_config || {}) : (hfQuant || {});
-    const v = dig(src, path);
-    producerVersion = v === null || v === undefined ? null : String(v);
-  }
-  const files = await shardList(repoId);
-  if (!files.length) {
-    // A pack whose weights are a .pt or .bin cannot be read this way, and
-    // must not be reported as unquantized.
-    throw new Error('no safetensors weights published — torchao and HQQ '
-      + 'packs often ship a .pt instead, and their contents cannot be read '
-      + 'from metadata');
-  }
-  onProgress(0, files.length);
-  // Read the shards a few at a time rather than one after another. A
-  // 70B pack is nine shards and two ranged requests each; sequentially
-  // that is long enough that the page reads as broken. Four at a time
-  // is enough to hide most of the latency without opening a burst of
-  // connections against the Hub for a page that is only reading
-  // metadata.
-  const tensors = [];
-  let next = 0;
-  let finished = 0;
-  const worker = async () => {
-    while (next < files.length) {
-      const mine = files[next++];
-      const got = await readHeader(repoId, mine);
-      tensors.push(...got);
-      onProgress(++finished, files.length);
-    }
-  };
-  await Promise.all(
-    Array.from({ length: Math.min(4, files.length) }, worker));
-  return {
-    repo: repoId,
-    producerVersion,
-    shards: files.length,
-    tensorCount: tensors.length,
-    ...summarize(tensors, method),
-  };
-}

+/**
+ * What precision a pack is actually in — the browser half.
+ *
+ * The JavaScript port of `tools/quantize/precision_map.py`. Both are held
+ * together by `parity.mjs`, which runs real tensor names harvested from
+ * nine toolchains through each and diffs. The rules took a wrong answer
+ * to get right, and a port that drifted from them would bring it back
+ * silently.
+ *
+ * The wrong answer is worth stating, because it is the whole reason this
+ * file classifies the way it does. The first version keyed on tensor
+ * NAMES, learned from compressed-tensors packs where the payload is
+ * called `weight_packed`. Probing the ecosystem showed that convention is
+ * the minority: bitsandbytes, ModelOpt FP8, ModelOpt NVFP4 and
+ * compressed-tensors' own int-quantized and naive-quantized formats all
+ * store the quantized payload under the plain name `weight`. A
+ * name-driven reader reports every one of those packs as 100% full
+ * precision — confidently, and about most of what is published.
+ *
+ * So dtype is the primary evidence here. Names are used only to separate
+ * quantization metadata from model weights, a distinction that genuinely
+ * has no dtype signature.
+ */
+/** Bytes per element, keyed by the safetensors dtype string. */
+export const DTYPE_BYTES = {
+  BF16: 2, F16: 2, F32: 4, F64: 8, F8_E4M3: 1, F8_E5M2: 1, F4: 1,
+  I8: 1, U8: 1, I16: 2, I32: 4, I64: 8, BOOL: 1,
+};
+/**
+ * A tensor in one of these dtypes is carrying quantized payload. Every
+ * packing scheme measured lands here: compressed-tensors packs into I32,
+ * GPTQ/AWQ/AutoRound into I32, bitsandbytes and MXFP4 and NVFP4 into U8,
+ * FP8 into F8_E4M3, int8 into I8.
+ */
+export const PAYLOAD_DTYPES = new Set(
+  ['I32', 'I8', 'U8', 'F8_E4M3', 'F8_E5M2', 'F4', 'I16']);
+/**
+ * Excluded on purpose: index buffers and masks (`position_ids`, causal
+ * masks, `weight_shape`), never packed weights.
+ */
+export const BUFFER_DTYPES = new Set(['I64', 'BOOL']);
+/**
+ * Quantization metadata: scales, zero points, group permutations, the
+ * stored original shape. Real bytes, reported as their own category —
+ * counting them as full precision would overstate what stayed whole, and
+ * counting them as payload would hide the overhead.
+ *
+ * One union across all toolchains rather than a table per format: these
+ * names do not collide, so a reader that misidentifies the format still
+ * gets the metadata right.
+ */
+export const METADATA_SUFFIXES = [
+  // compressed-tensors
+  'weight_scale', 'weight_shape', 'weight_zero_point', 'weight_g_idx',
+  'input_scale', 'output_scale',
+  // gptq / awq / autoround
+  'qzeros', 'scales', 'g_idx',
+  // bitsandbytes — double quantization, so the scales are themselves quantized
+  'absmax', 'quant_map', 'nested_absmax', 'nested_quant_map',
+  'quant_state.bitsandbytes__nf4', 'quant_state.bitsandbytes__fp4',
+  // ModelOpt / native fp8 + fp4
+  'weight_scale_2', 'k_scale', 'v_scale', 'q_scale', 'prob_scale',
+  // mxfp4
+  '_scales',
+];
+/** Formats that give the payload its own name; the rest reuse `weight`. */
+export const PAYLOAD_SUFFIXES = ['weight_packed', 'qweight', '_blocks'];
+/**
+ * Every format here was verified by reading a real published pack of it.
+ *
+ * `producer` says where that pack records the version of the tool that
+ * wrote it, and `null` means the tool records nothing — which is worth
+ * reporting rather than hiding, since it tells the reader no version
+ * evidence exists for those bytes.
+ *
+ * AutoAWQ is deliberately `null` even though its config has a `version`
+ * field: that field holds `"gemm"`, the kernel variant. Printing it as a
+ * release number would be a small invented fact.
+ */
+export const FORMATS = {
+  'compressed-tensors': {
+    tool: 'llm-compressor / compressed-tensors',
+    producer: ['config', 'version'],
+    verifiedOn: 'aleada/Qwen3.8-27B-W4A16 (0.17.1), RedHatAI w8a8, RedHatAI FP8',
+    note: 'pack-quantized names the payload weight_packed; int-quantized and naive-quantized reuse `weight`',
+  },
+  gptq: {
+    tool: 'GPTQModel / AutoGPTQ',
+    producer: ['config', 'meta.quantizer'],
+    verifiedOn: 'ModelCloud vortex-v3 (gptqmodel:1.4.4), TheBloke/Llama-2-7B-Chat-GPTQ',
+    note: 'qweight + qzeros + scales + g_idx',
+  },
+  awq: {
+    tool: 'AutoAWQ',
+    producer: null,
+    verifiedOn: 'casperhansen/llama-3-8b-instruct-awq, Qwen/Qwen3-8B-AWQ',
+    note: 'qweight + qzeros + scales, no g_idx',
+  },
+  'auto-round': {
+    tool: 'Intel AutoRound',
+    producer: ['config', 'autoround_version'],
+    verifiedOn: 'OPEA/Qwen2.5-7B-Instruct-int4-sym-inc (0.4.0.dev)',
+    note: 'exports in gptq or compressed-tensors layout',
+  },
+  'intel/auto-round': {
+    tool: 'Intel AutoRound',
+    producer: ['config', 'autoround_version'],
+    verifiedOn: 'Intel/Qwen2-7B-int4-inc',
+    note: 'same layout, older method spelling',
+  },
+  bitsandbytes: {
+    tool: 'bitsandbytes',
+    producer: null,
+    verifiedOn: 'unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit',
+    note: 'payload is U8 under the plain name `weight`; absmax/quant_map are the scales',
+  },
+  mxfp4: {
+    tool: 'MXFP4 (native export)',
+    producer: null,
+    verifiedOn: 'openai/gpt-oss-20b',
+    note: '*_blocks payload + *_scales, per fused expert tensor',
+  },
+  quark: {
+    tool: 'AMD Quark',
+    producer: null,
+    verifiedOn: 'amd/Qwen3.8-27B-Quark-AWQ-INT4-W4A16',
+    note: 'payload is `weight` at I32, with weight_scale and an I32 weight_zero_point',
+  },
+  modelopt: {
+    tool: 'NVIDIA TensorRT ModelOpt',
+    producer: ['hf_quant_config', 'producer.version'],
+    verifiedOn: 'nvidia/Llama-3.3-70B-Instruct-FP4 (0.23.0), nvidia/Llama-3.1-8B-Instruct-FP8',
+    note: 'config.json declares nothing — the method lives in hf_quant_config.json',
+  },
+};
+export const RULES_MEASURED_ON = '2026-09-07';
+/**
+ * Which module a full-precision tensor belongs to. Ordered: the first
+ * match wins, so specific patterns precede general ones.
+ */
+export const FAMILIES = [
+  [/(^|\.)mtp\.|(^|\.)draft/, 'auxiliary head (MTP / draft)'],
+  [/(^|\.)(lm_head|output_layer)\b/, 'output head (lm_head)'],
+  [/embed|embeddings?\b|wte\b/, 'embeddings'],
+  [/vision_tower|vision_model|visual|image_encoder|patch_embed/, 'vision tower'],
+  [/multi_modal_projector|mm_projector|merger/, 'multimodal projector'],
+  [/norm|layernorm|rmsnorm/, 'norms'],
+  [/A_log|dt_bias|conv1d|\.D$/, 'state-space parameters'],
+  [/(^|\.)(gate|router)\b|e_score_correction|sinks/, 'routers and sinks'],
+  [/rotary|inv_freq|position/, 'position buffers'],
+  [/\.bias$/, 'biases'],
+  [/experts?\./, 'experts (left unquantized)'],
+];
+const HEAD_RE = /lm_head|output_layer/;
+/**
+ * quantized | metadata | full | buffer.
+ *
+ * Name first, but only to pull metadata out — a scale is a scale whatever
+ * its dtype. Then dtype, which is what actually decides whether a tensor
+ * holds full-precision weights.
+ */
+export function classify(name, dtype) {
+  for (const suf of METADATA_SUFFIXES) if (name.endsWith(suf)) return 'metadata';
+  for (const suf of PAYLOAD_SUFFIXES) if (name.endsWith(suf)) return 'quantized';
+  if (BUFFER_DTYPES.has(dtype)) return 'buffer';
+  if (PAYLOAD_DTYPES.has(dtype)) return 'quantized';
+  return 'full';
+}
+export function family(name) {
+  for (const [pattern, label] of FAMILIES) if (pattern.test(name)) return label;
+  return 'other linear weights';
+}
+/**
+ * `meta.quantizer` out of a nested object, tolerating a list value:
+ * GPTQModel writes that field as a bare string in some releases and a
+ * one-element array in others, and both are in the wild.
+ */
+export function dig(obj, path) {
+  let cur = obj;
+  for (const part of path.split('.')) {
+    if (cur === null || typeof cur !== 'object' || Array.isArray(cur)) return null;
+    cur = cur[part];
+    if (cur === undefined) return null;
+  }
+  if (Array.isArray(cur)) return cur.length ? cur.map(String).join(', ') : null;
+  return cur === undefined ? null : cur;
+}
+/**
+ * The quantization method, from wherever the tool chose to record it.
+ *
+ * Never from the repo name: `cyankiwi/Qwen3-VL-8B-Instruct-AWQ-4bit`
+ * declares `compressed-tensors`, and a reader that trusted the name would
+ * apply the wrong convention to it.
+ */
+export function declaredMethod(cfg, hfQuant) {
+  let q = cfg?.quantization_config;
+  if (!q && cfg?.text_config && typeof cfg.text_config === 'object') {
+    q = cfg.text_config.quantization_config;
+  }
+  const m = q?.quant_method;
+  if (m) return String(m);
+  if (hfQuant) return 'modelopt';
+  return 'none';
+}
+/**
+ * Fold a list of `{name, dtype, shape}` into the report.
+ *
+ * Split out from any fetching so the parity gate can run it on fixtures
+ * and so the same arithmetic serves whichever transport reads the header.
+ */
+export function summarize(tensors, method) {
+  const spec = FORMATS[method] || null;
+  const buckets = { quantized: 0, metadata: 0, full: 0, buffer: 0 };
+  const families = {};
+  const dtypeBytes = {};
+  const unknownDtypes = new Set();
+  let headQuantized = false;
+  for (const t of tensors) {
+    if (!(t.dtype in DTYPE_BYTES)) unknownDtypes.add(t.dtype);
+    let n = 1;
+    for (const d of t.shape) n *= d;
+    const size = n * (DTYPE_BYTES[t.dtype] ?? 2);
+    const kind = classify(t.name, t.dtype);
+    buckets[kind] += size;
+    dtypeBytes[t.dtype] = (dtypeBytes[t.dtype] || 0) + size;
+    if (kind === 'full') {
+      const fam = family(t.name);
+      families[fam] = (families[fam] || 0) + size;
+    } else if (kind === 'quantized' && HEAD_RE.test(t.name)) {
+      headQuantized = true;
+    }
+  }
+  const total = Object.values(buckets).reduce((a, b) => a + b, 0) || 1;
+  // Largest first, ties broken by name. The tie is not hypothetical: an
+  // untied model's embeddings and output head are the same tensor
+  // transposed, so their byte counts are equal exactly. Shards are read
+  // concurrently, so without the second key those two rows would swap
+  // between runs of the same pack — and a report that changes when
+  // nothing changed is a report nobody can quote.
+  //
+  // Compared by code point, not localeCompare: Python's `sorted` orders
+  // by code point, and a locale-aware comparison disagrees with it on
+  // case and punctuation. The parity gate can only catch that when a
+  // fixture happens to contain a tie, so the two are made to agree by
+  // construction instead of by luck.
+  const byName = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+  const sortDesc = (o) => Object.fromEntries(
+    Object.entries(o).sort((a, b) => b[1] - a[1] || byName(a[0], b[0])));
+  return {
+    method,
+    tool: spec ? spec.tool : null,
+    verifiedOn: spec ? spec.verifiedOn : null,
+    note: spec ? spec.note : null,
+    totalBytes: total,
+    buckets,
+    dtypeBytes: sortDesc(dtypeBytes),
+    fullByFamily: sortDesc(families),
+    fullPct: (buckets.full / total) * 100,
+    headQuantized,
+    unknownDtypes: [...unknownDtypes].sort(),
+    // A declared method with no payload found means this reader does not
+    // understand that tool's layout — not that the pack is unquantized.
+    // Saying so is the one guard that keeps a future convention change
+    // from producing a confident wrong answer.
+    recognised: buckets.quantized > 0 || method === 'none',
+    knownFormat: spec !== null || method === 'none',
+  };
+}
+// ------------------------------------------------------------- transport
+const HF = 'https://huggingface.co';
+async function json(url) {
+  const r = await fetch(url);
+  if (!r.ok) return null;
+  try { return await r.json(); } catch { return null; }
+}
+/**
+ * Read one safetensors file's header without downloading the file.
+ *
+ * The format opens with a little-endian u64 giving the header length,
+ * then that many bytes of JSON describing every tensor. Two ranged
+ * requests fetch it — typically a few hundred kilobytes against shards
+ * of many gigabytes, which is what makes this possible from a browser
+ * at all.
+ */
+export async function readHeader(repoId, file) {
+  const url = `${HF}/${repoId}/resolve/main/${file}`;
+  const head = await fetch(url, { headers: { Range: 'bytes=0-7' } });
+  if (!head.ok) throw new Error(`cannot read ${file} (HTTP ${head.status})`);
+  const len = Number(new DataView(await head.arrayBuffer()).getBigUint64(0, true));
+  if (!Number.isFinite(len) || len <= 0 || len > 200_000_000) {
+    throw new Error(`${file} does not look like a safetensors file`);
+  }
+  const body = await fetch(url, { headers: { Range: `bytes=8-${7 + len}` } });
+  if (!body.ok) throw new Error(`cannot read ${file} header (HTTP ${body.status})`);
+  const parsed = JSON.parse(new TextDecoder().decode(await body.arrayBuffer()));
+  const tensors = [];
+  for (const [name, info] of Object.entries(parsed)) {
+    if (name === '__metadata__') continue;
+    tensors.push({ name, dtype: info.dtype, shape: info.shape || [] });
+  }
+  return tensors;
+}
+/** Which safetensors files a repo publishes, sharded or not. */
+export async function shardList(repoId) {
+  const index = await json(`${HF}/${repoId}/resolve/main/model.safetensors.index.json`);
+  if (index?.weight_map) return [...new Set(Object.values(index.weight_map))];
+  const head = await fetch(`${HF}/${repoId}/resolve/main/model.safetensors`,
+    { headers: { Range: 'bytes=0-7' } });
+  if (head.ok) return ['model.safetensors'];
+  return [];
+}
+/** Everything the page needs about one repo. */
+export async function inspect(repoId, onProgress = () => {}) {
+  const cfg = await json(`${HF}/${repoId}/resolve/main/config.json`);
+  if (!cfg) throw new Error('no config.json — gated, private, or not a model repo');
+  const hfQuant = await json(`${HF}/${repoId}/resolve/main/hf_quant_config.json`);
+  const method = declaredMethod(cfg, hfQuant);
+  let producerVersion = null;
+  const spec = FORMATS[method];
+  if (spec?.producer) {
+    const [where, path] = spec.producer;
+    const src = where === 'config' ? (cfg.quantization_config || {}) : (hfQuant || {});
+    const v = dig(src, path);
+    producerVersion = v === null || v === undefined ? null : String(v);
+  }
+  const files = await shardList(repoId);
+  if (!files.length) {
+    // A pack whose weights are a .pt or .bin cannot be read this way, and
+    // must not be reported as unquantized.
+    throw new Error('no safetensors weights published — torchao and HQQ '
+      + 'packs often ship a .pt instead, and their contents cannot be read '
+      + 'from metadata');
+  }
+  onProgress(0, files.length);
+  // Read the shards a few at a time rather than one after another. A
+  // 70B pack is nine shards and two ranged requests each; sequentially
+  // that is long enough that the page reads as broken. Four at a time
+  // is enough to hide most of the latency without opening a burst of
+  // connections against the Hub for a page that is only reading
+  // metadata.
+  const tensors = [];
+  let next = 0;
+  let finished = 0;
+  const worker = async () => {
+    while (next < files.length) {
+      const mine = files[next++];
+      const got = await readHeader(repoId, mine);
+      tensors.push(...got);
+      onProgress(++finished, files.length);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(4, files.length) }, worker));
+  return {
+    repo: repoId,
+    producerVersion,
+    shards: files.length,
+    tensorCount: tensors.length,
+    ...summarize(tensors, method),
+  };
+}