calliope-ts 0.0.4 → 0.1.0

package/dist/index.js

@@ -12,9 +12,10 @@ import { clioEngine } from './clio/engine.js';
 import { analyzeReadingDocumentClio, renderUnifiedDisplay as clioRenderUnifiedDisplay, renderReadingView as clioRenderReadingView, renderFullLegend as clioRenderFullLegend, parseDocument as clioParseDocument, isPunctuation as clioIsPunctuation, } from './clio/pipeline.js';
 import { renderHierarchy, renderKeyStresses, } from './phonological.js';
 import { extractKeyStresses, scoreMeters, applyStanzaConsensus, applyRhythmLayer, applyMetricalityLayer } from './scansion.js';
-import { applyRhymeAndForm } from './rhyme.js';
-import { scandroidCorralWeird, scandroidMaximizeNormal, stressToMarks, } from './scandroid.js';
-import { renderUnifiedDisplay, renderFullLegend, renderReadingView, } from './display.js';
+import { applyRhymeAndForm, isBeatTransferRhyme } from './rhyme.js';
+import { scanTextNatively } from './scandroidNative/engine.js';
+import { renderUnifiedDisplay, renderFullLegend, renderReadingView, fabbHalleSyllablesOf, } from './display.js';
+import { buildFabbHalleGridsForPoem } from './fabbhalle.js';
 // The active prosody engine for this process: Calliope (faithful, default) or
 // Clio (the frozen legacy / alternative parse), chosen by `--clio` or the REPL
 // menu.  The exported analysis functions default their `engine` parameter to
@@ -70,6 +71,51 @@ function markStanzaGivenness(docPerLine) {
             seen.add(k);
     }
 }
+/**
+ * Stanza-level RHYME-FELLOW focus — the mirror image of givenness.  The end-rhyme
+ * is the verse form's own focus device: a rhyme falls where the ear expects a
+ * beat, and the poet who closes a line on a pronoun has PUT the punchline there
+ * ("And he stoppeth one of THREE … Now wherefore stopp'st thou ME?" — the rhyme
+ * pair three/me IS the contrast pair).  A weak-class line-final word therefore
+ * inherits beat-eligibility from a rhyme partner that carries one lexically.
+ * Guards (all must hold — none of this is a categorical pronoun rule):
+ *   • only the LINE-FINAL word of a line is ever flagged (mid-line "me" untouched);
+ *   • the word itself is FUNCTION-class (a content final already has its beat);
+ *   • the partner is a CONTENT-class line-final in the SAME stanza — the beat is
+ *     transferred from an attested template, never invented;
+ *   • the rhyme is BEAT-BEARING (perfect/rich/family, or augmented/diminished —
+ *     same stressed vowel ± one terminal consonant) and non-identical — looser
+ *     slant hunches and mere repetition do not license promotion;
+ *   • single lines and unrhymed finals (enjambment, free verse) are untouched.
+ * Mutates `rhymeFocal`; must run BEFORE the per-line relativisation (the
+ * relativiser gives a flagged MONOSYLLABLE the 'n' tier — a real, promotable
+ * beat, graded below the clause's content beats).
+ */
+function markRhymeFellows(docPerLine) {
+    if (docPerLine.length < 2)
+        return; // single line → no scheme
+    const finals = docPerLine.map(sents => {
+        const ws = sents.flatMap(s => s.words)
+            .filter(w => /[a-z]/i.test(w.word) && !isPunctuation(w.lexicalClass));
+        return ws.length ? ws.reduce((a, b) => (b.absoluteIndex > a.absoluteIndex ? b : a)) : null;
+    });
+    for (let i = 0; i < finals.length; i++) {
+        const w = finals[i];
+        if (!w || w.isContent)
+            continue; // weak-class finals only
+        for (let j = 0; j < finals.length; j++) {
+            if (j === i)
+                continue;
+            const p = finals[j];
+            if (!p || !p.isContent)
+                continue; // template must be a content beat
+            if (isBeatTransferRhyme(w.word, p.word)) {
+                w.rhymeFocal = true;
+                break;
+            }
+        }
+    }
+}
 /**
  * Scan one VERSE LINE (which may parse into several grammatical sentences).
  *
@@ -119,39 +165,11 @@ function processLine(sents, engine = activeEngine) {
     const phonoDetail = scoreMeters(keyStresses, words, ius);
     phonoDetail.all = renderHierarchy(ius, words);
     phonoDetail.keyStresses = renderKeyStresses(ius, words, keyStresses);
-    // Scandroid – use the actual foot count from the phonological detection
-    const stressPattern = words.flatMap((w) => w.syllables.map((s) => s.relativeStress ?? 'w'));
-    const marks = stressToMarks(stressPattern);
-    const actualFeet = phonoDetail.footCount > 0 ? phonoDetail.footCount : 5; // fallback only if unknown
-    const corral = scandroidCorralWeird(marks, actualFeet);
-    const max = scandroidMaximizeNormal(marks, actualFeet);
-    const corralResult = corral.footlist.length
-        ? {
-            meter: 'iambic',
-            scansion: corral.footlist.map(f => f.replace(/[()]/g, '')).join(' | '),
-            certainty: 0,
-            weightScore: 0,
-            maxPossibleWeight: 0,
-            algorithm: 'Scandroid Corral the Weird',
-        }
-        : undefined;
-    const maxResult = max.footlist.length
-        ? {
-            meter: 'iambic',
-            scansion: max.footlist.map(f => f.replace(/[()]/g, '')).join(' | '),
-            certainty: 0,
-            weightScore: 0,
-            maxPossibleWeight: 0,
-            algorithm: 'Scandroid Maximise the Normal',
-        }
-        : undefined;
     return {
         sentence: merged,
         phonologicalHierarchy: ius,
         keyStresses,
         phonologicalScansion: phonoDetail,
-        scandroidCorral: corralResult,
-        scandroidMaximise: maxResult,
     };
 }
 /**
@@ -194,6 +212,15 @@ function applyContinuityRename(results) {
 export function analyzeStanzas(text, useScandroid = true, engine = activeEngine) {
     const stanzas = text.split(/\n\s*\n/);
     const results = [];
+    // Scandroid deduces its Metron/line-length ONCE over the WHOLE document (up
+    // to a dozen sampled lines for a real multi-line poem; a per-line decision
+    // for a single typed line) — exactly Hartman's own "loaded document" vs
+    // "typed line" distinction — so this runs across stanza breaks, not per
+    // stanza.  Independent of everything else computed below: raw text in,
+    // Scandroid's own verdict out.
+    const allRawLines = stanzas.flatMap(st => st.split('\n').filter(l => l.trim() !== ''));
+    const nativeResults = useScandroid ? scanTextNatively(allRawLines) : [];
+    let nativeIdx = 0;
     for (const stanza of stanzas) {
         const lines = stanza.split('\n').filter(l => l.trim() !== '');
         const stanzaResults = [];
@@ -202,8 +229,12 @@ export function analyzeStanzas(text, useScandroid = true, engine = activeEngine)
         // default (Calliope) relativiser consults it; Clio ignores the flag.
         const docs = lines.map(line => parseDocument(line));
         markStanzaGivenness(docs.map(d => d.sentences));
+        markRhymeFellows(docs.map(d => d.sentences));
         for (const doc of docs) {
             const res = processLine(doc.sentences, engine);
+            if (res && useScandroid)
+                res.scandroidNative = nativeResults[nativeIdx];
+            nativeIdx++;
             if (res)
                 stanzaResults.push(res);
         }
@@ -253,14 +284,23 @@ export function analyzeText(text, useScandroid = true, engine = activeEngine) {
 export function analyzeReadingDocument(text, engine = activeEngine) {
     const stanzas = text.split(/\n\s*\n/);
     const out = [];
+    // See analyzeStanzas: Scandroid deduces Metron/line-length once over the
+    // whole document, spanning stanza breaks.
+    const allRawLines = stanzas.flatMap(st => st.split('\n').filter(l => l.trim() !== ''));
+    const nativeResults = scanTextNatively(allRawLines);
+    let nativeIdx = 0;
     for (const stanza of stanzas) {
         const rawLines = stanza.split('\n').filter(l => l.trim() !== '');
         if (rawLines.length === 0)
             continue;
         const rawDocs = rawLines.map(raw => ({ raw, doc: parseDocument(raw) }));
         markStanzaGivenness(rawDocs.map(rd => rd.doc.sentences));
+        markRhymeFellows(rawDocs.map(rd => rd.doc.sentences));
         const lines = rawDocs.map(({ raw, doc }) => {
             const res = processLine(doc.sentences, engine);
+            if (res)
+                res.scandroidNative = nativeResults[nativeIdx];
+            nativeIdx++;
             return { raw, results: res ? [res] : [] };
         });
         applyStanzaConsensus(lines.flatMap(l => l.results.map(r => r.phonologicalScansion)));
@@ -286,14 +326,27 @@ function showResults(text) {
     // Clio routes through its own frozen pipeline + renderer.
     const isClio = activeEngine.name === 'clio';
     const stanzas = (isClio ? analyzeReadingDocumentClio : analyzeReadingDocument)(text);
-    const render = isClio ? clioRenderUnifiedDisplay : renderUnifiedDisplay;
+    // Fabb–Halle's rule set is discovered by its OWN poem-level grid
+    // construction over the whole document (lexical stress only), then each
+    // line is rendered under it — the engine's verdict is only reported for
+    // comparison.  Clio's frozen renderer keeps its own behaviour.
+    let fhSchema = null;
+    if (!isClio) {
+        try {
+            const allResults = stanzas.flatMap(st => st.lines.flatMap(l => l.results));
+            fhSchema = buildFabbHalleGridsForPoem(allResults.map(fabbHalleSyllablesOf))?.schema ?? null;
+        }
+        catch { /* section falls back to stipulating the engine's meter */ }
+    }
     for (let s = 0; s < stanzas.length; s++) {
         if (stanzas.length > 1) {
             console.log('\n' + chalk.bold('═══ Stanza ' + (s + 1) + ' ═══'));
         }
         for (const ln of stanzas[s].lines) {
             for (const res of ln.results) {
-                console.log(render(res, ln.raw));
+                console.log(isClio
+                    ? clioRenderUnifiedDisplay(res, ln.raw)
+                    : renderUnifiedDisplay(res, ln.raw, { fhSchema }));
             }
         }
     }

package/dist/phonological.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phonological.d.ts","sourceRoot":"","sources":["../src/phonological.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,WAAW,EACX,OAAO,EAGP,kBAAkB,EAClB,gBAAgB,EAChB,SAAS,EAET,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,WAAW,GACpB,gBAAgB,EAAE,CAoBpB;AA0UD,wBAAgB,eAAe,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,EAAE,CAM/D;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,kBAAkB,GAAG,OAAO,EAAE,CAMjE;AA+ED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAGjF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EAAE,EACvB,KAAK,EAAE,OAAO,EAAE,EAChB,WAAW,EAAE,SAAS,EAAE,GACvB,MAAM,CASR;AAsBD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvD,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAQzD;AAED,mFAAmF;AACnF,wBAAgB,oBAAoB,CAClC,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GACvE,WAAW,EAAE,CASf;AAsDD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CA8RrJ;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,oBAAoB,EAAE,CAwB9E"}
+{"version":3,"file":"phonological.d.ts","sourceRoot":"","sources":["../src/phonological.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,WAAW,EACX,OAAO,EAGP,kBAAkB,EAClB,gBAAgB,EAChB,SAAS,EAET,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,WAAW,GACpB,gBAAgB,EAAE,CAoBpB;AA0UD,wBAAgB,eAAe,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,EAAE,CAM/D;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,kBAAkB,GAAG,OAAO,EAAE,CAMjE;AA+ED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAGjF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EAAE,EACvB,KAAK,EAAE,OAAO,EAAE,EAChB,WAAW,EAAE,SAAS,EAAE,GACvB,MAAM,CASR;AA8BD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvD,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAQzD;AAED,mFAAmF;AACnF,wBAAgB,oBAAoB,CAClC,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GACvE,WAAW,EAAE,CASf;AAsDD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CA8RrJ;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,oBAAoB,EAAE,CAwB9E"}

package/dist/phonological.js

@@ -435,7 +435,13 @@ export function renderKeyStresses(ius, words, keyStresses) {
  * Respects English phonotactics: digraphs stay together, consonants go to
  * the onset of the following syllable when they form a legal cluster.
  */
-const VOWEL_CHARS = new Set('aeiouyAEIOUY');
+// Accented Latin vowels included: an "é" read as a consonant shifts every
+// chunk boundary in the word (Milésien split Milé·si·en, parking the stress
+// mark on the wrong displayed syllable).
+const VOWEL_CHARS = new Set('aeiouyAEIOUY'
+    + 'àáâãäåæèéêëìíîïòóôõöøùúûüýÿ'
+    + 'ÀÁÂÃÄÅÆÈÉÊËÌÍÎÏÒÓÔÕÖØÙÚÛÜÝ'
+    + 'āăēĕīĭōŏūŭȳœŒ');
 const CONSONANT_DIGRAPHS = new Set(['th', 'sh', 'ch', 'wh', 'ph', 'gh', 'ck', 'ng', 'nk', 'tch', 'dge', 'sc', 'sk', 'sp', 'st']);
 // ARPABET vowels, split into "free/long" (can end a syllable → favours an OPEN
 // split: e·ven, ta·ble, o·pen) and "checked/short" (needs a coda → favours a

package/dist/rewriteEn.d.ts

@@ -0,0 +1,14 @@
+export interface EnRewriteOptions {
+    /** rhyme mode: widen the pool to family and assonant rhyme tiers. */
+    fuzzyRhyme?: boolean;
+    /** derivational-suffix + CMU-morphology-class grounding. */
+    morphGround?: boolean;
+    /** 0–4: weight of the |Δzipf| register-band penalty (0 = off). */
+    registerFidelity?: number;
+    /** use dictionary POS for source words instead of the contextual tagger. */
+    dictPos?: boolean;
+}
+/** Rewrite English verse in place — spacing, punctuation, and case survive
+ *  (nounsing's built-ins lowercase and drop punctuation). */
+export declare function rewriteEnglishText(text: string, mode: 'stress' | 'rhyme' | 'phones', posPrecision?: number, freqThreshold?: number, opts?: EnRewriteOptions): string;
+//# sourceMappingURL=rewriteEn.d.ts.map

package/dist/rewriteEn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewriteEn.d.ts","sourceRoot":"","sources":["../src/rewriteEn.ts"],"names":[],"mappings":"AAuLA,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,kEAAkE;IAClE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAsKD;6DAC6D;AAC7D,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,EACnC,YAAY,SAAI,EAChB,aAAa,SAAI,EACjB,IAAI,GAAE,gBAAqB,GAC1B,MAAM,CAmCR"}

package/dist/rewriteEn.js

@@ -0,0 +1,392 @@
+// rewriteEn.ts — the English Transmutation Chamber, rebuilt over nounsing-pro
+// primitives with the Russian side's scored-ranking architecture.
+//
+//   stress — candidates share the source's exact stress contour;
+//   rhyme  — candidates rhyme with the source (perfect; or, with fuzzyRhyme,
+//            the wider family/assonant tiers of nounsing's rhyme typology —
+//            many words have one or zero perfect rhyme-mates: temperate ↔
+//            intemperate is the whole perfect pool);
+//   phones — candidates share the opening two phonemes.
+//
+// Gates (preserved semantics from nounsing's built-in rewrites):
+//   posPrecision 0–3 — Penn-tag prefix match.  The SOURCE word's tag comes
+//     from the scansion engine's CONTEXTUAL tagger by default (parseDocument:
+//     UDPipe-in-context with clitic re-merging and archaic forms — "frame" in
+//     "Could frame thy fearful symmetry" gates as VB, not the dictionary's
+//     NN); candidates are dictionary-tagged (they occur in no context).
+//     `dictPos: true` reverts the source side to dictionary tags (fast path,
+//     no per-line parse).
+//   freqThreshold    — Zipf floor (≥ 1.0 enables).
+//
+// Grounding score (new, composed like src/russian/rewrite.ts):
+//   morphGround      — derivational-suffix match (-ness/-tion/-ing/-ly …)
+//                      + the augmented CMU's morphology classes (suffixType,
+//                      prefixType, simple/complex), + same-root avoidance;
+//   registerFidelity — 0–4 slider: −r·|Δzipf| penalty, so a rare word swaps
+//                      for a similarly rare word and a common one for a
+//                      common one (register/diction banding);
+//   fuzzy rhyme tiers — perfect +8 > family +5 > assonant +2, so perfect
+//                      rhymes still win wherever they exist.
+//
+// Unlike nounsing's built-ins (lowercased whitespace-join), this rewriter
+// replaces words in place — punctuation, spacing, and capitalisation survive.
+import { lexicon, morphology, phonesForWord, stresses, search, searchStresses, rhymes, familyRhyme, assonantRhyme, } from 'nounsing-pro';
+import { parseDocument, isPunctuation } from './parser.js';
+import { lexicon as enLexicon } from 'en-lexicon';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+/** Words attested lowercase in Webster's 2nd (web2 ∩ lexicon, de-inflected
+ *  at build time — tools note: regenerate src/data/en_common_words.json from
+ *  /usr/share/dict/words if the lexicon changes; tsc does NOT copy it to
+ *  dist/data/).  The CMU is ~half proper names that carry NO tag/frequency
+ *  marker (aaron is NN at Zipf 4.2), so dictionary-attestation is the one
+ *  signal that separates eagle/warrior/chorus from aaron/melcher/salisbury. */
+let _commonWords = null;
+function commonWords() {
+    if (_commonWords)
+        return _commonWords;
+    try {
+        const p = join(dirname(fileURLToPath(import.meta.url)), 'data', 'en_common_words.json');
+        _commonWords = new Set(JSON.parse(readFileSync(p, 'utf8')));
+    }
+    catch {
+        _commonWords = new Set();
+    }
+    return _commonWords;
+}
+// ── Grounding helpers ─────────────────────────────────────────────────
+/** English derivational suffixes, longest-first.  Surface match beats the
+ *  CMU's class-level fields for register: brightness → sweetness keeps the
+ *  deadjectival-abstract cast even when Penn tags already agree. */
+const DERIV_SUFFIXES = [
+    'ability', 'ibility', 'ization', 'fulness', 'ousness',
+    'ation', 'ition', 'iness', 'ingly', 'ement', 'ships',
+    'ness', 'tion', 'sion', 'ment', 'able', 'ible', 'ance', 'ence',
+    'ship', 'hood', 'ward', 'wise', 'less', 'ful', 'ous', 'ive',
+    'ity', 'ism', 'ist', 'ize', 'ise', 'ify', 'ard', 'dom',
+    'ing', 'est', 'eth', 'ess', 'ly', 'ed', 'er', 'en',
+];
+const _sufCache = new Map();
+function derivSuffix(word) {
+    const hit = _sufCache.get(word);
+    if (hit !== undefined)
+        return hit;
+    let out = '';
+    for (const s of DERIV_SUFFIXES) {
+        if (word.length - s.length >= 3 && word.endsWith(s)) {
+            out = s;
+            break;
+        }
+    }
+    _sufCache.set(word, out);
+    return out;
+}
+function morphClassOf(word) {
+    const m = morphology(word);
+    if (!m || m.length === 0)
+        return null;
+    return {
+        suffixType: m[0].suffixType ?? 'NA',
+        prefixType: m[0].prefixType ?? 'NA',
+        morphology: m[0].morphology ?? 'NA',
+    };
+}
+function zipfOf(word) {
+    const lex = lexicon(word);
+    if (!lex || lex.length === 0)
+        return null;
+    const f = parseFloat(lex[0].freq);
+    return Number.isNaN(f) ? null : f;
+}
+function posOf(word) {
+    const lex = lexicon(word);
+    const pos = lex?.[0]?.pos;
+    return pos && pos !== 'NA' ? pos.toUpperCase() : null;
+}
+/** Candidate-side tag SET, from the FinNLP en-lexicon (112k words, full
+ *  Penn tag distributions: burning → NN|VBG|JJ) with nounsing's single
+ *  first-profile tag as fallback.  Two wins over first-profile-only:
+ *  a VB source no longer rejects "frame" (NN|VBP|VB), and en-lexicon
+ *  tags proper names as NNP (aaron, jake, kyle) where the augmented CMU
+ *  calls them NN — the name signal no other resource carries. */
+const _tagSetCache = new Map();
+function tagSetOf(word) {
+    const hit = _tagSetCache.get(word);
+    if (hit)
+        return hit;
+    // Own-property + type guard: the lexicon is a plain object, so bare
+    // indexing with "constructor" (a real CMU word!) returns the Object
+    // constructor function — .toUpperCase() then crashes the cast.
+    const entry = Object.prototype.hasOwnProperty.call(enLexicon, word)
+        ? enLexicon[word] : undefined;
+    let out;
+    if (typeof entry === 'string' && entry) {
+        out = entry.toUpperCase().split('|');
+    }
+    else {
+        const p = posOf(word);
+        out = p ? [p] : [];
+    }
+    _tagSetCache.set(word, out);
+    return out;
+}
+/** Same-root detector: English derives at both edges (night→nightly,
+ *  more→anymore, temperate→intemperate), so containment at either edge
+ *  flags the pair.  Applied unconditionally — a same-root cast is a
+ *  transmutation in name only, and temperate's sole perfect rhyme is
+ *  its own negation. */
+function sameRoot(a, b) {
+    if (Math.min(a.length, b.length) < 3)
+        return false;
+    return a.endsWith(b) || b.endsWith(a) || a.startsWith(b) || b.startsWith(a);
+}
+// ── Closed-class scaffolding (active at posPrecision ≥ 1) ─────────────
+//
+// The Russian side's quality edge is exactly this: function words are the
+// grammatical scaffolding, and swapping them through the open-class pipeline
+// yields "of → would've" and "the → an call".  Closed-class tags are KEPT;
+// pronouns and modals — where swaps stay grammatical — transmute only
+// WITHIN curated sets that respect case and possession (Penn's PRP covers
+// he AND him, so the tag alone can't guard case).
+const KEEP_TAGS = new Set([
+    'DT', 'IN', 'CC', 'TO', 'EX', 'POS', 'RP', 'PDT',
+    'WDT', 'WP', 'WP$', 'WRB', 'UH', 'CD', 'LS', 'SYM', 'FW',
+]);
+const PRON_NOM = ['i', 'he', 'she', 'we', 'they', 'thou', 'ye', 'you', 'it'];
+const PRON_ACC = ['me', 'him', 'her', 'us', 'them', 'thee', 'you', 'it'];
+const PRON_POSS = ['my', 'thy', 'his', 'her', 'its', 'our', 'their', 'your'];
+const MODALS = ['can', 'could', 'may', 'might', 'must', 'shall', 'should', 'will', 'would'];
+function closedClassSet(tag, lower) {
+    if (tag === 'MD')
+        return MODALS;
+    if (tag === 'PRP$')
+        return PRON_POSS;
+    if (tag === 'PRP') {
+        if (PRON_NOM.includes(lower))
+            return PRON_NOM;
+        if (PRON_ACC.includes(lower))
+            return PRON_ACC;
+        return []; // unknown pronoun form — keep it
+    }
+    return null;
+}
+function matchCase(original, replacement) {
+    if (original === original.toUpperCase() && original.length > 1)
+        return replacement.toUpperCase();
+    if (original[0] === original[0].toUpperCase()) {
+        return replacement[0].toUpperCase() + replacement.slice(1);
+    }
+    return replacement;
+}
+const MAX_SCORED = 4000; // sample cap before scoring very large pools
+function pickReplacement(mode, lower, ctxTag, posPrecision, zipfFloor, opts) {
+    const prons = phonesForWord(lower);
+    if (prons.length === 0)
+        return null;
+    // Candidate pool, with rhyme-tier tags in fuzzy rhyme mode.
+    let pool;
+    if (mode === 'stress') {
+        const pat = stresses(prons[0]);
+        if (!pat)
+            return null;
+        pool = searchStresses('^' + pat + '$').map(w => ({ word: w, tier: 0 }));
+    }
+    else if (mode === 'rhyme') {
+        const perfect = rhymes(lower);
+        if (opts.fuzzyRhyme) {
+            const seen = new Set(perfect);
+            pool = perfect.map(w => ({ word: w, tier: 8 }));
+            for (const w of familyRhyme(lower)) {
+                if (!seen.has(w)) {
+                    seen.add(w);
+                    pool.push({ word: w, tier: 5 });
+                }
+            }
+            for (const w of assonantRhyme(lower)) {
+                if (!seen.has(w)) {
+                    seen.add(w);
+                    pool.push({ word: w, tier: 2 });
+                }
+            }
+        }
+        else {
+            pool = perfect.map(w => ({ word: w, tier: 0 }));
+        }
+    }
+    else {
+        const first2 = prons[0].split(' ').slice(0, 2).join(' ');
+        pool = search('^' + first2).map(w => ({ word: w, tier: 0 }));
+    }
+    if (pool.length === 0)
+        return null;
+    // Gates (same semantics as nounsing's built-in rewrites).  The source tag
+    // prefers the contextual parse; dictionary POS is the fallback (and the
+    // whole story when dictPos is set).
+    const srcPos = ctxTag ?? posOf(lower);
+    const posPrefix = posPrecision > 0 && srcPos ? srcPos.slice(0, posPrecision) : null;
+    // Closed-class scaffolding: prepositions, determiners, conjunctions etc.
+    // survive untouched; pronouns and modals transmute only within their
+    // curated sets — the mode constraint already lives in the pool, so
+    // could→should/would in rhyme mode, he→she/thee/we, thy→her/our.
+    if (posPrecision > 0 && srcPos) {
+        if (KEEP_TAGS.has(srcPos))
+            return null;
+        const set = closedClassSet(srcPos, lower);
+        if (set) {
+            const members = pool.filter(c => c.word !== lower && set.includes(c.word));
+            if (members.length === 0)
+                return null;
+            return members[(Math.random() * members.length) | 0].word;
+        }
+    }
+    // Sample very large pools before the scoring pass.
+    if (pool.length > MAX_SCORED) {
+        for (let i = pool.length - 1; i > pool.length - 1 - MAX_SCORED; i--) {
+            const j = (Math.random() * (i + 1)) | 0;
+            [pool[i], pool[j]] = [pool[j], pool[i]];
+        }
+        pool = pool.slice(pool.length - MAX_SCORED);
+    }
+    const srcSuffix = opts.morphGround ? derivSuffix(lower) : '';
+    const srcMorph = opts.morphGround ? morphClassOf(lower) : null;
+    const srcZipf = (opts.registerFidelity ?? 0) > 0 ? zipfOf(lower) : null;
+    const rFid = opts.registerFidelity ?? 0;
+    const srcNsylls = mode !== 'stress' ? (lexicon(lower)?.[0]?.nsylls ?? null) : null;
+    const scored = [];
+    for (const { word: cand, tier } of pool) {
+        if (cand === lower)
+            continue;
+        // Letters only, two or more: kills CMU noise (a42128), tokenisation
+        // shards (ca), and the apostrophe entries (morris', would've, it'll)
+        // that read as junk in a cast.
+        if (!/^[a-z][a-z]+$/.test(cand))
+            continue;
+        const candZipf = zipfOf(cand);
+        if (zipfFloor >= 1.0 && (candZipf === null || candZipf < zipfFloor))
+            continue;
+        // Tag-set gate: the candidate passes if ANY of its readings matches the
+        // source tag at the requested precision (precision 3 = EXACT tag — a
+        // prefix slice conflated PRP with PRP$; thy→me was a case wreck).
+        // Proper-noun readings are struck first when the source isn't proper:
+        // jake is NNP-only and vanishes; frank keeps JJ|NN|VB and stays.
+        let primaryMatch = false;
+        if (posPrefix && srcPos) {
+            let tags = tagSetOf(cand);
+            if (!srcPos.startsWith('NNP')) {
+                tags = tags.filter(t => !t.startsWith('NNP'));
+                if (tags.length === 0)
+                    continue;
+            }
+            const match = (t) => posPrecision >= 3 ? t === srcPos : t.slice(0, posPrecision) === posPrefix;
+            if (!tags.some(match))
+                continue;
+            // The dominant (first-listed) reading matching is worth a bonus —
+            // "frame" as VB is its secondary reading, "blame" its primary.
+            primaryMatch = match(tags[0]);
+        }
+        let s = tier;
+        if (primaryMatch)
+            s += 2;
+        // Attestation penalty (not a hard filter — thin pools still cast):
+        // unattested candidates are overwhelmingly the CMU's untagged proper
+        // names.  Skipped for proper-noun sources, where names are the point.
+        if (posPrecision > 0 && (!srcPos || !srcPos.startsWith('NNP')) && commonWords().size > 0
+            && !commonWords().has(cand))
+            s -= 7;
+        if (opts.morphGround) {
+            if (srcSuffix && derivSuffix(cand) === srcSuffix)
+                s += 4;
+            if (srcMorph) {
+                const cm = morphClassOf(cand);
+                if (cm) {
+                    if (cm.suffixType === srcMorph.suffixType)
+                        s += 2;
+                    if (cm.morphology === srcMorph.morphology)
+                        s += 1;
+                    if (cm.prefixType === srcMorph.prefixType)
+                        s += 1;
+                }
+            }
+        }
+        if (sameRoot(lower, cand))
+            s -= 6;
+        if (srcZipf !== null && candZipf !== null) {
+            // Quantised to half-Zipf bands: a continuous penalty would leave a
+            // unique argmax and kill the dice — candidates within a band tie,
+            // and the random tiebreak keeps each cast fresh.
+            s -= rFid * (Math.round(Math.abs(srcZipf - candZipf) * 2) / 2);
+        }
+        // Rhyme/phones pools ignore length, so meter breaks worst on long
+        // lines (hand→understand, frame→francisco).  Prefer same-syllable
+        // casts without forcing them — rhyme pools can be thin.
+        if (srcNsylls !== null) {
+            const cn = lexicon(cand)?.[0]?.nsylls;
+            if (cn)
+                s -= 1.5 * Math.min(Math.abs(cn - srcNsylls), 3);
+        }
+        scored.push({ word: cand, s, r: Math.random() });
+    }
+    if (scored.length === 0)
+        return null;
+    scored.sort((a, b) => b.s - a.s || a.r - b.r);
+    return scored[0].word;
+}
+const WORD_RE = /[A-Za-z][A-Za-z'’]*/g;
+/** a/an agreement post-pass: articles survive (closed class), but the noun
+ *  after them changes, so "an call" and "a hour" need re-agreement.  The
+ *  first PHONE decides (an hour, a unicorn), with a letter fallback. */
+function startsWithVowelSound(word) {
+    const p = phonesForWord(word.toLowerCase().replace(/[’]/g, "'"))[0];
+    if (p)
+        return /^[AEIOU]/.test(p);
+    return /^[aeiou]/i.test(word);
+}
+function fixArticles(line) {
+    return line.replace(/\b([Aa])(n?)(\s+)([A-Za-z][A-Za-z'’]*)/g, (_m, a, _n, sp, next) => {
+        return (startsWithVowelSound(next) ? a + 'n' : a) + sp + next;
+    });
+}
+/** Normalised lookup key: lowercase, straight apostrophe (parseDocument
+ *  normalises curly apostrophes before tokenising, so keys must match). */
+function keyOf(s) {
+    return s.toLowerCase().replace(/[‘’ʼ′]/g, "'");
+}
+/** Rewrite English verse in place — spacing, punctuation, and case survive
+ *  (nounsing's built-ins lowercase and drop punctuation). */
+export function rewriteEnglishText(text, mode, posPrecision = 1, freqThreshold = 0, opts = {}) {
+    return text.split('\n').map(line => {
+        if (!line.trim())
+            return line;
+        // Contextual tagging (default): one parse per line; the aligner walks
+        // the parsed words in order, matching surface forms within a small
+        // window (clitic re-merging keeps contractions whole on both sides).
+        let ctxWords = [];
+        if (posPrecision > 0 && !opts.dictPos) {
+            try {
+                ctxWords = parseDocument(line).sentences
+                    .flatMap(s => s.words)
+                    .filter(w => !isPunctuation(w.lexicalClass))
+                    .map(w => ({ form: keyOf(w.word), tag: w.lexicalClass.toUpperCase() }));
+            }
+            catch { /* dictionary fallback for the whole line */ }
+        }
+        let ti = 0;
+        const nextTag = (surface) => {
+            const target = keyOf(surface);
+            for (let k = ti; k < Math.min(ctxWords.length, ti + 6); k++) {
+                if (ctxWords[k].form === target) {
+                    ti = k + 1;
+                    return ctxWords[k].tag;
+                }
+            }
+            return null;
+        };
+        return fixArticles(line.replace(WORD_RE, (surface) => {
+            const ctxTag = nextTag(surface);
+            const lower = keyOf(surface);
+            const repl = pickReplacement(mode, lower, ctxTag, posPrecision, freqThreshold, opts);
+            return repl ? matchCase(surface, repl) : surface;
+        }));
+    }).join('\n');
+}