Enable the swap control, and document the whole transform

The Lexicon Lab's `mint` control was rendered disabled: `LexiconLab` never
passed `mint` into `vacParams` at all, so it could not have worked. It works
now, and the interesting part is how its one real constraint is presented.

`mint = "swap"` is injective only at p in {0, 1} — a theorem (contract §5.2a),
not a rough edge: a map stable in p whose images are domain types is injective
everywhere only if it is the identity. So the UI never clamps p, never falls
back to nonce, and never catches-and-replaces the typed error. `LexiconLab`
asks the engine and carries the refusal up as a string; the panel prints it
verbatim with the four exits offered as buttons, and with no vocabulary the
counters, the trainer and the invariance check have nothing to report — which
is the honest state of that configuration.

Beside the mint control the theorem is COUNTED rather than asserted: every
domain type is pushed through the real transform at the current p and the
distinct images counted. Measured on the shipped corpus at seed 0, swap loses
244 / 322 / 233 image slots at p = .25/.5/.75 and 0 at both endpoints; nonce
loses 0 everywhere. The `bijective` chip now reads "injective at p = 0, 1"
under swap instead of a bare tick.

Info tab gains #vacancy: the T4 2x2 with the vacancy cell marked, the
transform's definition, nesting and stability and the four properties the
source implementation claims and breaks, the invariance theorem with §7.4's
framing (the exact zero IS the finding), the swap decomposition with "cost of
unknown form" stated as an upper bound, the stress table's real status (61
rule-seeded entries, never human-checked, 5.1% of this corpus's tokens), and
what the static build refuses by name — plus the WebGPU/CI coverage gap.
#real, #limits and #refs updated.

Every number in that prose is pinned by five new tests in docs.spec.ts: the
counts come from a live POST /api/lex/vacancy, the swap collisions and the
stress-table size are read off the running panel, and the static build's
±0.2 nats and 700-token floor are read out of the constants that enforce them.
No number from the source document appears anywhere; its prosody figures are
its own, on a corpus we do not have.

Also fixes a stale comment in staticClient/arch.ts that still documented a
±0.1 nats quantization uncertainty its own constant had superseded with 0.2.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: jeremymanning

code/frontend/src/lib/staticClient/arch.ts

@@ -721,7 +721,11 @@ export class ArchSection {
    *     is 14–23 % pooled with sign flips, so quantization eats exactly the contrast that
    *     makes the result mean something;
    *   - pooled `swap − english` and `nonce − english` are reported, with the measured
-   *     ±0.1 nats quantization uncertainty stated beside the sampling standard error.
+   *     `VACANCY_Q8_UNCERTAINTY_NATS` quantization uncertainty stated beside the sampling
+   *     standard error. (This line said "±0.1" until that constant was re-derived on the
+   *     configuration that actually ships and came out at 0.2 — see its own comment. A
+   *     number written twice is a number that drifts, so it is named here rather than
+   *     retyped.)
    *
    * A dtype with no measured bound is refused outright rather than given a ± copied from
    * a different dtype: a stated error bar that was never measured is a fabrication, and

code/frontend/src/viz/info/InfoTab.svelte

@@ -64,9 +64,11 @@
   import {
     buildVacancyMap,
     mapVocabWords,
+    typeCounts,
     vacancyDomain,
     vacancyParams,
     vacateText,
+    type MintStrategy,
     type VacancyMap,
     type VacancyParams,
   } from "../../lib/lexEngine/vacancy";
@@ -134,7 +136,7 @@
   let vacCondition = $state<VacancyCondition>("consistent");
   let vacRevealAfter = $state(1);
   let vacProsody = $state(true);
-  let vacMint = $state("nonce");
+  let vacMint = $state<MintStrategy>("nonce");
 
   /**
    * What a training run produced, or null while nothing has been trained at the CURRENT
@@ -205,25 +207,50 @@
       consistent: vacCondition !== "inconsistent",
       matchProsody: vacProsody,
       revealAfter: vacCondition === "reveal" ? vacRevealAfter : 0,
+      mint: vacMint,
     }),
   );
 
   /**
-   * The nonce assignment, built ONCE over the domain (corpus types ∪ the full Dolch list)
-   * in canonical order — contract §5.2. It reads `vacSeed` and `vacProsody` and
-   * deliberately NOT `vacP`: the map is `p`-independent, which is what makes a stem's
-   * nonce the same string at every `p` where it is vacated, and building it inside a
-   * derived that also read `p` would silently re-mint the whole corpus on every tick of
-   * the slider — visibly breaking the stability the panel exists to demonstrate.
+   * The replacement assignment, built ONCE over the domain (corpus types ∪ the full Dolch
+   * list) in canonical order — contract §5.2. It reads `vacSeed`, `vacProsody` and the
+   * minting strategy, and deliberately NOT `vacP`: the map is `p`-independent, which is what
+   * makes a stem's replacement the same string at every `p` where it is vacated, and building
+   * it inside a derived that also read `p` would silently re-mint the whole corpus on every
+   * tick of the slider — visibly breaking the stability the panel exists to demonstrate.
+   *
+   * `consistent` IS passed, even though the map itself does not depend on it, because the
+   * engine refuses `mint = "swap"` under the inconsistent control (contract §8.3: 1 680
+   * open-class stems against 8 202 vacated tokens, so there is no supply of real words to
+   * mint a fresh one per occurrence). Deciding that here would be re-deriving a rule the
+   * engine owns; asking the engine and CARRYING its refusal is the honest form. Nothing is
+   * substituted for a refused map — `vacRefusal` renders the engine's own sentence and the
+   * panels below have no vocabulary, which is exactly the state the reader is in.
    */
-  const vacMap = $derived.by<VacancyMap | null>(() =>
-    corpus
-      ? buildVacancyMap(
-          vacancyDomain(tokenize(corpus.text)),
-          vacancyParams({ seed: vacSeed, matchProsody: vacProsody }),
-        )
-      : null,
-  );
+  const vacBuild = $derived.by<{ map: VacancyMap | null; refusal: string }>(() => {
+    if (!corpus) return { map: null, refusal: "" };
+    const tokens = tokenize(corpus.text);
+    try {
+      return {
+        map: buildVacancyMap(
+          vacancyDomain(tokens),
+          vacancyParams({
+            seed: vacSeed,
+            matchProsody: vacProsody,
+            mint: vacMint,
+            consistent: vacParams.consistent,
+          }),
+          // The swap control ranks its replacement pool by corpus frequency, so it needs the
+          // TOKEN STREAM's counts; `nonce` never looks at them.
+          vacMint === "swap" ? typeCounts(tokens) : undefined,
+        ),
+        refusal: "",
+      };
+    } catch (e) {
+      return { map: null, refusal: e instanceof Error ? e.message : String(e) };
+    }
+  });
+  const vacMap = $derived(vacBuild.map);
 
   /** The corpus every panel below measures, trains on and generates from. */
   const vacatedText = $derived.by(() =>
@@ -251,26 +278,45 @@
    * tab's normal rule. Coverage then collapses — and the collapse is the measurement, not
    * a failure to be papered over.
    */
-  const vocab = $derived.by<LexVocab | null>(() => {
-    if (!corpus || !baseVocab) return null;
-    if (!vacated) return baseVocab;
+  const vocabResult = $derived.by<{ vocab: LexVocab | null; refusal: string }>(() => {
+    if (vacBuild.refusal) return { vocab: null, refusal: vacBuild.refusal };
+    if (!corpus || !baseVocab) return { vocab: null, refusal: "" };
+    if (!vacated) return { vocab: baseVocab, refusal: "" };
     if (vacMapped && vacMap) {
-      return new LexVocab(
-        mapVocabWords(baseVocab.words, vacMap, vacParams),
-        baseVocab.source,
-        baseVocab.budgetName,
-      );
+      try {
+        return {
+          vocab: new LexVocab(
+            mapVocabWords(baseVocab.words, vacMap, vacParams),
+            baseVocab.source,
+            baseVocab.budgetName,
+          ),
+          refusal: "",
+        };
+      } catch (e) {
+        // Contract §5.2a, and the one refusal a reader will actually meet: `mint = "swap"`
+        // draws its replacements FROM the domain, so at an intermediate `p` a vacated type
+        // can land on one that has not moved and two budget words would share an embedding
+        // row. The theorem there proves no `p`-stable swap avoids it, so this is not a defect
+        // to re-draw away. The engine's sentence is carried up verbatim and NOTHING is put in
+        // its place: rebuilding the budget from the vacated corpus here would be a different
+        // measurement (§7.2's rebuilt rule belongs to the control conditions) wearing the
+        // mapped condition's label.
+        return { vocab: null, refusal: e instanceof Error ? e.message : String(e) };
+      }
     }
-    return buildVocab(budgetSource, budgetName, vacatedText);
+    return { vocab: buildVocab(budgetSource, budgetName, vacatedText), refusal: "" };
   });
+  const vocab = $derived(vocabResult.vocab);
+  /** The engine's own words for a configuration it declines, or `""`. Never paraphrased. */
+  const vacRefusal = $derived(vocabResult.refusal);
   const coverage = $derived.by<Coverage | null>(() =>
     vocab && corpus ? vocab.coverage(vacatedText) : null,
   );
   /** What the trainer, the sampler and the geometry are describing. */
   const activeCorpusLabel = $derived(
     corpus
       ? vacated
-        ? `${corpus.label} · vacated p=${vacP.toFixed(2)}, seed ${vacSeed}, ${vacCondition}`
+        ? `${corpus.label} · vacated p=${vacP.toFixed(2)}, seed ${vacSeed}, ${vacCondition}, ${vacMint}`
         : corpus.label
       : "",
   );
@@ -545,10 +591,16 @@
           one matrix counted twice.
         </li>
         <li>
-          <b>Not shipped:</b> nonce-word minting (it needs a parameter-matched control that
-          does not exist), and the meter/rhyme "fingerprint" (the source's meter score does
-          not measure meter — under its scheme every word's stress pattern begins the same
-          way, so the score converges to the template's own density whatever you feed it).
+          <b>Shipped, corrected:</b> nonce-word minting — the vacancy panel above. Feature 006
+          deferred it for want of a parameter-matched control; the control turned out to be the
+          design, since under the mapped condition the transform preserves the vocabulary
+          exactly. Four properties the source claims for itself are broken by its own
+          implementation and fixed here (its map is built lazily while rewriting, so a nonce
+          depends on <code>p</code>; its give-up path and its seam fix are order-dependent; and
+          injectivity is assumed rather than verified).
+          <b>Not shipped:</b> the meter/rhyme "fingerprint" (the source's meter score does not
+          measure meter — under its scheme every word's stress pattern begins the same way, so
+          the score converges to the template's own density whatever you feed it).
         </li>
         <li>
           Browser and Python run the <b>same recipe</b>, held to ≤1e-5 on the forward pass,
@@ -623,12 +675,13 @@
       condition={vacCondition}
       revealAfter={vacRevealAfter}
       mint={vacMint}
+      refusal={vacRefusal}
       onP={(v) => (vacP = v)}
       onSeed={(v) => (vacSeed = v)}
       onCondition={(c) => (vacCondition = c as VacancyCondition)}
       onRevealAfter={(v) => (vacRevealAfter = v)}
       onProsody={(v) => (vacProsody = v)}
-      onMint={(m) => (vacMint = m)}
+      onMint={(m) => (vacMint = m as MintStrategy)}
     />
   </div>