calliope-ts 0.0.1 → 0.0.2

package/tests/basic.test.ts

@@ -0,0 +1,696 @@
+import { describe, it, expect } from 'vitest';
+import { parseDocument } from '../src/parser.js';
+import {
+  assignLexicalStress,
+  applyCompoundStress,
+  applyNuclearStress,
+  assignRelativeStresses,
+} from '../src/stress.js';
+import { buildPhonologicalHierarchy } from '../src/phonological.js';
+import { extractKeyStresses, scoreMeters } from '../src/scansion.js';
+import {
+  scandroidCorralWeird,
+  scandroidMaximizeNormal,
+  stressToMarks,
+} from '../src/scandroid.js';
+import { analyzeText, feedMultilineEvent, newMLState, ML_IDLE_MS, type MLEvent } from '../src/index.js';
+import type { PhonologicalScansionDetail } from '../src/types.js';
+import { classifyRhymePair, detectScheme } from '../src/rhyme.js';
+import { analyzeStanzas } from '../src/index.js';
+
+/** Drive the multi-line input reducer with a synthetic event sequence. */
+function runMultiline(events: MLEvent[]): { result: string; lines: string[] } {
+  const st = newMLState();
+  let result = 'continue';
+  for (const ev of events) {
+    result = feedMultilineEvent(st, ev);
+    if (result !== 'continue') break;
+  }
+  return { result, lines: st.lines };
+}
+const FAST = ML_IDLE_MS - 50;   // burst-speed (paste)
+const SLOW = ML_IDLE_MS + 400;  // deliberate keystroke
+/** A whole line of pasted text: its chars (burst), then a burst-speed newline. */
+function pasteLine(text: string, firstGap = FAST): MLEvent[] {
+  const evs: MLEvent[] = [];
+  [...text].forEach((c, i) => evs.push({ kind: 'char', str: c, gap: i === 0 ? firstGap : FAST }));
+  evs.push({ kind: 'return', gap: FAST });
+  return evs;
+}
+
+function scanLine(line: string): PhonologicalScansionDetail {
+  const results = analyzeText(line, false);
+  return results[0].phonologicalScansion;
+}
+
+function runPipeline(line: string) {
+  const doc = parseDocument(line);
+  const sent = doc.sentences[0];
+  assignLexicalStress(sent.words);
+  const ius = buildPhonologicalHierarchy(sent);
+  applyCompoundStress(ius);
+  applyNuclearStress(ius);
+  assignRelativeStresses(sent.words, ius);
+  const keys = extractKeyStresses(ius, sent.words);
+  const result = scoreMeters(keys, sent.words, ius);
+  return { result, sent, ius, keys };
+}
+
+function hasEmptyFeet(s: string): boolean {
+  return s.includes('||') || s.startsWith('|') || s.endsWith('|');
+}
+
+describe('parser', () => {
+  it('parses a simple sentence into ClsDocument', () => {
+    const doc = parseDocument('I love you');
+    expect(doc.sentences).toHaveLength(1);
+    const sent = doc.sentences[0];
+    expect(sent.words).toHaveLength(3);
+    expect(sent.words[0].word).toBe('i');
+    expect(sent.words[0].lexicalClass).toBeTruthy();
+    expect(sent.dependencies).toHaveLength(3);
+    const rootDep = sent.dependencies.find(d => d.governorIndex === 0);
+    expect(rootDep).toBeTruthy();
+  });
+});
+
+describe('contraction handling', () => {
+  it("merges we'll into a single word", () => {
+    const r = scanLine("In Petersburg once more we'll be united");
+    expect(r).toBeDefined();
+    expect(r.meterName).toBeDefined();
+  });
+  it("merges we've into a single word", () => {
+    const r = scanLine("Like in a place where we've entombed the sun");
+    expect(r).toBeDefined();
+  });
+  it("merges I've into a single word", () => {
+    const doc = parseDocument("I've returned to my city, I know it to tears");
+    const w = doc.sentences[0].words.find(x => x.word === "i've");
+    expect(w).toBeDefined();
+  });
+  it("merges don't into a single word", () => {
+    const doc = parseDocument("don't you think the sun is brighter now");
+    const w = doc.sentences[0].words.find(x => x.word === "don't");
+    expect(w).toBeDefined();
+  });
+  it("merges it's into a single word", () => {
+    const doc = parseDocument("it's a nice day");
+    const w = doc.sentences[0].words.find(x => x.word === "it's");
+    expect(w).toBeDefined();
+    expect(doc.sentences[0].words.length).toBe(4);
+  });
+  it("merges can't into a single word", () => {
+    const doc = parseDocument("I can't do it");
+    const w = doc.sentences[0].words.find(x => x.word === "can't");
+    expect(w).toBeDefined();
+  });
+  it("merges I'm into a single word", () => {
+    const doc = parseDocument("I'm here now");
+    const w = doc.sentences[0].words.find(x => x.word === "i'm");
+    expect(w).toBeDefined();
+    expect(doc.sentences[0].words.length).toBe(3);
+  });
+  it("merges might've into a single word", () => {
+    const doc = parseDocument("I might've done that");
+    const w = doc.sentences[0].words.find(x => x.word === "might've");
+    expect(w).toBeDefined();
+  });
+  it('does not merge non-contraction host+clitic sequences', () => {
+    const doc = parseDocument('we will go');
+    const sent = doc.sentences[0];
+    expect(sent.words[0].word).toBe('we');
+    expect(sent.words[1].word).toBe('will');
+  });
+  it('a contraction line has correct syllable count', () => {
+    const doc = parseDocument("In Petersburg once more we'll be united");
+    assignLexicalStress(doc.sentences[0].words);
+    const sylCount = doc.sentences[0].words.reduce((a, w) => a + w.syllables.length, 0);
+    expect(sylCount).toBe(11);
+  });
+});
+
+describe('stress', () => {
+  function makeWords() {
+    return [
+      { text: 'city', pos: 'NN', isContent: true },
+      { text: 'hall', pos: 'NN', isContent: true },
+      { text: 'without', pos: 'IN', isContent: false },
+      { text: 'permission', pos: 'NN', isContent: true },
+      { text: 'the', pos: 'DT', isContent: false },
+    ].map((w, i) => ({
+      index: i + 1,
+      lexicalClass: w.pos,
+      lexicalDetails: '',
+      lexicalPlural: false,
+      position: '',
+      word: w.text,
+      absoluteIndex: i,
+      isContent: w.isContent,
+      syllables: [],
+      phraseStress: 0,
+    }));
+  }
+
+  function mockIus(words: any[]): any {
+    return [{ phonologicalPhrases: [{ cliticGroups: [{ tokens: words }] }] }];
+  }
+
+  it('assignLexicalStress sets syllables with stress numbers', () => {
+    const words = makeWords();
+    assignLexicalStress(words);
+    for (const w of words) {
+      expect(w.syllables.length).toBeGreaterThan(0);
+    }
+    expect(words[0].syllables.some(s => s.stress === 2)).toBe(true);
+    expect(words[4].syllables.some(s => s.stress === 2)).toBe(false);
+  });
+
+  it('applyCompoundStress adjusts adjacent noun-noun compounds', () => {
+    const words = makeWords();
+    assignLexicalStress(words);
+    applyCompoundStress(mockIus(words));
+    const cityMax = Math.max(...words[0].syllables.map(s => s.stress));
+    const hallMax = Math.max(...words[1].syllables.map(s => s.stress));
+    expect(cityMax).toBe(2);
+    expect(hallMax).toBe(1);
+  });
+
+  it('applyNuclearStress boosts rightmost content word', () => {
+    const words = makeWords();
+    assignLexicalStress(words);
+    applyNuclearStress(mockIus(words));
+    const rightStress = words[3].syllables.reduce((a, b) => Math.max(a, b.stress), 0);
+    const leftStress = words[0].syllables.reduce((a, b) => Math.max(a, b.stress), 0);
+    expect(rightStress).toBeGreaterThanOrEqual(leftStress);
+  });
+
+  it('assignRelativeStresses converts numeric to symbolic levels', () => {
+    const words = makeWords();
+    assignLexicalStress(words);
+    if (words[1] && words[4]) {
+      const dep = {
+        governor: words[1], dependent: words[4],
+        governorIndex: 2, dependentIndex: 5, dependentType: 'det',
+        governorName: 'hall', dependentName: 'the', index: 5,
+      };
+      words[1].dependency = dep as any;
+      words[4].dependency = dep as any;
+    }
+    assignRelativeStresses(words, mockIus(words));
+    for (const w of words) {
+      for (const s of w.syllables) {
+        expect(['x', 'w', 'n', 'm', 's']).toContain(s.relativeStress);
+      }
+    }
+  });
+});
+
+describe('phonological', () => {
+  it('builds IU/PP/CP hierarchy for a simple sentence', () => {
+    const doc = parseDocument('The planet orbits a star');
+    const sent = doc.sentences[0];
+    assignLexicalStress(sent.words);
+    const ius = buildPhonologicalHierarchy(sent);
+    expect(ius.length).toBeGreaterThan(0);
+    expect(ius[0].phonologicalPhrases.length).toBeGreaterThan(0);
+    expect(ius[0].phonologicalPhrases[0].cliticGroups.length).toBeGreaterThan(0);
+  });
+});
+
+describe('scansion', () => {
+  it('Shall I compare thee? — iambic', () => {
+    const { result } = runPipeline("Shall I compare thee to a summer's day?");
+    expect(result.meterName).toBe('iambic');
+    // 'x' = zero-provision clitics ("to", and the article "a" — whose old 'n'
+    // came from the letter-name EY1 dictionary anomaly, fixed 2026-06-12).
+    expect(result.scansion).toBe('nn|ws|nx|xm|ws');
+    expect(result.footCount).toBeGreaterThan(0);
+  });
+
+  it('The Assyrian came down — anapestic', () => {
+    const { result } = runPipeline('The Assyrian came down like the wolf on the fold');
+    expect(result.meterName).toBe('anapestic');
+    // 'x' = the three reduced "the" clitics (DT); the monosyllabic prepositions
+    // "like"/"on" floor at 'w' (clitic-floor rule) rather than 'n', so the
+    // anapestic upbeats "like·the·WOLF / on·the·FOLD" read w·x·s.
+    expect(result.scansion).toBe('xws|wsm|wxs|wxs');
+  });
+
+  it('I\'ve returned to my city — anapestic', () => {
+    const { result } = runPipeline("I've returned to my city, I know it to tears");
+    expect(result.meterName).toBe('anapestic');
+    // 'x' = reduced clitics "to", "it", "to"; the possessive "my" (PRP$) floors
+    // at 'w' (clitic-floor rule) rather than 'n': "to·my·CIT(y)" = x·w·s.
+    expect(result.scansion).toBe('nwm|xws|wns|xxs');
+  });
+
+  it('through Eden took — iambic', () => {
+    const { result } = runPipeline('Through Eden took their solitary way');
+    expect(result.meterName).toBe('iambic');
+    // Clitic-floor: the preposition "Through" (IN) → 'w' and the possessive
+    // "their" (PRP$) → 'x' (floored to 'w', then governance-demoted under
+    // "solitary"), giving clean rising feet "through·E / …their·SOL".
+    expect(result.scansion).toBe('wm|ws|xm|wn|ws');
+  });
+
+  it('free verse for nonsensical empty input', () => {
+    const result = scoreMeters([], []);
+    expect(result.meterName).toBe('free verse');
+    expect(result.scansion).toBe('');
+  });
+
+  it("You've returned here — anapestic (Mandelstam, 'Leningrad')", () => {
+    // Translation of Mandelstam's anapestic-tetrameter "Ты вернулся сюда…":
+    // you've·re·TURNED | here·so·SWAL | low·then·FAST | as·you·MIGHT.  Resolved by
+    // (1) treating the line-final modal "might" as the final beat ("endings
+    // strict"), (2) the trailing-function-run rule that keeps "as you" as upbeat,
+    // (3) the coarse rising-onset cue, and (4) the project's slight ternary bias.
+    const { result } = runPipeline("You've returned here, so swallow then, fast as you might");
+    expect(result.meterName).toBe('anapestic');
+  });
+
+  it('And onto shores — iambic', () => {
+    const { result } = runPipeline('And onto shores, with scorching fishes');
+    expect(result.meterName).toBe('iambic');
+  });
+
+  it('We all live — anapestic', () => {
+    const { result } = runPipeline('We all live, underneath us no country we sense');
+    expect(result.meterName).toBe('anapestic');
+  });
+
+  it('Woolen gray hat — dactylic', () => {
+    const { result } = runPipeline('Woolen gray hat and the crimson stars shining');
+    expect(result.meterName).toBe('dactylic');
+  });
+
+  it('keeps making blue holes — amphibrachic', () => {
+    const { result } = runPipeline('keeps making blue holes in the waterproof gloss');
+    expect(result.meterName).toBe('amphibrachic');
+  });
+
+  it('This ivy resembles — amphibrachic', () => {
+    const { result } = runPipeline('This ivy resembles the eyes of the deaf.');
+    expect(result.meterName).toBe('amphibrachic');
+  });
+
+  it('We charged at the foe — anapestic', () => {
+    const { result } = runPipeline('We charged at the foe, and we camped on the heath,');
+    expect(result.meterName).toBe('anapestic');
+  });
+
+  it('All this time — trochaic', () => {
+    const { result } = runPipeline("All this time, you'd softly utter, years on end");
+    expect(result.meterName).toBe('trochaic');
+  });
+
+  it('The strong wine flows down fast — bacchic', () => {
+    const { result } = runPipeline('The strong wine flows down fast');
+    expect(result.meterName).toBe('bacchic');
+  });
+
+  it('But he gave no one else a laugher\'s license — iambic (Tarlinskaja)', () => {
+    const { result } = runPipeline("But he gave no one else a laugher's license.");
+    expect(result.meterName).toBe('iambic');
+    // Tarlinskaja's example of a stress-modulated iambic pentameter: a trochaic
+    // inversion (gave·no), a spondee (one·else), a he·gave clash (· silent beat),
+    // and a feminine ending (laugher's·li·cense → wsw).  Every foot is a real
+    // 2–3 syllable foot — unlike the prior key's spurious 4-syllable "mwsw".
+    // ("a" reads 'x' since the letter-name EY1 anomaly fix, 2026-06-12.)
+    expect(result.scansion).toBe('wm|-sn|sm|xm|wsw');
+  });
+});
+
+describe('expert baseline', () => {
+  it('If hairs be wires — iambic', () => {
+    const { result } = runPipeline('If hairs be wires, black wires grow on her head');
+    expect(result.meterName).toBe('iambic');
+    // 'x' = reduced clitic "if" (IN); "be" floors at 'w' not 'x' (a function
+    // VERB is reducible but never maximally reduced — 2026-06-12 rule); the
+    // preposition "on" (IN) and possessive "her" (PRP$) floor at 'w' (clitic-
+    // floor rule) rather than 'n', so the close reads "grow·on / her·HEAD".
+    expect(result.scansion).toBe('xm|ws|mm|sw|ws');
+  });
+
+  it('Through Eden took — iambic', () => {
+    const { result } = runPipeline('Through Eden took their solitary way');
+    expect(result.meterName).toBe('iambic');
+    // Clitic-floor: "Through" (IN) → 'w', "their" (PRP$) → 'x' (see above).
+    expect(result.scansion).toBe('wm|ws|xm|wn|ws');
+  });
+
+  it('There they are my fifty men — trochaic', () => {
+    const { result } = runPipeline('There they are my fifty men and women');
+    expect(result.meterName).toBe('trochaic');
+  });
+
+  it('What had I given — iambic', () => {
+    const { result } = runPipeline('What had I given to hear the soft sweep');
+    expect(result.meterName).toBe('iambic');
+    // 'x' = reduced clitics "to" and "the".
+    expect(result.scansion).toBe('nn|nm|wxm|xm|s');
+  });
+
+  it('Lies the subject of all verse — trochaic', () => {
+    const { result } = runPipeline('Lies the subject of all verse');
+    expect(result.meterName).toBe('trochaic');
+    // 'x' = reduced clitics "the" (DT) and "of" (IN); "all" (PDT) stays content 'n'.
+    expect(result.scansion).toBe('sx|sw|xn|s');
+  });
+
+});
+
+describe('scansion quality', () => {
+  const lines = [
+    'If hairs be wires, black wires grow on her head',
+    'Through Eden took their solitary way',
+    'What had I given to hear the soft sweep',
+    "Shall I compare thee to a summer's day?",
+    'Gone were but the Winter, come were but the Spring',
+    'The Assyrian came down like the wolf on the fold',
+  ];
+
+  it('no metered scansion has empty feet', () => {
+    for (const line of lines) {
+      const { result } = runPipeline(line);
+      if (result.meterName !== 'free verse') {
+        expect(hasEmptyFeet(result.scansion)).toBe(false);
+      }
+    }
+  });
+
+  it('metered scansions contain foot breaks', () => {
+    for (const line of lines) {
+      const { result } = runPipeline(line);
+      expect(result.scansion).toContain('|');
+    }
+  });
+});
+
+describe('phonological notation', () => {
+  it('includes CP, PP, IU boundary brackets', () => {
+    const r = scanLine('The planet orbits a star');
+    expect(r.all).toMatch(/\[/);
+    expect(r.all).toMatch(/\{/);
+    expect(r.all).toMatch(/</);
+    expect(r.keyStresses).toMatch(/\[/);
+  });
+
+  it('includes stress symbols w m s n', () => {
+    const r = scanLine('The planet orbits a star');
+    expect(r.all).toMatch(/[wmsn]/);
+    expect(r.keyStresses).toMatch(/[wmsn]/);
+  });
+});
+
+describe('multi-line input (paste-friendly)', () => {
+  it('paste WITH trailing newline + one Enter submits, keeping stanza breaks', () => {
+    // Two stanzas of two lines, paste ends in a newline, then a deliberate Enter.
+    const evs: MLEvent[] = [
+      ...pasteLine('line one', SLOW),   // first char gap is large (since reader just opened)
+      ...pasteLine('line two'),
+      { kind: 'return', gap: FAST },    // blank line within the burst = stanza break
+      ...pasteLine('line three'),
+      ...pasteLine('line four'),        // burst ends with a trailing newline
+      { kind: 'return', gap: SLOW },    // the user's single deliberate Enter → submit
+    ];
+    const { result, lines } = runMultiline(evs);
+    expect(result).toBe('submit');
+    // The blank stanza break is preserved between the two couplets.
+    expect(lines.filter(l => l.trim() === '').length).toBe(1);
+    expect(lines.filter(l => l.trim() !== '')).toEqual(['line one', 'line two', 'line three', 'line four']);
+  });
+
+  it('paste WITHOUT trailing newline + one Enter submits, flushing the last line', () => {
+    const evs: MLEvent[] = [
+      ...pasteLine('first line', SLOW),
+      // last line has no burst newline; the user just presses Enter once:
+      ...[...'last line'].map((c, i) => ({ kind: 'char', str: c, gap: i === 0 ? FAST : FAST } as MLEvent)),
+      { kind: 'return', gap: SLOW },    // deliberate Enter after the paste burst → submit + flush
+    ];
+    const { result, lines } = runMultiline(evs);
+    expect(result).toBe('submit');
+    expect(lines.filter(l => l.trim() !== '')).toEqual(['first line', 'last line']);
+  });
+
+  it('Esc cancels (returns to menu)', () => {
+    const { result } = runMultiline([...pasteLine('something'), { kind: 'escape' }]);
+    expect(result).toBe('cancel');
+  });
+
+  it('slow hand-typing: a blank line finishes', () => {
+    const evs: MLEvent[] = [
+      ...[...'typed line'].map((c) => ({ kind: 'char', str: c, gap: SLOW } as MLEvent)),
+      { kind: 'return', gap: SLOW },    // end of the typed line (no burst seen) → line break
+      { kind: 'return', gap: SLOW },    // blank line → submit
+    ];
+    const { result, lines } = runMultiline(evs);
+    expect(result).toBe('submit');
+    expect(lines.filter(l => l.trim() !== '')).toEqual(['typed line']);
+  });
+});
+
+describe('scandroid', () => {
+  it('Corral the Weird scans regular iambic', () => {
+    const result = scandroidCorralWeird('x/x/x/x/x/', 5);
+    expect(result.footlist.length).toBe(5);
+  });
+
+  it('Maximize Normal works on regular iambic', () => {
+    const result = scandroidMaximizeNormal('x/x/x/x/x/', 5);
+    expect(result.footlist.length).toBeGreaterThan(0);
+  });
+
+  it('stressToMarks converts correctly', () => {
+    expect(stressToMarks(['w', 's', 'w', 's'])).toBe('x/x/');
+  });
+});
+
+describe('end‑to‑end', () => {
+  const poem = `Shall I compare thee to a summer's day?
+Thou art more lovely and more temperate.
+Rough winds do shake the darling buds of May,
+And summer's lease hath all too short a date.`;
+
+  it('analyzeText returns results for each line', () => {
+    const results = analyzeText(poem, false);
+    expect(results.length).toBe(4);
+    expect(results[0].phonologicalScansion.meterName).toBe('iambic');
+    expect(results[1].phonologicalScansion.meterName).toBe('iambic');
+    expect(results[2].phonologicalScansion.meterName).toBe('iambic');
+    expect(results[3].phonologicalScansion.meterName).toBe('iambic');
+  });
+
+  it('analyzeText with Scandroid includes Scandroid results', () => {
+    const results = analyzeText(poem, true);
+    for (const r of results) {
+      expect(r.phonologicalScansion.meterName).toBeDefined();
+    }
+  });
+
+  it('handles free verse line gracefully', () => {
+    // A famously free-verse line (Williams): there is no canonical scansion, so we
+    // assert graceful handling — a defined meter and a non-empty, foot-delimited
+    // scansion covering every syllable — rather than a brittle exact string.
+    const results = analyzeText('so much depends upon a red wheel barrow', false);
+    const d = results[0].phonologicalScansion;
+    expect(d.meter).toBeDefined();
+    expect(d.scansion.length).toBeGreaterThan(0);
+    expect(d.scansion).toContain('|');
+    // syllable letters in the scansion must equal the line's syllable count
+    const sylLetters = (d.scansion.match(/[xwnms]/g) || []).length;
+    const totalSyls = results[0].sentence.words.reduce((a, w) => a + w.syllables.length, 0);
+    expect(sylLetters).toBe(totalSyls);
+  });
+});
+
+describe('structural fixes (2026-06-10 audit)', () => {
+  it('quotation marks are not prosodic breaks: quoted word scans like unquoted', () => {
+    // Quotes fragmented the IU hierarchy and flipped this line to "trochaic
+    // hexameter"; quoted and unquoted twins must scan identically.
+    const quoted = analyzeText('I wonder why we call them "wisdom" teeth.', false)[0].phonologicalScansion;
+    const plain = analyzeText('I wonder why we call them wisdom teeth.', false)[0].phonologicalScansion;
+    expect(quoted.meterName).toBe('iambic');
+    expect(quoted.footCount).toBe(5);
+    expect(quoted.meterName).toBe(plain.meterName);
+    expect(quoted.footCount).toBe(plain.footCount);
+  });
+
+  it('the LINE is the scansion domain: internal stops do not fragment the meter', () => {
+    // Three grammatical sentences, one verse line (Woolley) — one iambic pentameter,
+    // not trimeter + monometer + monometer fragments.
+    const results = analyzeText("You'll slurp potato soup. No straws! Suck gauze.", false);
+    expect(results.length).toBe(1);
+    expect(results[0].phonologicalScansion.meterName).toBe('iambic');
+    expect(results[0].phonologicalScansion.footCount).toBe(5);
+  });
+
+  it('mid-line exclamation keeps the line whole (Stallings-aligned)', () => {
+    const results = analyzeText('Oh, bloody day! Extractions take their toll;', false);
+    expect(results.length).toBe(1);
+    expect(results[0].phonologicalScansion.meterName).toBe('iambic');
+    expect(results[0].phonologicalScansion.footCount).toBe(5);
+  });
+
+  it('single anacrusis upbeat does not inflate the foot count', () => {
+    // 10 syllables with a leading extrametrical upbeat: pentameter, never hexameter.
+    const d = analyzeText('The woods around it have it--it is theirs.', false)[0].phonologicalScansion;
+    expect(d.footCount).toBe(5);
+    expect(d.meter).not.toContain('hexameter');
+  });
+
+  it('double upbeat fills a foot slot: Hiawatha stays tetrameter', () => {
+    const d = analyzeText('By the shores of Gitche Gumee,', false)[0].phonologicalScansion;
+    expect(d.meterName).toBe('trochaic');
+    expect(d.footCount).toBe(4);
+  });
+});
+
+describe('syllable-count integrity (2026-06-10 audit)', () => {
+  const sylCount = (line: string) => {
+    const r = analyzeText(line, false)[0];
+    return r.sentence.words.reduce((a, w) => a + w.syllables.length, 0);
+  };
+
+  it('"am" is one syllable (not the letter-name A.M. anomaly)', () => {
+    expect(sylCount('I am too absent-spirited to count;')).toBe(10);
+  });
+
+  it('"us" is one syllable (not the letter-name U.S. anomaly)', () => {
+    expect(sylCount('Just for a handful of silver he left us,')).toBe(11);
+  });
+
+  it("who'll / there's / she's re-merge to one syllable each", () => {
+    expect(sylCount("who'll barely recognize your puffy face.")).toBe(10);
+    expect(sylCount("and there's a light she's seen")).toBe(6);
+  });
+
+  it("archaic -'d preterite does not swallow the next word", () => {
+    const r = analyzeText("And heav'n knows wand'ring ev'ry fix'd star", false)[0];
+    const words = r.sentence.words.map(w => w.word.toLowerCase());
+    expect(words).toContain("fix'd");
+    expect(words).toContain('star');
+    expect(words).not.toContain('would');
+    expect(sylCount("And heav'n knows wand'ring ev'ry fix'd star")).toBe(9);
+  });
+
+  it("th'-elision keeps the host's stress (th'ex-PENSE, not TH'EX-pense)", () => {
+    const r = analyzeText("Th'expense of spirit in a waste of shame", false)[0];
+    const w = r.sentence.words.find(x => x.word.toLowerCase().startsWith("th'"))!;
+    expect(w.syllables.length).toBe(2);
+    const rank: Record<string, number> = { x: 0, w: 1, n: 2, m: 3, s: 4 };
+    expect(rank[w.syllables[1].relativeStress!]).toBeGreaterThan(rank[w.syllables[0].relativeStress!]);
+  });
+
+  it("'tis / 'twas are weak aphaeresis clitics, not stressed proper nouns", () => {
+    const r = analyzeText("'Tis true, 'twas night", false)[0];
+    const tis = r.sentence.words.find(w => w.word.toLowerCase().includes('tis'))!;
+    const twas = r.sentence.words.find(w => w.word.toLowerCase().includes('twas'))!;
+    expect(['x', 'w']).toContain(tis.syllables[0].relativeStress);
+    expect(['x', 'w']).toContain(twas.syllables[0].relativeStress);
+  });
+});
+
+describe('rhyme & form layer (2026-06-12)', () => {
+  it('classifies canonical rhyme pairs (LYRICAL typology)', () => {
+    expect(classifyRhymePair('grace', 'face')).toMatchObject({ type: 'perfect', structure: 'masculine' });
+    expect(classifyRhymePair('picky', 'tricky')).toMatchObject({ type: 'perfect', structure: 'feminine' });
+    expect(classifyRhymePair('belief', 'leaf')).toMatchObject({ type: 'rich' });     // homophone tails
+    expect(classifyRhymePair('dame', 'grain')).toMatchObject({ type: 'family' });    // M/N nasals
+    expect(classifyRhymePair('love', 'move')).toMatchObject({ type: 'consonant' });  // para-rhyme
+    expect(classifyRhymePair('shaken', 'shaken')).toMatchObject({ type: 'identical' });
+  });
+
+  it('detects ABCB with unrhymed lines marked', () => {
+    const rs = detectScheme(['Mariner', 'three', 'eye', 'me']);
+    expect(rs.map(r => r.letter).join('')).toBe('\u00b7A\u00b7A');
+  });
+
+  it('Coleridge quatrain \u2192 ballad stanza (rhyme + 4\u00b73 gate)', () => {
+    const r = analyzeStanzas('It is an ancient Mariner,\nAnd he stoppeth one of three.\nBy thy long grey beard and glittering eye,\nNow wherefore stopp\u2019st thou me?');
+    expect(r[0][0].phonologicalScansion.formNote).toBe('ballad stanza (ABCB, 4\u00b73)');
+  });
+
+  it('Pope couplet \u2192 couplet', () => {
+    const r = analyzeStanzas('True wit is nature to advantage dressed,\nWhat oft was thought, but ne\u2019er so well expressed.');
+    expect(r[0][0].phonologicalScansion.formNote).toBe('couplet');
+  });
+
+  it('Frost (Mending Wall opening) \u2192 blank verse', () => {
+    const r = analyzeStanzas("Something there is that doesn't love a wall,\nThat sends the frozen-ground-swell under it,\nAnd spills the upper boulders in the sun;\nAnd makes gaps even two can pass abreast.");
+    expect(r[0][0].phonologicalScansion.formNote).toBe('blank verse');
+  });
+
+  it('Sonnet 130 \u2192 Shakespearean Sonnet, full scheme', () => {
+    const text = "My mistress' eyes are nothing like the sun;\nCoral is far more red than her lips' red;\nIf snow be white, why then her breasts are dun;\nIf hairs be wires, black wires grow on her head.\nI have seen roses damask'd, red and white,\nBut no such roses see I in her cheeks;\nAnd in some perfumes is there more delight\nThan in the breath that from my mistress reeks.\nI love to hear her speak, yet well I know\nThat music hath a far more pleasing sound;\nI grant I never saw a goddess go;\nMy mistress, when she treads, walks on the ground.\nAnd yet, by heaven, I think my love as rare\nAs any she belied with false compare.";
+    const r = analyzeStanzas(text);
+    expect(r[0][0].phonologicalScansion.formNote).toBe('Shakespearean Sonnet');
+    expect(r[0].map(l => l.phonologicalScansion.rhyme!.letter).join('')).toBe('ABABCDCDEFEFGG');
+  });
+
+  it('Lear limerick \u2192 limerick (AABBA, ternary)', () => {
+    const r = analyzeStanzas('There was an Old Man with a beard,\nWho said, It is just as I feared!\nTwo Owls and a Hen,\nFour Larks and a Wren,\nHave all built their nests in my beard!');
+    expect(r[0][0].phonologicalScansion.formNote).toMatch(/^limerick/);
+  });
+});
+
+describe('continuity rename (2026-06-14)', () => {
+  it('near-tie line adopts the stanza-dominant meter; standalone kept as note', () => {
+    // Exile opening: L2 standalone reads dactylic (spondaic "book-" anacrusis
+    // seizes a beat), but the stanza is amphibrachic — continuity renames it.
+    const r = analyzeStanzas(
+      'He happens to be a French poet, that thin,\n' +
+      'book-carrying man with a bristly gray chin;\n' +
+      'you meet him whenever you go');
+    const d = r[0][1].phonologicalScansion;
+    expect(d.meterName).toBe('amphibrachic');
+    expect(d.standaloneMeter).toMatch(/dactylic/);
+    expect(d.consensusMeter).toBeUndefined();
+  });
+
+  it('accentual stanzas are exempt: Wyatt keeps 4-beat accentual, no renames', () => {
+    const wyatt =
+      'They fle from me that sometyme did me seke\n' +
+      'With naked fote stalking in my chambre.\n' +
+      'I have sene theim gentill tame and meke\n' +
+      'That nowe are wyld and do not remembre\n' +
+      'That sometyme they put theimself in daunger\n' +
+      'To take bred at my hand; and nowe they raunge\n' +
+      'Besely seking with a continuell chaunge.';
+    const r = analyzeStanzas(wyatt);
+    for (const l of r[0]) {
+      expect(l.phonologicalScansion.rhythmNote).toBe('4-beat accentual');
+      expect(l.phonologicalScansion.standaloneMeter).toBeUndefined();
+    }
+  });
+});
+
+describe('parse-correction layer (2026-06-14)', () => {
+  it('staged pipeline repairs "I had quit the programming paradigm"', () => {
+    const doc = parseDocument('I had quit the programming paradigm');
+    const words = doc.sentences[0].words;
+    expect(words.find(w => w.word === 'i')!.lexicalClass).toBe('PRP');
+    expect(words.find(w => w.word === 'quit')!.lexicalClass).toBe('VBN');
+    const deps = doc.sentences[0].dependencies;
+    const prog = deps.find(d => d.dependentName === 'programming')!;
+    expect(prog.dependentType).toBe('amod');
+    expect(prog.governorName).toBe('paradigm');
+    const det = deps.find(d => d.dependentName === 'the')!;
+    expect(det.dependentType).toBe('det');
+    expect(det.governorName).toBe('paradigm');
+  });
+
+  it('archaic forms get verse-correct tags (thy/PRP$ floors at w)', () => {
+    const doc = parseDocument('By thy long grey beard and glittering eye,');
+    const thy = doc.sentences[0].words.find(w => w.word === 'thy')!;
+    expect(thy.lexicalClass).toBe('PRP$');
+  });
+
+  it('context-guarded gerund fix: "they bicycle through" keeps the verb', () => {
+    const doc = parseDocument('young beauties, all legs, as they bicycle through');
+    const bike = doc.sentences[0].words.find(w => w.word === 'bicycle')!;
+    expect(bike.lexicalClass).toBe('VBP');
+  });
+});
+