calliope-ts 0.0.4 → 0.1.0

package/dist/rhyme.d.ts

@@ -1,5 +1,5 @@
 import { LineResult, StressLevel } from './types.js';
-export type RhymeTypeName = 'identical' | 'rich' | 'perfect' | 'family' | 'assonant' | 'consonant' | 'augmented' | 'diminished' | 'wrenched' | 'eye';
+export type RhymeTypeName = 'identical' | 'rich' | 'perfect' | 'family' | 'assonant' | 'consonant' | 'augmented' | 'diminished' | 'grammatical' | 'mosaic' | 'wrenched' | 'eye';
 export interface RhymePair {
     type: RhymeTypeName;
     /** masculine (stress on final syllable) / feminine (penult) / dactylic (antepenult) */
@@ -7,6 +7,34 @@ export interface RhymePair {
 }
 /** Classify the rhyme relation between two line-end words (or null). */
 export declare function classifyRhymePair(a: string, b: string): RhymePair | null;
+/** A BEAT-BEARING end-rhyme between two line-end words — the bar the stanza
+ *  rhyme-fellow pass (index.ts markRhymeFellows) requires before a weak
+ *  line-final monosyllable may inherit a beat from its rhyme partner.  Beyond
+ *  the STRONG tier (perfect/rich/family) it admits AUGMENTED and DIMINISHED
+ *  pairs: their stressed vowel is identical and they differ by ONE terminal
+ *  consonant, so the correspondence is still carried audibly by the final
+ *  beat ("me"/"dream", "sea"/"seed").  Identical repetition is excluded
+ *  (epistrophe, not a prominence template), as are the looser slant tiers
+ *  (assonant/consonant/grammatical/wrenched/eye) — a hunch is not a beat. */
+export declare function isBeatTransferRhyme(a: string, b: string): boolean;
+/**
+ * MOSAIC (multi-word) end-rhyme — Byron's "intellectual / hen-pecked you all";
+ * the maintainer's "TENderly / SLENder — SEE?".  One line's POLYSYLLABIC rhyme
+ * part (its final word's last stressed vowel + everything after, ≥2 syllables)
+ * is covered by a SEQUENCE of words at the other line's end, the rhyme domain
+ * re-segmented across the word boundary.  Detection is nucleus-aligned:
+ *   • the covering span opens on a STRESSED vowel exactly n syllables from the
+ *     line end (n = the anchor's rhyme-part syllable count) and must CROSS a
+ *     word boundary (a one-word cover is ordinary rhyme, handled elsewhere);
+ *   • every nucleus must match its opposite number;
+ *   • the consonant runs between nuclei must match, except AT MOST ONE run may
+ *     differ (by substitution or one phone of length) — the re-segmentation
+ *     fudge that makes tender-LY ~ slender-SEE (L→S) and ~ slender-BE (L→B)
+ *     ring true, while "tenderly / slender seed" (two differing runs) fails.
+ * This is inherently beyond a one-word-at-a-time rhyme dictionary (Nounsing);
+ * only the line-holding layer can see it.
+ */
+export declare function classifyMosaicPair(tailA: string[], tailB: string[]): RhymePair | null;
 export interface LineRhyme {
     endWord: string;
     letter: string;
@@ -14,8 +42,12 @@ export interface LineRhyme {
     matchedLine?: number;
 }
 /** Detect a stanza's rhyme scheme from its line-end words.  Strong rhymes
- *  bind; slant-tier rhymes bind only when no strong candidate exists. */
-export declare function detectScheme(endWords: string[]): LineRhyme[];
+ *  bind; slant-tier rhymes bind only when no strong candidate exists.  When
+ *  `endTails` (each line's last few words) is supplied, a MOSAIC multi-word
+ *  rhyme is tried wherever the single-word pair yields nothing strong — the
+ *  mosaic verdict outranks a looser single-word slant reading ("tenderly /
+ *  slender — see?" is mosaic, not a wrenched hunch on tenderly/see). */
+export declare function detectScheme(endWords: string[], endTails?: string[][]): LineRhyme[];
 /**
  * Annotate rhyme letters/types (`detail.rhyme`) and form verdicts
  * (`detail.formNote`) across a poem.  Stanza forms are per-stanza; a poem-level

package/dist/rhyme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rhyme.d.ts","sourceRoot":"","sources":["../src/rhyme.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAW,UAAU,EAA8B,WAAW,EAAE,MAAM,YAAY,CAAC;AAK1F,MAAM,MAAM,aAAa,GACrB,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAC3C,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,GACrD,UAAU,GAAG,KAAK,CAAC;AAEvB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,uFAAuF;IACvF,SAAS,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;CACnD;AA6DD,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAkDxE;AAQD,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;yEACyE;AACzE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CA6C5D;AA6MD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,IAAI,CAkB/D;AAsCD,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IAAG,OAAO,EAAE,MAAM,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;IAClC,SAAS,EAAE,WAAW,CAAC;CACxB;AACD,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,QAAQ,EAAE,CAAC;IAChB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACnD,SAAS,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnE;AAED;0EAC0E;AAC1E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,YAAY,CAsIzE;AAgCD,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;CAAE;AA2B9D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,WAAW,EAAE,CA0DpE"}
+{"version":3,"file":"rhyme.d.ts","sourceRoot":"","sources":["../src/rhyme.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAW,UAAU,EAA8B,WAAW,EAAE,MAAM,YAAY,CAAC;AAK1F,MAAM,MAAM,aAAa,GACrB,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAC3C,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,GACrD,aAAa,GAAG,QAAQ,GACxB,UAAU,GAAG,KAAK,CAAC;AAEvB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,uFAAuF;IACvF,SAAS,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;CACnD;AA6DD,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA8ExE;AASD;;;;;;;;6EAQ6E;AAC7E,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAIjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,IAAI,CAErF;AAwED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;wEAKwE;AACxE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,SAAS,EAAE,CAiDnF;AAmND;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,IAAI,CAkB/D;AAsCD,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IAAG,OAAO,EAAE,MAAM,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;IAClC,SAAS,EAAE,WAAW,CAAC;CACxB;AACD,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,QAAQ,EAAE,CAAC;IAChB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACnD,SAAS,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnE;AAED;0EAC0E;AAC1E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,YAAY,CAsIzE;AAgCD,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;CAAE;AA2B9D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,WAAW,EAAE,CA0DpE"}

package/dist/rhyme.js

@@ -120,15 +120,42 @@ export function classifyRhymePair(a, b) {
     if (vowelSame) {
         // Same stressed vowel.  Matching-length codas whose consonants pair up
         // within one phonetic family (wet/deck, dame/grain) → family rhyme.
-        if (codaA.length === codaB.length && codaA.length > 0
+        // The segments must ALSO be the same length overall — the coda test
+        // filters vowels out, so without the length gate an extra tail syllable
+        // vanishes and fun/funny reads "family" (it is grammatical, below).
+        if (na.length === nb.length && codaA.length === codaB.length && codaA.length > 0
             && codaA.every((p, i) => p === codaB[i] || sameFamily(p, codaB[i]))) {
             return { type: 'family', structure };
         }
-        // One extra trailing consonant on the second/first word (bray/brave).
-        if (codaA.length + 1 === codaB.length && codaA.every((p, i) => p === codaB[i]))
+        // AUGMENTED / DIMINISHED (poemshape's Dickinson taxonomy): the rhyme is
+        // "extended by a consonant" — ONE extra TERMINAL consonant on one side,
+        // compared over the FULL rhyme segments, vowels included (bray/brave,
+        // grow/sown, stained/rain; manner/manners feminine).  The previous
+        // coda-only comparison filtered the tail's unstressed VOWELS away before
+        // comparing, so a whole extension syllable could masquerade as a terminal
+        // consonant (pun/running "augmented", floating/float "diminished") — the
+        // same corruption the maintainer traced in Nounsing's search lineage.
+        const extraTerminalConsonant = (shorter, longer) => longer.length === shorter.length + 1 &&
+            shorter.every((p, i) => p === longer[i]) &&
+            !isVowelPhone(longer[longer.length - 1]);
+        if (extraTerminalConsonant(na, nb))
             return { type: 'augmented', structure };
-        if (codaB.length + 1 === codaA.length && codaB.every((p, i) => p === codaA[i]))
+        if (extraTerminalConsonant(nb, na))
             return { type: 'diminished', structure };
+        // GRAMMATICAL rhyme: matching stressed vowel at the roots, distinct
+        // INFLECTIONAL tails (pun/running, fun/funny, float/floating).  One full
+        // segment is a proper prefix of the other, the excess is SYLLABIC
+        // (contains a vowel — a bare terminal consonant was aug/dim above), and
+        // the longer word's spelling ends in a closed inflectional suffix.
+        const shorterFirst = na.length <= nb.length;
+        const segS = shorterFirst ? na : nb;
+        const segL = shorterFirst ? nb : na;
+        const wordL = shorterFirst ? wb : wa;
+        if (segL.length > segS.length && segS.every((p, i) => p === segL[i])
+            && segL.slice(segS.length).some(p => isVowelPhone(p))
+            && GRAMMATICAL_TAILS.some(t => wordL.endsWith(t))) {
+            return { type: 'grammatical', structure };
+        }
         return { type: 'assonant', structure };
     }
     if (codaEq && codaA.length > 0)
@@ -136,20 +163,153 @@ export function classifyRhymePair(a, b) {
     const t = orthographicTier(a, b, pa, pb);
     return t ? { type: t } : null;
 }
+/** Closed inflectional/light-derivational tails for the GRAMMATICAL rhyme
+ *  test (spelling-level; the phone-level prefix condition does the real work). */
+const GRAMMATICAL_TAILS = [
+    'ings', 'ing', "in'", 'ied', 'ies', 'ed', 'es', 'ers', 'er', 'est', 'eth',
+    'ly', 'y', 's', "'d", "'st",
+];
+/** A BEAT-BEARING end-rhyme between two line-end words — the bar the stanza
+ *  rhyme-fellow pass (index.ts markRhymeFellows) requires before a weak
+ *  line-final monosyllable may inherit a beat from its rhyme partner.  Beyond
+ *  the STRONG tier (perfect/rich/family) it admits AUGMENTED and DIMINISHED
+ *  pairs: their stressed vowel is identical and they differ by ONE terminal
+ *  consonant, so the correspondence is still carried audibly by the final
+ *  beat ("me"/"dream", "sea"/"seed").  Identical repetition is excluded
+ *  (epistrophe, not a prominence template), as are the looser slant tiers
+ *  (assonant/consonant/grammatical/wrenched/eye) — a hunch is not a beat. */
+export function isBeatTransferRhyme(a, b) {
+    const r = classifyRhymePair(a, b);
+    if (!r || r.type === 'identical')
+        return false;
+    return STRONG.has(r.type) || r.type === 'augmented' || r.type === 'diminished';
+}
+/**
+ * MOSAIC (multi-word) end-rhyme — Byron's "intellectual / hen-pecked you all";
+ * the maintainer's "TENderly / SLENder — SEE?".  One line's POLYSYLLABIC rhyme
+ * part (its final word's last stressed vowel + everything after, ≥2 syllables)
+ * is covered by a SEQUENCE of words at the other line's end, the rhyme domain
+ * re-segmented across the word boundary.  Detection is nucleus-aligned:
+ *   • the covering span opens on a STRESSED vowel exactly n syllables from the
+ *     line end (n = the anchor's rhyme-part syllable count) and must CROSS a
+ *     word boundary (a one-word cover is ordinary rhyme, handled elsewhere);
+ *   • every nucleus must match its opposite number;
+ *   • the consonant runs between nuclei must match, except AT MOST ONE run may
+ *     differ (by substitution or one phone of length) — the re-segmentation
+ *     fudge that makes tender-LY ~ slender-SEE (L→S) and ~ slender-BE (L→B)
+ *     ring true, while "tenderly / slender seed" (two differing runs) fails.
+ * This is inherently beyond a one-word-at-a-time rhyme dictionary (Nounsing);
+ * only the line-holding layer can see it.
+ */
+export function classifyMosaicPair(tailA, tailB) {
+    return mosaicDirected(tailA, tailB) ?? mosaicDirected(tailB, tailA);
+}
+function mosaicDirected(anchorTail, coverTail) {
+    if (anchorTail.length === 0 || coverTail.length < 2)
+        return null;
+    const anchorWord = anchorTail[anchorTail.length - 1];
+    const pa = phonesOf(anchorWord);
+    if (!pa)
+        return null;
+    const ia = lastStressedIdx(pa);
+    if (ia < 0)
+        return null;
+    const ra = pa.slice(ia);
+    const nA = ra.filter(p => isVowelPhone(p)).length;
+    if (nA < 2)
+        return null; // needs a feminine/dactylic anchor
+    const perWord = [];
+    for (const w of coverTail) {
+        const p = phonesOf(w);
+        if (!p)
+            return null;
+        perWord.push(p);
+    }
+    const combined = perWord.flat();
+    const lastWordStart = combined.length - perWord[perWord.length - 1].length;
+    // The covering span opens at the vowel sitting nA nuclei from the line end.
+    let seen = 0;
+    let p0 = -1;
+    for (let i = combined.length - 1; i >= 0; i--) {
+        if (isVowelPhone(combined[i])) {
+            seen++;
+            if (seen === nA) {
+                p0 = i;
+                break;
+            }
+        }
+    }
+    if (p0 < 0)
+        return null;
+    if (!/[12]$/.test(combined[p0]))
+        return null; // span opens on a stressed vowel
+    if (p0 >= lastWordStart)
+        return null; // must cross a word boundary
+    const rb = combined.slice(p0);
+    // Nucleus-by-nucleus alignment with the one-run fudge.
+    const decompose = (seg) => {
+        const nuclei = [];
+        const runs = [];
+        let cur = [];
+        for (const p of seg) {
+            if (isVowelPhone(p)) {
+                if (nuclei.length)
+                    runs.push(cur);
+                cur = [];
+                nuclei.push(base(p));
+            }
+            else {
+                cur.push(base(p));
+            }
+        }
+        runs.push(cur); // final coda
+        return { nuclei, runs };
+    };
+    const A = decompose(ra);
+    const B = decompose(rb);
+    if (A.nuclei.length !== B.nuclei.length)
+        return null;
+    if (A.nuclei.some((v, i) => v !== B.nuclei[i]))
+        return null;
+    let fudged = 0;
+    for (let i = 0; i < A.runs.length; i++) {
+        const x = A.runs[i];
+        const y = B.runs[i];
+        if (x.length === y.length && x.every((p, k) => p === y[k]))
+            continue;
+        if (Math.abs(x.length - y.length) <= 1) {
+            fudged++;
+            continue;
+        }
+        return null;
+    }
+    if (fudged > 1)
+        return null;
+    return { type: 'mosaic', structure: nA === 2 ? 'feminine' : 'dactylic' };
+}
 // Strength tiers for scheme detection.
 const STRONG = new Set(['identical', 'rich', 'perfect', 'family']);
-const SLANT = new Set(['assonant', 'consonant', 'augmented', 'diminished', 'wrenched', 'eye']);
+const SLANT = new Set(['assonant', 'consonant', 'augmented', 'diminished', 'grammatical', 'mosaic', 'wrenched', 'eye']);
 // Full rhyme only — the stricter bar a pre-caesural INTERNAL rhyme must clear.
 const STRICT_INTERNAL = new Set(['identical', 'rich', 'perfect']);
 /** Detect a stanza's rhyme scheme from its line-end words.  Strong rhymes
- *  bind; slant-tier rhymes bind only when no strong candidate exists. */
-export function detectScheme(endWords) {
+ *  bind; slant-tier rhymes bind only when no strong candidate exists.  When
+ *  `endTails` (each line's last few words) is supplied, a MOSAIC multi-word
+ *  rhyme is tried wherever the single-word pair yields nothing strong — the
+ *  mosaic verdict outranks a looser single-word slant reading ("tenderly /
+ *  slender — see?" is mosaic, not a wrenched hunch on tenderly/see). */
+export function detectScheme(endWords, endTails) {
     const out = [];
     let nextLetter = 0;
     for (let i = 0; i < endWords.length; i++) {
         let best = null;
         for (let j = i - 1; j >= 0; j--) {
-            const pair = classifyRhymePair(endWords[j], endWords[i]);
+            let pair = classifyRhymePair(endWords[j], endWords[i]);
+            if ((!pair || !STRONG.has(pair.type)) && endTails?.[j]?.length && endTails?.[i]?.length) {
+                const m = classifyMosaicPair(endTails[j], endTails[i]);
+                if (m)
+                    pair = m;
+            }
             if (!pair)
                 continue;
             if (STRONG.has(pair.type)) {
@@ -327,6 +487,11 @@ function lineEndWord(line) {
     const ws = lineWords(line);
     return ws.length ? surfaceOf(ws[ws.length - 1]) : '';
 }
+/** The line's last few syllable-bearing words — the material a MOSAIC
+ *  multi-word rhyme may re-segment across (classifyMosaicPair). */
+function lineEndTail(line, maxWords = 4) {
+    return lineWords(line).slice(-maxWords).map(surfaceOf);
+}
 // ─── INTERNAL (PRE-CAESURAL) RHYME — additive layer ─────────────────
 //
 // The per-stanza END-rhyme scheme (detectScheme) is the primary, UNTOUCHED
@@ -444,7 +609,7 @@ export function applyRhymeAndForm(stanzas) {
     // stanza) — that is what couplet/quatrain/sonnet patterns are defined over.
     const analyzed = stanzas.map(lines => {
         const details = lines.map(l => l.phonologicalScansion);
-        const rhymes = detectScheme(lines.map(lineEndWord));
+        const rhymes = detectScheme(lines.map(lineEndWord), lines.map(l => lineEndTail(l)));
         return { lines, details, rhymes };
     });
     for (const { details, rhymes } of analyzed) {
@@ -514,7 +679,7 @@ export function analyzePhonopoetics(stanzas) {
     };
     // ── Phase 1: END rhymes (poem-wide) ──
     const endWords = PLs.map(pl => lineEndWord(pl.line));
-    const es = detectScheme(endWords);
+    const es = detectScheme(endWords, PLs.map(pl => lineEndTail(pl.line)));
     const endScheme = canonicalScheme(es);
     const byLetter = new Map();
     es.forEach((r, i) => { if (r.letter !== '·') {
@@ -740,7 +905,7 @@ export function summarizePoem(stanzas) {
     // ── Form — the form layer's verdict(s) + registry-scheme alignment.  (The
     // detailed rhyme listing now lives in the Phonopoetics section; the synopsis
     // carries only the canonical End-Rhyme Scheme, below.) ──
-    const endRhymes = N >= 2 ? detectScheme(lines.map(lineEndWord)) : [];
+    const endRhymes = N >= 2 ? detectScheme(lines.map(lineEndWord), lines.map(l => lineEndTail(l))) : [];
     const endScheme = endRhymes.length ? canonicalScheme(endRhymes) : '';
     const hasEndRhyme = endRhymes.some(r => r.letter !== '·');
     const forms = [...new Set(details.map(d => d.formNote).filter((x) => !!x))];

package/dist/russian/accentuator.d.ts

@@ -0,0 +1,31 @@
+interface AccentsData {
+    wordAccents: Map<string, number>;
+    ambiguousAccents: Record<string, Record<string, string[]>>;
+    ambiguousAccents2: Record<string, number[]>;
+    yoWords: Record<string, string>;
+    yoByGram: Record<string, any>;
+    secondaryStress: Record<string, number[]>;
+    rhymedWords: Set<[string, string]>;
+    rhymingDict: Record<string, string[]>;
+    derivationData: any;
+}
+declare function loadJson<T>(filename: string): T;
+/** Load a JSON data file (used by other modules). */
+export { loadJson };
+export interface AccentResult {
+    stressPos: number;
+    secondaryStress: number[] | null;
+    ambiguous: boolean;
+    allStressPositions: number[];
+}
+/** Apply ёфикация: replace 'е' with 'ё' where appropriate. */
+export declare function yoficate(word: string, feats?: Record<string, string>, upos?: string): string;
+/** Get all accentuations for a word (multi-variant, like original get_accents). */
+export declare function getAccents(word: string, feats?: Record<string, string>, upos?: string): AccentResult[];
+/** Get stress position for a word, using dictionary + neural MLP fallback. */
+export declare function getAccent(word: string, feats?: Record<string, string>, upos?: string): AccentResult;
+/** Render a word with stress mark (U+0301 for primary, U+0300 for secondary). */
+export declare function renderStressedWord(word: string, accent: AccentResult): string;
+/** Get the data handle (for rhyme module). */
+export declare function getAccentsData(): AccentsData;
+//# sourceMappingURL=accentuator.d.ts.map

package/dist/russian/accentuator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accentuator.d.ts","sourceRoot":"","sources":["../../src/russian/accentuator.ts"],"names":[],"mappings":"AAuBA,UAAU,WAAW;IACnB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IAC3D,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC1C,WAAW,EAAE,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACtC,cAAc,EAAE,GAAG,CAAC;CACrB;AAID,iBAAS,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,CAGxC;AAED,qDAAqD;AACrD,OAAO,EAAE,QAAQ,EAAE,CAAC;AAuMpB,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CA+ChG;AAwCD,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE,CA8E1G;AAED,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,YAAY,CAqHvG;AAsED,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAe7E;AAED,8CAA8C;AAC9C,wBAAgB,cAAc,IAAI,WAAW,CAE5C"}