calliope-ts 0.0.2 → 0.0.3

package/dist/display.js

@@ -3,6 +3,9 @@
 import chalk from 'chalk';
 import { isPunctuation } from './parser.js';
 import { syllabifyWord, syllableVowelLengths } from './phonological.js';
+import { computeCaesurae } from './caesura.js';
+import { computeBoundaries } from './calliope/boundaries.js';
+import { summarizePoem, analyzePhonopoetics } from './rhyme.js';
 // ═══════════════════════════════════════════════════════════════════════
 // COLOUR SYSTEM — Conceptually motivated palettes
 // ═══════════════════════════════════════════════════════════════════════
@@ -51,6 +54,38 @@ const B_CAESURA = chalk.whiteBright.bold; // hard caesura (overt: punctuation /
 const B_CAESURA_SOFT = chalk.cyan.dim; // inferred caesura (phonological-phrase pause)
 const B_FOOT = chalk.gray;
 const B_SILENT = chalk.gray.dim;
+// ── Graded boundary-strength colour (Wagner Ch.4–5): cold blue (weak) → warm red
+// (strong).  The relational grid says boundaries differ in DEGREE, not just kind, so
+// ϕ/ι brackets are tinted along a continuous spectrum by their NSBR-scaled strength
+// (boundaries.ts).  κ (clitic-group) boundaries are the weakest tier — a constant dim
+// blue.  This makes the boundary-strength dimension VISIBLE in the bracketing view.
+const GRAD_STOPS = [
+    [0.00, [0x6a, 0x8c, 0xc7]], // cold blue
+    [0.30, [0x5f, 0xc7, 0xc0]], // teal
+    [0.55, [0xd9, 0xc2, 0x4d]], // yellow
+    [0.78, [0xe0, 0x91, 0x3f]], // orange
+    [1.00, [0xe0, 0x56, 0x4b]], // red
+];
+function gradHex(t) {
+    const x = Math.max(0, Math.min(1, t));
+    for (let i = 1; i < GRAD_STOPS.length; i++) {
+        const [t1, c1] = GRAD_STOPS[i - 1];
+        const [t2, c2] = GRAD_STOPS[i];
+        if (x <= t2) {
+            const f = t2 === t1 ? 0 : (x - t1) / (t2 - t1);
+            const r = Math.round(c1[0] + (c2[0] - c1[0]) * f);
+            const g = Math.round(c1[1] + (c2[1] - c1[1]) * f);
+            const b = Math.round(c1[2] + (c2[2] - c1[2]) * f);
+            return '#' + [r, g, b].map(v => v.toString(16).padStart(2, '0')).join('');
+        }
+    }
+    return '#e0564b';
+}
+/** Colour for a ϕ/ι bracket given its boundary strength (0..1). */
+function boundaryColour(strength) {
+    return (s) => chalk.hex(gradHex(strength))(s);
+}
+const B_KAPPA = (s) => chalk.hex('#5a6f9e').dim(s); // κ — weakest, dim blue
 // Word roles
 const W_CONTENT = chalk.white;
 const W_FUNCTION = chalk.gray;
@@ -75,7 +110,7 @@ function buildColSyls(words, ius) {
                         continue;
                     const dep = w.dependency;
                     const sylCount = w.syllables.length;
-                    const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix);
+                    const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix, w.morphPrefix);
                     for (let si = 0; si < sylCount; si++) {
                         const syl = w.syllables[si];
                         const lex = syl.lexicalStress ?? syl.stress;
@@ -106,10 +141,31 @@ function buildColSyls(words, ius) {
                             wordRef: w,
                         });
                     }
+                    // A 0-syllable possessive enclitic ('s) has no syllable column of its own;
+                    // append its surface to the preceding syllable so "Nature's" renders WITH its
+                    // 's instead of as bare "Nature" (and so its κ-boundary does not collapse into
+                    // the next group — the "Nature first" mis-bracketing the maintainer flagged).
+                    if (sylCount === 0 && w.lexicalClass === 'POS' && result.length > 0) {
+                        result[result.length - 1].chunk += w.word;
+                    }
                 }
             }
         }
     }
+    // Bracket-boundary flags via look-around over the SYLLABLE-bearing columns, so a
+    // 0-syllable token (possessive 's, an elided clitic) can never swallow a κ/ϕ/ι
+    // boundary: a column is first/last in its unit when the adjacent column belongs to a
+    // different unit.  (Composite key, since cpId/ppId are indices LOCAL to their parent.)
+    const uKey = (c, lvl) => lvl === 'cp' ? `${c.iuId}.${c.ppId}.${c.cpId}` : lvl === 'pp' ? `${c.iuId}.${c.ppId}` : `${c.iuId}`;
+    for (let i = 0; i < result.length; i++) {
+        const cur = result[i], prev = result[i - 1], next = result[i + 1];
+        result[i].isFirstInCP = !prev || uKey(prev, 'cp') !== uKey(cur, 'cp');
+        result[i].isLastInCP = !next || uKey(next, 'cp') !== uKey(cur, 'cp');
+        result[i].isFirstInPP = !prev || uKey(prev, 'pp') !== uKey(cur, 'pp');
+        result[i].isLastInPP = !next || uKey(next, 'pp') !== uKey(cur, 'pp');
+        result[i].isFirstInIU = !prev || uKey(prev, 'iu') !== uKey(cur, 'iu');
+        result[i].isLastInIU = !next || uKey(next, 'iu') !== uKey(cur, 'iu');
+    }
     return result;
 }
 // ═══════════════════════════════════════════════════════════════════════
@@ -181,6 +237,32 @@ export function renderUnifiedDisplay(result, rawLine) {
     }
     lines.push('  ' + lexParts.join(''));
     lines.push('');
+    // ── Layer 3b: Phrase stress (genuine cyclic Compound + Nuclear Stress Rules) ───
+    // The real phrase-stress stage (bracketing.ts): the SPE/Hayes cyclic CSR (compound
+    // → primary LEFT) + NSR (phrase → primary RIGHT) over the dependency tree's
+    // constituent bracketing.  1 = STRONGEST (the utterance nuclear); higher = weaker.
+    // Reproduces "Mary 2, ate 3, sweet 4, ice 1, cream 5".  An integer prominence
+    // ranking, computed INDEPENDENTLY of the relative contour below.
+    lines.push(H1('Phrase Stress') + '  ' + chalk.dim('1 = strongest (utterance nuclear) → higher = weaker · 0 = none'));
+    lines.push('');
+    const phrParts = [];
+    for (const cs of colSyls) {
+        if (cs.isFirstInWord && cs.globalIdx > 0)
+            phrParts.push(' ');
+        if (cs.isFirstInWord) {
+            const ps = cs.wordRef.phraseStress || 0;
+            const colour = ps === 0 ? chalk.dim
+                : ps === 1 ? chalk.cyanBright // the utterance nuclear (strongest)
+                    : ps <= 3 ? chalk.cyan // strong
+                        : chalk.dim; // weak / deeply demoted
+            phrParts.push(colour(String(ps)));
+        }
+        else {
+            phrParts.push(' '); // continuation syllable — keep word-start alignment
+        }
+    }
+    lines.push('  ' + phrParts.join(''));
+    lines.push('');
     // ── Layer 4: Relative stress (w/n/m/s) ──────────────────────────
     lines.push(H1('Relative Stress') + '  ' + REL_X('x') + REL_W('w') + REL_N('n') + REL_M('m') + REL_S('s') + '  (zero‑provision→weak→low→moderate→strong)');
     lines.push('');
@@ -192,37 +274,52 @@ export function renderUnifiedDisplay(result, rawLine) {
     }
     lines.push('  ' + relParts.join(''));
     lines.push('');
-    // ── Layer 5: Phonological bracketing ────────────────────────────
-    lines.push(H1('Phonological Bracketing') + '  ' + B_CP('[]') + ' CP  ' + B_PP('{}') + ' PP  ' + B_IU('<>') + ' IU');
+    // ── Layer 5: Phonological bracketing (graded by boundary strength) ──────
+    lines.push(H1('Phonological Bracketing') + '  ' + B_KAPPA('[]') + ' κ  ' + B_PP('{}') + ' ϕ  ' + B_IU('<>') + ' ι' +
+        chalk.dim('   — ϕ/ι tint: ') + boundaryColour(0.1)('weak') + chalk.dim('→') + boundaryColour(1)('strong'));
     lines.push('');
+    // Graded boundary strengths (NSBR, boundaries.ts), zipped to the ϕ/ι opens as we
+    // walk the syllable columns: each ϕ is tinted by the strength of the break that
+    // introduced it (its left-edge boundary); κ stays the weakest dim-blue tier.
+    const bounds = computeBoundaries(words, ius);
+    let phiOrd = -1;
+    let ppColourFn = B_PP;
+    let iuColourFn = B_IU;
     const sylParts = [];
     let iuOpen = false, ppOpen = false, cpOpen = false;
     for (const cs of colSyls) {
+        if (cs.isFirstInPP) {
+            phiOrd++;
+            const st = bounds.phi[phiOrd]?.strength ?? 0;
+            ppColourFn = boundaryColour(st);
+            if (cs.isFirstInIU)
+                iuColourFn = boundaryColour(st);
+        }
         if (cs.isFirstInIU && !iuOpen) {
-            sylParts.push(B_IU('<'));
+            sylParts.push(iuColourFn('<'));
             iuOpen = true;
         }
         if (cs.isFirstInPP && !ppOpen) {
-            sylParts.push(B_PP('{'));
+            sylParts.push(ppColourFn('{'));
             ppOpen = true;
         }
         if (cs.isFirstInCP && !cpOpen) {
-            sylParts.push(B_CP('['));
+            sylParts.push(B_KAPPA('['));
             cpOpen = true;
         }
         if (cs.isFirstInWord && cs.globalIdx > 0)
             sylParts.push(' ');
         sylParts.push(relColour(cs.relStress)(cs.chunk));
         if (cs.isLastInCP && cpOpen) {
-            sylParts.push(B_CP(']'));
+            sylParts.push(B_KAPPA(']'));
             cpOpen = false;
         }
         if (cs.isLastInPP && ppOpen) {
-            sylParts.push(B_PP('}'));
+            sylParts.push(ppColourFn('}'));
             ppOpen = false;
         }
         if (cs.isLastInIU && iuOpen) {
-            sylParts.push(B_IU('>'));
+            sylParts.push(iuColourFn('>'));
             iuOpen = false;
         }
     }
@@ -238,7 +335,7 @@ export function renderUnifiedDisplay(result, rawLine) {
         if (isPunctuation(w.lexicalClass))
             continue;
         const sylCount = w.syllables.length;
-        const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix);
+        const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix, w.morphPrefix);
         for (let si = 0; si < sylCount; si++) {
             linearSyls.push({
                 chunk: chunks[si] || w.word,
@@ -253,8 +350,20 @@ export function renderUnifiedDisplay(result, rawLine) {
     function isSyllableChar(ch) {
         return 'xXwWnNmMsS'.includes(ch);
     }
+    // Feet whose right edge carries a caesura take the caesura GLYPH as their
+    // separator (matching the reading view's "xs ‖ xnw"), never a doubled "‖ |".
+    const joinFeet = (feet, caesAfter) => {
+        let out = '';
+        for (let i = 0; i < feet.length; i++) {
+            out += feet[i];
+            if (i < feet.length - 1)
+                out += caesAfter[i] ? ' ' : B_FOOT(' | ');
+        }
+        return out;
+    };
     let sylIdx = 0;
     const footDisplays = [];
+    const footCaes = [];
     let prevWordRef = null;
     for (const rawFoot of feetRaw) {
         let footOut = '';
@@ -277,10 +386,12 @@ export function renderUnifiedDisplay(result, rawLine) {
         const ck = caesurae.get(sylIdx);
         if (ck)
             footOut += ' ' + caesuraGlyph(ck);
+        footCaes.push(!!ck);
         footDisplays.push(footOut);
     }
-    lines.push('  ' + H2('Feet:   ') + footDisplays.join(B_FOOT(' | ')));
+    lines.push('  ' + H2('Feet:   ') + joinFeet(footDisplays, footCaes));
     const stressDisplays = [];
+    const stressCaes = [];
     let rIdx = 0;
     for (const rawFoot of feetRaw) {
         let s = '';
@@ -299,9 +410,10 @@ export function renderUnifiedDisplay(result, rawLine) {
         const ck2 = caesurae.get(rIdx);
         if (ck2)
             s += ' ' + caesuraGlyph(ck2);
+        stressCaes.push(!!ck2);
         stressDisplays.push(s);
     }
-    lines.push('  ' + H2('Stress: ') + stressDisplays.join(B_FOOT(' | ')));
+    lines.push('  ' + H2('Stress: ') + joinFeet(stressDisplays, stressCaes));
     lines.push('');
     // ── Layer 7: Dependencies ───────────────────────────────────────
     lines.push(H1('Dependencies'));
@@ -550,7 +662,7 @@ function normWordForm(s) {
 /** Colour each orthographic syllable of an original token by its relative stress. */
 function colourToken(tokenText, word) {
     const sylCount = Math.max(1, word.syllables.length);
-    const chunks = syllabifyWord(tokenText, sylCount, syllableVowelLengths(word.syllables), word.morphSuffix); // partitions the WHOLE token
+    const chunks = syllabifyWord(tokenText, sylCount, syllableVowelLengths(word.syllables), word.morphSuffix, word.morphPrefix); // partitions the WHOLE token
     const stresses = chunks.map((_, i) => word.syllables[i]?.relativeStress ?? 'w');
     // Fast path: chunks reconstruct the token exactly (the common case).
     if (chunks.join('') === tokenText) {
@@ -633,113 +745,17 @@ export function projectStressOntoLine(rawLine, words) {
     out += rawLine.slice(cursor); // trailing text, verbatim
     return out;
 }
-/** Foot-boundary syllable indices from a scansion string (cumulative syllable
- *  count after each foot; silent beats '-' are not syllables). */
-function footBoundarySet(scansion) {
-    const set = new Set();
-    let c = 0;
-    for (const foot of scansion.split('|')) {
-        for (const ch of foot)
-            if ('xwnms'.includes(ch))
-                c++;
-        set.add(c);
-    }
-    return set;
-}
-// A new phonological/syntactic phrase opens at these POS tags: prepositions &
-// subordinators (IN), infinitival "to" (TO), coordinators (CC), wh/relativizers,
-// verb-particles (RP), and the predicate's verb/modal.  The major medial caesura
-// of a line falls immediately BEFORE such a word — far more reliably read off the
-// (robust) POS tags than off FinNLP's (noisy) phonological-phrase grouping, which
-// mis-bracketed e.g. "The epic | feast…".  Determiners/articles are excluded (they
-// continue a phrase a preposition already opened: "as | one empty bag").
-const PHRASE_ONSET_POS = new Set([
-    'IN', 'TO', 'CC', 'WDT', 'WP', 'WP$', 'WRB', 'RP',
-    'VB', 'VBD', 'VBG', 'VBN', 'VBP', 'VBZ', 'MD',
-]);
-// Directional/spatial adverbs that open a phrase ("snowed-in OUT of many routes",
-// "drifting DOWN to sleep").  FinNLP often tags these RB rather than RP/IN, so the
-// POS set alone misses them; a small curated lemma list recovers them with low
-// over-fire risk (a generic RB like "very"/"quickly" is NOT a phrase onset).
-const DIRECTIONAL_ONSET = new Set([
-    'out', 'in', 'up', 'down', 'off', 'away', 'back', 'forth', 'over',
-    'around', 'along', 'through', 'apart', 'aside', 'onward', 'onwards',
-]);
-/** True if a word opens a new phonological/syntactic phrase (a caesura candidate). */
-function isPhraseOnset(w) {
-    if (PHRASE_ONSET_POS.has(w.lexicalClass))
-        return true;
-    return w.lexicalClass === 'RB' && DIRECTIONAL_ONSET.has(w.word.toLowerCase());
-}
-/**
- * Caesura positions for a line, keyed by the syllable index AFTER which the pause
- * falls (= number of syllables to its left).
- *  • 'hard' — an overt break at an Intonational-Unit boundary (comma, dash, colon,
- *    semicolon …): the punctuation projection.
- *  • 'soft' — a single INFERRED medial caesura for a punctuation-free line (Kiparsky
- *    1975, via McAleese: "phonological phrasing determines the location of caesurae
- *    in verse").  Candidates are the boundaries just before a phrase/clause onset
- *    (PHRASE_ONSET_POS); the one nearest the line's midpoint that lies in the
- *    central third AND coincides with a foot boundary wins — so it is medial, never
- *    mid-foot, and consistent across structurally-parallel lines.  Read in LINEAR
- *    order (robust to clitic-group reordering); needs a line of ≥ 8 syllables.
- */
-function computeCaesurae(words, ius, scansion) {
-    const caes = new Map();
-    const iuOf = new Map();
-    for (let i = 0; i < ius.length; i++) {
-        for (const pp of ius[i].phonologicalPhrases) {
-            for (const cg of pp.cliticGroups)
-                for (const tok of cg.tokens)
-                    iuOf.set(tok, i);
-        }
-    }
-    let cum = 0;
-    let prevIu;
-    let prevWasContentful = false;
-    const onsetPositions = [];
-    for (const w of words) {
-        if (isPunctuation(w.lexicalClass) || w.syllables.length === 0)
-            continue;
-        const iu = iuOf.get(w);
-        if (prevIu !== undefined && iu !== undefined && iu !== prevIu) {
-            caes.set(cum, 'hard'); // IU boundary → hard caesura
-        }
-        // A phrase-onset word that is NOT the line's first word opens a candidate
-        // caesura immediately before it.
-        if (prevWasContentful && isPhraseOnset(w))
-            onsetPositions.push(cum);
-        cum += w.syllables.length;
-        prevIu = iu;
-        prevWasContentful = true;
-    }
-    const total = cum;
-    // Infer ONE medial caesura only when the line carries no overt (hard) break.
-    if (caes.size === 0 && total >= 8 && onsetPositions.length > 0) {
-        const footEdges = scansion ? footBoundarySet(scansion) : null;
-        const mid = total / 2;
-        const lo = Math.max(2, Math.ceil(total / 3));
-        const hi = Math.floor((2 * total) / 3);
-        let best = -1, bestDist = Infinity;
-        for (const c of onsetPositions) {
-            if (c < lo || c > hi)
-                continue; // medial third only
-            if (footEdges && !footEdges.has(c))
-                continue; // align to a foot boundary
-            const d = Math.abs(c - mid);
-            if (d < bestDist) {
-                bestDist = d;
-                best = c;
-            }
-        }
-        if (best > 0)
-            caes.set(best, 'soft');
-    }
-    return caes;
-}
-/** Render the glyph for a caesura kind. */
-function caesuraGlyph(kind) {
-    return kind === 'hard' ? B_CAESURA('‖') : B_CAESURA_SOFT('¦');
+// ═══════════════════════════════════════════════════════════════════════
+// CAESURA RENDERING  (placement logic now lives in caesura.ts)
+// ═══════════════════════════════════════════════════════════════════════
+/** Render the glyph for a caesura, coloured by its boundary strength (Wagner
+ *  Ch.4–5): a strong break is a warm-red '‖', a medium one an orange '¦', a weak
+ *  one a dim '·' — the same cold-blue→warm-red spectrum as the brackets. */
+function caesuraGlyph(info) {
+    const glyph = info.kind === 'hard' ? '‖' : '¦';
+    if (info.strength < 0.34)
+        return chalk.hex(gradHex(info.strength))('·');
+    return chalk.hex(gradHex(info.strength)).bold(glyph);
 }
 /** Colour a scansion string ("nws|nns|-wns") letter-by-letter, inserting caesura
  *  marks (at foot boundaries) when a caesura map is supplied. */
@@ -778,13 +794,60 @@ const METER_ABBR = {
     amphibrachic: 'amph', bacchic: 'bacch', spondaic: 'spon', pyrrhic: 'pyrr',
     'free verse': 'free',
 };
-/** Compact top-3 meter fit scores, e.g. "(anap 0.81 · iamb 0.77 · amph 0.74)". */
+// ── Meter-family colours ───────────────────────────────────────────
+// One consistent, legible LIGHT tone per metre family, reused EVERYWHERE a
+// metre is named (the reading per-line meter, the top-3 ranking, and the
+// synopsis).  The foot-count label (pentameter / octameter…) stays white — we
+// tint only the family word, so the output is informative without being gaudy.
+const METER_HUE = {
+    iambic: chalk.hex('#7fb8ff'), // light blue
+    trochaic: chalk.hex('#ffc24d'), // yellow / orange
+    dactylic: chalk.hex('#88e0a0'), // mid / light green
+    amphibrachic: chalk.hex('#ff9ec4'), // pinkish
+    anapestic: chalk.hex('#ff7a6b'), // reddish
+    bacchic: chalk.hex('#c08be6'), // purple / wine
+    spondaic: chalk.hex('#b8b8b8'),
+    pyrrhic: chalk.hex('#b8b8b8'),
+};
+const METER_FALLBACK = chalk.hex('#cfd8e3'); // free verse / unknown
+/** Tint a metre-family WORD (the first token of a metre name) by its hue. */
+function meterFamilyColour(family) {
+    return METER_HUE[family.toLowerCase()] ?? METER_FALLBACK;
+}
+/** Colour a full metre label ("iambic pentameter"): family tinted, foot-count
+ *  label left white.  Bare "free verse" / multi-word non-families: fallback. */
+function colourMeterLabel(meter) {
+    const sp = meter.indexOf(' ');
+    if (sp < 0)
+        return meterFamilyColour(meter)(meter);
+    const family = meter.slice(0, sp);
+    const hue = METER_HUE[family.toLowerCase()];
+    if (!hue)
+        return METER_FALLBACK(meter);
+    return hue(family) + chalk.whiteBright(meter.slice(sp));
+}
+/** Tint every metre-family word/abbreviation occurring inside a free-form
+ *  string (used to colour the synopsis values without restructuring them).
+ *  Longest-first so "iamb" inside "iambic" is not matched before the full word. */
+const _METER_WORD_RE = /\b(iambic|trochaic|dactylic|amphibrachic|anapestic|bacchic|spondaic|pyrrhic|iamb|troch|dact|amph|anap|bacch|spon|pyrr)\b/gi;
+function tintMeterNames(s) {
+    return s.replace(_METER_WORD_RE, (w) => {
+        const key = w.toLowerCase();
+        const fam = key.startsWith('iamb') ? 'iambic' : key.startsWith('troch') ? 'trochaic'
+            : key.startsWith('dact') ? 'dactylic' : key.startsWith('amph') ? 'amphibrachic'
+                : key.startsWith('anap') ? 'anapestic' : key.startsWith('bacch') ? 'bacchic'
+                    : key.startsWith('spon') ? 'spondaic' : 'pyrrhic';
+        return meterFamilyColour(fam)(w);
+    });
+}
+/** Compact top-3 meter fit scores, e.g. "anap 0.81 · iamb 0.77 · amph 0.74" —
+ *  each family abbreviation tinted its hue, the score dimmed, no enclosing
+ *  parentheses (set off from the meter name by a dim "|" at the call site). */
 function formatRanking(ranking) {
     if (!ranking || ranking.length === 0)
         return '';
-    const top = ranking.slice(0, 3)
-        .map(r => `${METER_ABBR[r.meter] ?? r.meter} ${r.score.toFixed(2)}`);
-    return chalk.dim('(' + top.join(' · ') + ')');
+    const top = ranking.slice(0, 3).map(r => meterFamilyColour(r.meter)(METER_ABBR[r.meter] ?? r.meter) + chalk.dim(' ' + r.score.toFixed(2)));
+    return top.join(chalk.dim(' · '));
 }
 /** Divergence notes.  After the continuity rename, a near-tie line's BASE
  *  meter is already the stanza/poem-dominant one and `standaloneMeter` records
@@ -799,23 +862,35 @@ function consensusNote(detail) {
         return '';
     return chalk.dim.italic(`  ↔ aligns w/ stanza ${detail.consensusMeter}`);
 }
-/** Non-classical rhythm annotation (dolnik / taktovik / accentual /
- *  alternating ictus counts), set by the rhythm layer.  Empty when the line
- *  has no such reading. */
+/** Non-classical rhythm annotation (dolnik / taktovik / accentual), set by the
+ *  rhythm layer.  Shown as a separate chip AFTER the meter — it supplements the
+ *  classical reading (in beats), it never replaces it. */
 function rhythmNoteStr(detail) {
     if (!detail.rhythmNote)
         return '';
-    return chalk.magenta.dim(`  ♪ ${detail.rhythmNote}`);
+    const note = detail.rhythmNote;
+    // Some notes (the 4/3 accentual) already carry a ♪; don't double it.
+    return chalk.magenta.dim('  ' + (note.includes('♪') ? note : '♪ ' + note));
 }
-/** End-rhyme chip for a line: scheme letter plus (dimmed) rhyme type when the
- *  line rhymes with an earlier one — e.g. "B(perfect)"; '·' = unrhymed. */
+/** Rhyme chip for a line: the end-rhyme scheme letter with its rhyme TYPE
+ *  (e.g. "A(perfect)"; '·' = unrhymed), PLUS any pre-caesural INTERNAL rhymes,
+ *  each parenthesised and cyan with its own type, shown before the end letter:
+ *  e.g. "(C)(perfect) A(perfect)". */
 function rhymeStr(detail) {
-    if (!detail.rhyme)
+    const r = detail.rhyme;
+    if (!r)
         return '';
-    const { letter, type } = detail.rhyme;
-    if (letter === '·')
-        return '  ' + chalk.dim('·');
-    return '  ' + chalk.yellowBright(letter) + (type ? chalk.dim(`(${type})`) : '');
+    const parts = [];
+    for (const iw of r.internal ?? []) {
+        parts.push(chalk.cyan(`(${iw.letter})`) + (iw.type ? chalk.dim(`(${iw.type})`) : ''));
+    }
+    if (r.letter && r.letter !== '·') {
+        parts.push(chalk.yellowBright(r.letter) + (r.type ? chalk.dim(`(${r.type})`) : ''));
+    }
+    else if (parts.length === 0) {
+        parts.push(chalk.dim('·'));
+    }
+    return '  ' + parts.join(' ');
 }
 /** Non-punctuation, syllable-bearing words across all of a line's sentences. */
 function collectLineWords(ln) {
@@ -828,30 +903,105 @@ function collectLineWords(ln) {
     }
     return ws;
 }
+/**
+ * The Phonopoetics block of the synopsis: end / caesural / head rhymes (each
+ * letter coloured by the strongest relative-stress tier it spans), alliteration,
+ * and acrostics.  Only subsections actually present in the poem are shown.
+ */
+function renderPhonopoetics(p) {
+    // a rhyme pair "word [A|L1(|kind)] -> word [A|L4]", letter tinted by top stress
+    const rel = (r) => {
+        const L = relColour(r.topStress)(r.letter);
+        const D = chalk.dim;
+        const kindTag = r.kind === 'end' ? '' : D('|' + r.kind);
+        const typ = r.type ? D(` ${r.type}`) : '';
+        return chalk.white(r.fromWord) + ' ' + D('[') + L + D('|') + D(r.fromLabel) + kindTag + D(']')
+            + D(' → ') + chalk.white(r.toWord) + ' ' + D('[') + L + D('|') + D(r.toLabel) + D(']') + typ;
+    };
+    const SEP = chalk.dim('  ·  ');
+    const sub = [];
+    if (p.end.length)
+        sub.push({ label: 'End-Rhymes', body: p.end.map(rel).join(SEP) });
+    if (p.caesural.length)
+        sub.push({ label: 'Caesural Rhymes', body: p.caesural.map(rel).join(SEP) });
+    if (p.head.length)
+        sub.push({ label: 'Head Rhymes', body: p.head.map(rel).join(SEP) });
+    if (p.alliteration.length)
+        sub.push({
+            label: 'Alliteration',
+            body: p.alliteration.map(a => chalk.white(a.words.join(' ')) + chalk.dim(` (${a.label})`)).join(SEP),
+        });
+    if (p.acrostics.length)
+        sub.push({
+            label: 'Acrostic',
+            body: p.acrostics.map(a => a.firsts.map((f, i) => chalk.dim('[' + a.labels[i] + ':') + chalk.whiteBright(f) + chalk.dim(']')).join('')
+                + chalk.dim(' → ') + chalk.yellowBright(a.word)).join(SEP),
+        });
+    if (sub.length === 0)
+        return [];
+    const out = ['', chalk.bold.cyan('Phonopoetics:')];
+    const w = Math.max(...sub.map(s => s.label.length)) + 2;
+    for (const s of sub)
+        out.push('  ' + chalk.bold((s.label + ':').padEnd(w)) + s.body);
+    return out;
+}
 /**
  * Reading view: the poem itself in its original formatting, each syllable
  * coloured by 4-tier relative stress, followed by a same-structure block of
  * per-line stress maps + meter (with top-3 fit scores).  This is the whole
  * output for this mode — not the full per-line analytic dump.
  */
+/** A verse line CLOSED by terminal or clause punctuation is END-STOPPED (a
+ *  prosodic pause at the line break); one ending on a word with no boundary
+ *  punctuation RUNS ON — enjambment — its intonational unit spilling into the
+ *  next line.  (Trailing quotes/brackets are ignored when judging the close.) */
+function lineRunsOn(raw) {
+    const t = raw.replace(/["'’”»)\]]+$/, '').trimEnd();
+    if (!t)
+        return false;
+    return !/[.!?;:,—–…]$/.test(t);
+}
+/** Poem-wide enjambment summary (end-stopped vs run-on line-ends), or null for
+ *  a single line.  The final line is terminal by position, so only the
+ *  line-INTERNAL breaks (lines 1..n-1) are judged. */
+function summariseEnjambment(stanzas) {
+    const raws = stanzas.flatMap(st => st.lines.map(l => l.raw));
+    if (raws.length < 2)
+        return null;
+    const interior = raws.slice(0, -1);
+    const enjambed = [];
+    interior.forEach((r, i) => { if (lineRunsOn(r))
+        enjambed.push(i + 1); });
+    const n = interior.length, k = enjambed.length;
+    if (k === 0)
+        return 'end-stopped throughout';
+    const where = k <= 6 ? ' (lines ' + enjambed.join(', ') + ')' : '';
+    return k >= Math.ceil(n / 2)
+        ? `predominantly enjambed — ${k} of ${n} line-ends run on${where}`
+        : `mostly end-stopped — ${k} of ${n} line-ends enjambed${where}`;
+}
 export function renderReadingView(stanzas) {
     const out = [];
     const multiStanza = stanzas.length > 1;
     out.push('');
     out.push(HR);
-    out.push(H1('Reading View') + chalk.dim('  — stress gradient over the original text'));
+    out.push(H1('Reading View') + chalk.dim('  — stress gradient over input text'));
     out.push('');
     // ── Block 1: the poem, original formatting, syllables coloured ──
+    // Multi-stanza poems get a right-aligned "Stanza N" counter in the blank line
+    // before each stanza after the first (the gaps between stanzas).
     for (let s = 0; s < stanzas.length; s++) {
+        if (multiStanza && s > 0) {
+            out.push('');
+            out.push(chalk.dim.italic(('Stanza ' + (s + 1)).padStart(HR.length)));
+        }
         for (const ln of stanzas[s].lines) {
             out.push(projectStressOntoLine(ln.raw, collectLineWords(ln)));
         }
-        if (s < stanzas.length - 1)
-            out.push('');
     }
     out.push('');
     out.push(HR_THIN);
-    out.push(H1('Stress Maps & Meter') + chalk.dim('  — top-3 fit scores per line'));
+    out.push(H1('Stress Maps, Meter, & Rhymes') + chalk.dim('  — top-3 fit scores per line'));
     out.push('');
     // ── Block 2: stress maps + meter, same stanza/line structure ──
     for (let s = 0; s < stanzas.length; s++) {
@@ -875,16 +1025,47 @@ export function renderReadingView(stanzas) {
                 const caesurae = computeCaesurae(res.sentence.words, res.phonologicalHierarchy, d.scansion);
                 const map = colourScansionMap(d.scansion, caesurae);
                 const rank = formatRanking(d.ranking);
-                out.push('  ' + chalk.bold(label.padEnd(8)) + map + '   ' +
-                    chalk.whiteBright(d.meter) + (rank ? '   ' + rank : '') + consensusNote(d) + rhythmNoteStr(d) + rhymeStr(d));
+                out.push('  ' + chalk.bold(label.padEnd(8)) + map + '  ' +
+                    colourMeterLabel(d.meter) + (rank ? chalk.dim(' | ') + rank : '') + consensusNote(d) + rhythmNoteStr(d) + rhymeStr(d));
             }
         }
         if (multiStanza && s < stanzas.length - 1)
             out.push('');
     }
+    // ── Block 3: Legend ──
+    // Kept ABOVE the synopsis: the legend serves the Stress Maps & Meter, and the
+    // Phonopoetics subsection of the synopsis below can run long — left at the
+    // bottom it gets pushed out of the field of view.
     out.push('');
     out.push(HR_THIN);
     out.push(renderLegend());
+    // ── Block 4: cumulative poem synopsis (non-interfering meta-measure) ──
+    // Several top conclusions about the poem as a whole, drawn only from the
+    // per-line determinations above — never overriding any of them.
+    const synopsis = summarizePoem(stanzas.map(st => st.lines.flatMap(l => l.results)));
+    if (synopsis.length > 0) {
+        out.push('');
+        out.push(HR_THIN);
+        out.push(H1('Poem Synopsis') + chalk.dim(' In short, we have:'));
+        out.push('');
+        const w = Math.max(...synopsis.map(r => r.label.length)) + 2;
+        for (const row of synopsis) {
+            const label = chalk.bold.cyan((row.label + ':').padEnd(w));
+            // Colour the value so the block is not a wall of white: tint any metre
+            // names their family hue, and highlight the mean-fit %.
+            let val = tintMeterNames(row.value);
+            if (row.label === 'Meter')
+                val = val.replace(/~\d+%/, (m) => chalk.yellow(m));
+            out.push('  ' + label + val);
+        }
+        // Enjambment / end-stop — a poem-wide reading of the line-ends.
+        const enj = summariseEnjambment(stanzas);
+        if (enj)
+            out.push('  ' + chalk.bold.cyan('Enjambment:'.padEnd(w)) + chalk.dim(enj));
+        // Phonopoetics — end / caesural / head rhymes, alliteration, acrostic.
+        out.push(...renderPhonopoetics(analyzePhonopoetics(stanzas.map(st => st.lines.flatMap(l => l.results)))));
+    }
+    out.push('');
     out.push(HR);
     return out.join('\n');
 }

package/dist/engine.d.ts

@@ -0,0 +1,9 @@
+import { ClsSentence, IntonationalUnit } from './types.js';
+export type EngineName = 'calliope' | 'clio';
+export interface ProsodyEngine {
+    readonly name: EngineName;
+    /** Populate lexical/phrase/relative stress on `sent.words` and return the
+     *  sentence's intonational units (the prosodic hierarchy). */
+    analyzeSentence(sent: ClsSentence): IntonationalUnit[];
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE3D,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;kEAC8D;IAC9D,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,gBAAgB,EAAE,CAAC;CACxD"}