calliope-ts 0.0.2 → 0.0.4

package/dist/stress.js

@@ -4,6 +4,7 @@
 import * as nounsing from 'nounsing-pro';
 import { isPunctuation } from './parser.js';
 import { collectPPTokens, syllabifyWord } from './phonological.js';
+import { isStrandedPreposition, isContrastivePossessive, isVocative, isDeicticLocative } from './semantics.js';
 // ─── CONSTANTS & CLASSIFICATIONS ──────────────────────────────────
 /**
  * Content‑word POS tags (nouns, adjectives, lexical verbs, adverbs).
@@ -118,6 +119,23 @@ const FUNCTION_ADVERBS = new Set([
     'always', 'often', 'sometimes', 'usually',
     'today', 'tomorrow', 'yesterday', 'tonight',
 ]);
+/**
+ * Rising (iambic) disyllabic function words — prepositions, conjunctions, and
+ * deictic adverbs that stress the SECOND syllable (be·CAUSE, a·BOUT, be·TWEEN).
+ * A handful are recorded fully-reduced ("00") in the augmented dictionary; for
+ * those the all-zero re-stamp must fix the FINAL syllable, NOT take the
+ * disyllabic forestress default (which mis-read be·CAUSE as BE·cause).  The
+ * re-stamp only fires on a genuine all-zero entry, so listing a word that
+ * already carries a peak is harmless.  Trochaic IN·to / UN·to / ON·to are
+ * deliberately excluded — they correctly keep forestress.
+ */
+const RISING_FUNCTION_WORDS = new Set([
+    'because', 'about', 'above', 'around', 'across', 'along', 'among', 'amongst',
+    'against', 'amid', 'amidst', 'apart', 'ahead', 'aside', 'away', 'aloft',
+    'alone', 'aloud', 'anew', 'awhile', 'ago',
+    'before', 'behind', 'below', 'beneath', 'beside', 'besides', 'between',
+    'beyond', 'within', 'without',
+]);
 /**
  * Oblique (object/dative) pronouns.  In clause-final position these are
  * canonically unstressed and do NOT attract the beat ("…and beHIND me", not
@@ -200,6 +218,70 @@ const FUNCTION_VERBS = new Set([
     'continue', 'continues', 'continued', 'continuing',
     'let', 'lets', "let's"
 ]);
+/** The copula / auxiliary forms of BE — they reduce in connected speech whether
+ *  used as copula ("she IS fair" → reduced) or auxiliary ("is going"). */
+const BE_FORMS = new Set(['be', 'am', 'is', 'are', 'was', 'were', 'being']);
+/**
+ * Exclamatory / vocative interjections.  These are emphatic, expressive elements —
+ * never zero-provision clitics — yet FinNLP routinely mis-tags vocative "O" as a
+ * preposition (IN) and "Lo" as a proper noun (NNP), which would otherwise floor
+ * them to 'x'.  Keyed off the lemma (not the unreliable tag), they are raised to at
+ * least 'n'; an exclaimed one ("O!", "Oh!") is lifted a further tier by the
+ * interjection-emphasis pass at the end of assignRelativeStresses.  Apostrophe
+ * forms (o'er = over, e'er = ever) are NOT here — they are aphaeresis clitics.
+ */
+const EXCLAM_INTERJECTIONS = new Set([
+    'o', 'oh', 'ah', 'ay', 'aye', 'lo', 'alas', 'alack', 'hark', 'fie', 'woe',
+    'ho', 'oho', 'aha', 'ahoy', 'hurrah', 'huzza',
+]);
+/**
+ * Honest baseline relative prominence for a FUNCTION word (McAleese step 1b:
+ * "w=weak, n=some stress, m=subordinate strong, s=strong").  A monosyllabic
+ * function word bears no lexical *some-stress*; the dictionary's citation stress
+ * (which marks "and"/"in"/"my"/"could" as primary) is a CITATION artefact, not
+ * connected-speech prominence.  We floor it to its true reading prominence — the
+ * meter layer still PROMOTES it to a beat where the metre calls for it (McAleese's
+ * Appendix-A Test 2: stressless "than"/"in" stay weak in the contour; the metre
+ * lifts only "from", which carries latent stress).  Returns the tier to floor to,
+ * or null to leave the word untouched.
+ *
+ *   'x' (zero-provision) — pure schwa-proclitics that fully reduce: coordinators
+ *       (CC: and/or/but/nor), monosyllabic prepositions & subordinators (IN), the
+ *       infinitival/prepositional "to" (TO), possessive determiners (PRP$/WP$:
+ *       my/your/his/her/its/our/their/whose).
+ *   'w' (overt-weak, still meter-promotable) — full-vowel function words: personal
+ *       pronouns (PRP), modals (MD), existential "there" (EX), the copula/auxiliary
+ *       BE forms, the AUXILIARY uses of have/do (by dependency role — a main-verb
+ *       "have"/"did" keeps its beat), and reduced deictic/discourse adverbs.
+ *
+ * Content words and the internal contour of POLYSYLLABIC function words
+ * (be·NEATH = x·n, with·OUT) are returned null (untouched).
+ */
+function relativeFloorFor(word) {
+    if (word.isContent)
+        return null;
+    if (word.syllables.length !== 1)
+        return null; // keep polysyllabic function contour
+    const pos = word.lexicalClass;
+    const lemma = word.word.toLowerCase().replace(/['’]/g, '');
+    // Pure schwa-proclitics → zero-provision 'x'.
+    if (pos === 'CC' || pos === 'PRP$' || pos === 'WP$' || pos === 'TO')
+        return 'x';
+    if (pos === 'IN')
+        return 'x'; // prepositions / subordinators cliticise
+    // Full-vowel weak function words → overt-weak 'w' (meter-promotable).
+    if (pos === 'PRP' || pos === 'MD' || pos === 'EX')
+        return 'w';
+    if (BE_FORMS.has(lemma))
+        return 'w'; // copula & auxiliary BE both reduce
+    // NB: have/do are deliberately NOT floored — unlike BE they routinely bear a
+    // beat (main-verb "have"/"do", emphatic "DID"), and even as auxiliaries they
+    // carry an iambic beat often enough ("what HAD I given") that flooring them
+    // mis-reads such lines.  Their level is left to the clash filter + meter layer.
+    if (FUNCTION_ADVERBS.has(lemma))
+        return 'w'; // so/then/here/there/when/just…
+    return null;
+}
 /** Left‑stressed compound categories with example first‑word lists. */
 const LEFT_STRESS_MATERIAL = new Set([
     'metal', 'wood', 'silk', 'cotton', 'glass', 'stone', 'iron', 'steel',
@@ -254,7 +336,7 @@ const RIGHT_STRESS_HEADS = new Set([
     'juice', 'avenue', 'day',
 ]);
 /** Check if a pair of words forms a left‑stressed compound. */
-function isLeftStressedPair(w1, w2) {
+export function isLeftStressedPair(w1, w2) {
     const first = w1.toLowerCase();
     const second = w2.toLowerCase().replace(/'s$/, '');
     // A right-stressing head overrides any forestress modifier (apple PIE).
@@ -280,6 +362,46 @@ function isLeftStressedPair(w1, w2) {
         return true;
     return false;
 }
+/** True if `w2` is a head noun that keeps phrasal/right stress against an N1
+ *  modifier (apple PIE, summer DAY, Fifth AVenue) — the marked right-stress
+ *  exceptions to the otherwise fore-stressing Compound Stress Rule. */
+export function isRightStressedHead(w2) {
+    return RIGHT_STRESS_HEADS.has(w2.toLowerCase().replace(/'s$/, ''));
+}
+/**
+ * Direction of primary stress for an adjacent two-word modification structure,
+ * the SINGLE source of truth shared by the lexical compound pass
+ * (`applyCompoundStress`) and the Phrase-Stress phase (`computePhraseStress`),
+ * so the two layers cannot disagree.
+ *
+ *   'left'  = fore-stress, primary on w1 — the Compound Stress Rule default for
+ *             an N+N compound (Chomsky–Halle; McAleese's worked example marks
+ *             ICE cream with primary on "ice", not "cream"): KITCHen table,
+ *             WINdow frame, BEDroom door, plus the curated LEFT_STRESS_* sets.
+ *   'right' = end-stress, primary on w2 — the marked exceptions: food/temporal
+ *             "made of N1" heads (apple PIE, summer DAY), Adj+N which is phrasal
+ *             not compound (sweet CREAM, red CAR), and proper-name sequences
+ *             which carry their own right-headed prosody (New YORK, John SMITH).
+ *   null    = not a compound/modification pair at all.
+ *
+ * The fore-stress default is restricted to COMMON-noun N+N: proper-noun pairs
+ * (NNP/NNPS) are excluded because place- and personal-name sequences are not
+ * reliably fore-stressed, and flipping them would mis-teach New YORK / John SMITH.
+ */
+export function compoundStressSide(w1, pos1, w2, pos2) {
+    const isNN = pos1.startsWith('N') && pos2.startsWith('N');
+    const isAdjN = pos1.startsWith('J') && pos2.startsWith('N');
+    if (!isNN && !isAdjN)
+        return null;
+    if (isLeftStressedPair(w1, w2))
+        return 'left'; // curated fore-stress modifier
+    if (isRightStressedHead(w2))
+        return 'right'; // apple PIE, Fifth AVenue
+    const proper = (p) => p === 'NNP' || p === 'NNPS';
+    if (isNN && !proper(pos1) && !proper(pos2))
+        return 'left'; // common-N+N compound default
+    return 'right'; // Adj+N phrasal / proper-name pair
+}
 /**
  * Lexicalised forestress COLLOCATIONS — fixed two-word phrases that stress the
  * LEFT element, even though the second word is not a noun (so the N+N/J+N
@@ -291,6 +413,7 @@ function isLeftStressedPair(w1, w2) {
 const LEFT_STRESS_COLLOCATIONS = [
     { w1: 'good', w2: 'old' }, // GOOD old days
     { w1: 'end', w2: 'all', ok: w => w.lexicalClass !== 'PDT' }, // END-all (idiom), not "end ALL the wars"
+    { w1: 'old', w2: 'days' }, // the OLD days (fixed expression: "days" is semantically light)
 ];
 /** True if (w1,w2) is a lexicalised forestress collocation in this context. */
 function isLeftStressedCollocation(w1, w2) {
@@ -308,7 +431,7 @@ const VOWEL_CHARS = new Set('aeiouyAEIOUY');
  *  silent 'e' ("where·fore", "there·in"): the plain vowel-group count reads the
  *  'e' as a nucleus and over-counts.  Count the parts instead. */
 const SILENT_E_COMPOUND_RE = /^(where|there|here)(fore|in|by|of|on|upon|at|to|with|out|after|under|unto|abouts?|soever)$/;
-function countVowelGroups(word) {
+function countVowelGroups(word, keepDisyllabicFinalE = false) {
     {
         const m = word.toLowerCase().replace(/[^a-z]/g, '').match(SILENT_E_COMPOUND_RE);
         // Closed-class second elements; counted directly ("fore" would otherwise
@@ -334,9 +457,20 @@ function countVowelGroups(word) {
             inVowel = false;
         }
     }
-    if (groups >= 3 && n > 2 && lower[n - 1] === 'e' && VOWEL_CHARS.has(lower[n - 1])) {
+    // Final orthographic silent-e ("magic e"): a word-final 'e' that opens its own
+    // vowel group is silent in the default modern reading.  Original rule fired only
+    // at 3+ groups; extended (2026-07-02) to DISYLLABIC shapes — archaic verse
+    // spellings ("seke", "fote", "nowe", "raunge", "chaunge") read as their modern
+    // monosyllables (seek, foot, now, range, change), which restored Wyatt's 4-beat
+    // accentual profile.  Exclusions for the disyllabic case only:
+    //   • -Cle/-Cre codas (obstruent+liquid+e): the liquid is syllabic and the 'e'
+    //     is its written nucleus (table, sabre) — no deduction;
+    //   • proper nouns (keepDisyllabicFinalE): foreign names pronounce it (Dante).
+    if (groups >= 2 && n > 2 && lower[n - 1] === 'e' && VOWEL_CHARS.has(lower[n - 1])) {
         const lastVowelStart = vowelPositions[vowelPositions.length - 1];
-        if (lastVowelStart === n - 1) {
+        const syllabicLiquid = /[^aeiouy][lr]e$/.test(lower);
+        const allow = groups >= 3 || (!syllabicLiquid && !keepDisyllabicFinalE);
+        if (lastVowelStart === n - 1 && allow) {
             groups--;
         }
     }
@@ -419,8 +553,209 @@ function morphologicalStress(w) {
             return { pattern: [...stemNumeric, ...new Array(added).fill(0)], suffix: added >= 1 ? rule.suffix : '' };
         }
     }
+    // Tier 1b: PREFIX decomposition (Wagner §6.5.2 — a prefix forms its OWN prosodic
+    // domain; the STEM keeps its primary stress).  Only fires on a genuinely OOV word
+    // (no suffix decomposition found and the bare word isn't in the lexicon — checked
+    // by the caller), and only when the prefix-stripped remainder IS a known stem, so
+    // it can only EXTEND coverage, never alter an in-lexicon word.  Heavy separable
+    // prefixes (over-/under-/out-/anti-…) bear secondary stress; light ones
+    // (un-/re-/dis-…) are unstressed before the stem's primary.
+    const pre = prefixStress(w);
+    if (pre)
+        return pre;
     return null;
 }
+/** Productive prefixes: syllable count + whether the prefix's first syllable bears
+ *  a SECONDARY stress (separable/heavy) or is unstressed (light Latinate). */
+const PREFIX_RULES = [
+    { prefix: 'counter', sylls: 2, sec: true },
+    { prefix: 'over', sylls: 2, sec: true }, { prefix: 'under', sylls: 2, sec: true },
+    { prefix: 'inter', sylls: 2, sec: true }, { prefix: 'super', sylls: 2, sec: true },
+    { prefix: 'anti', sylls: 2, sec: true }, { prefix: 'semi', sylls: 2, sec: true },
+    { prefix: 'multi', sylls: 2, sec: true }, { prefix: 'ultra', sylls: 2, sec: true },
+    { prefix: 'fore', sylls: 1, sec: true }, { prefix: 'out', sylls: 1, sec: true },
+    { prefix: 'non', sylls: 1, sec: true }, { prefix: 'self', sylls: 1, sec: true },
+    { prefix: 'un', sylls: 1, sec: false }, { prefix: 're', sylls: 1, sec: false },
+    { prefix: 'pre', sylls: 1, sec: false }, { prefix: 'dis', sylls: 1, sec: false },
+    { prefix: 'mis', sylls: 1, sec: false }, { prefix: 'de', sylls: 1, sec: false },
+];
+function prefixStress(w) {
+    // longest prefix first (counter- before -); guard against tiny stems.
+    for (const rule of [...PREFIX_RULES].sort((a, b) => b.prefix.length - a.prefix.length)) {
+        if (!w.startsWith(rule.prefix))
+            continue;
+        const stem = w.slice(rule.prefix.length);
+        if (stem.length < 3)
+            continue; // need a real stem (re+do too short)
+        const data = nounsing.all(stem);
+        const raw = data && data.length ? (data[0].stress?.stressTrans || '') : '';
+        if (!raw)
+            continue;
+        const stemNumeric = [...raw].map(c => mapCMUStress(parseInt(c, 10)));
+        if (stemNumeric.length === 0 || !stemNumeric.some(n => n >= 2))
+            continue; // stem must carry a primary
+        const head = rule.sec ? 1 : 0;
+        const preNumeric = [head, ...new Array(Math.max(0, rule.sylls - 1)).fill(0)];
+        return { pattern: [...preNumeric, ...stemNumeric], suffix: '', prefix: rule.prefix };
+    }
+    return null;
+}
+/** Display-only prefix detection for ALL words (in-vocab AND OOV).
+ *
+ *  The OOV-only `morphologicalStress` prefix path (Tier 1b) only fires when no
+ *  suffix decomposition is found — so "disillusions" (OOV, suffix "-s" → stem
+ *  "disillusion" IN-VOCAB) returns before the prefix path runs, and
+ *  "uneducated" (IN-VOCAB) never hits the OOV branch at all.  Neither gets
+ *  `morphPrefix` set, and the display syllabifier's Maximal Onset principle
+ *  pulls the prefix's final consonant into the next syllable (di·sil·lu·sions,
+ *  u·ne·du·ca·ted).
+ *
+ *  This pass runs AFTER `assignLexicalStress` for every word: if it starts with
+ *  a known productive prefix (from `PREFIX_RULES`) and the stripped stem is in
+ *  the nounsing-pro dictionary, set `word.morphPrefix`.  The syllabifier then
+ *  peels the prefix as the first syllable(s) and syllabifies the stem
+ *  separately, respecting the morpheme boundary (dis·il·lu·sions,
+ *  un·ed·u·ca·ted).  DISPLAY-ONLY — never changes stress or meter.
+ *
+ *  Guards: the stem must carry a primary stress (so we don't peel a prefix off
+ *  a function word like "into"), and the prefix must be at least 2 characters
+ *  (to avoid false positives on short words). */
+export function detectDisplayPrefixes(words) {
+    for (const word of words) {
+        if (word.morphPrefix)
+            continue; // already set by OOV path
+        if (word.syllables.length < 2)
+            continue; // monosyllables: no boundary to place
+        const clean = word.word.toLowerCase().replace(/-/g, '').replace(/[''']/g, '');
+        if (clean.length < 5)
+            continue; // too short to have prefix + real stem
+        for (const rule of [...PREFIX_RULES].sort((a, b) => b.prefix.length - a.prefix.length)) {
+            if (!clean.startsWith(rule.prefix))
+                continue;
+            const stem = clean.slice(rule.prefix.length);
+            if (stem.length < 3)
+                continue; // need a real stem
+            const data = nounsing.all(stem);
+            if (!data || data.length === 0)
+                continue;
+            const raw = data[0].stress?.stressTrans || '';
+            if (!raw || !raw.split('').some(c => c === '1' || c === '2'))
+                continue; // stem must carry stress
+            word.morphPrefix = rule.prefix;
+            break;
+        }
+    }
+}
+/**
+ * Stress Shift — swap primary↔secondary when Nounsing-Pro confirms the word
+ * CAN shift (`suffixShiftPotential` returns `shiftLikely: true`) and the
+ * phonological context motivates it.  This is NOT a global rule — it is
+ * grounded in the dictionary's own shift-likelihood assessment plus a
+ * syntactic/phonological context gate.
+ *
+ * Conditions (ALL must hold):
+ *  1. `suffixShiftPotential(word)` returns `shiftLikely: true`
+ *  2. The word's `stressTrans` has both `1` (primary) and `2` (secondary)
+ *  3. The LAST digit of `stressTrans` is `2` — secondary is on the final
+ *     syllable, so swapping 1↔2 moves primary TO the final
+ *  4. Context gate (either):
+ *     a. The word is a VB at the start of a phonological phrase (imperative
+ *        at phrase start — "REcognize" → "recogNIZE")
+ *     b. Rhythm Rule clash: a stressed syllable follows within 2 syllables
+ *        (the shift avoids a clash with the following stress)
+ *
+ * Words like "realize" (shiftLikely=false) are correctly EXCLUDED —
+ * Nounsing-Pro says they cannot shift, and the code respects that.
+ *
+ * Effect: swap the `lexicalStress` values of the primary (2) and secondary (1)
+ * syllables, so `peakSyllable` and all downstream computation see the shifted
+ * peak.  The syllables' `stress` (raw CMU) values are also swapped for
+ * consistency.
+ */
+export function applyStressShift(words, ius) {
+    // Build a set of words that are at the start of a phonological phrase
+    const ppInitials = new Set();
+    for (const iu of ius) {
+        for (const pp of iu.phonologicalPhrases) {
+            const toks = collectPPTokens(pp)
+                .filter(w => w.syllables.length > 0)
+                .sort((a, b) => a.absoluteIndex - b.absoluteIndex);
+            if (toks.length > 0)
+                ppInitials.add(toks[0]);
+        }
+    }
+    const stressed = words.filter(w => w.syllables.length > 0 && !isPunctuation(w.lexicalClass));
+    const flat = [];
+    for (const w of [...stressed].sort((a, b) => a.absoluteIndex - b.absoluteIndex))
+        for (const s of w.syllables)
+            flat.push({ word: w, syl: s });
+    for (const word of stressed) {
+        if (word.syllables.length < 3)
+            continue; // need 3+ syllables for a meaningful shift
+        const data = nounsing.all(word.word.toLowerCase().replace(/[''']/g, ''));
+        if (!data || data.length === 0)
+            continue;
+        const st = data[0].stress?.stressTrans ?? '';
+        if (!st)
+            continue;
+        // Condition 2: has both primary (1) and secondary (2)
+        if (!st.includes('1') || !st.includes('2'))
+            continue;
+        // Condition 3: the secondary (2) is at a HIGHER index than the primary
+        // (1) in the stressTrans string — the swap moves primary RIGHTWARD (toward
+        // the end of the word).  This covers both "recognize" (102: 1→0, 2→2) and
+        // "dictating" (120: 1→0, 2→1).  Words like "understand" (201: primary
+        // already on final) are correctly excluded — the swap would move primary
+        // leftward, which is wrong.
+        const idx1 = st.indexOf('1');
+        const idx2 = st.indexOf('2');
+        if (idx2 <= idx1)
+            continue;
+        // Condition 1: shiftLikely from Nounsing-Pro
+        let shiftLikely = false;
+        try {
+            const shift = nounsing.suffixShiftPotential(word.word.toLowerCase().replace(/[''']/g, ''));
+            if (shift && shift.length > 0)
+                shiftLikely = !!shift[0].shiftLikely;
+        }
+        catch { /* graceful no-op */ }
+        if (!shiftLikely)
+            continue;
+        // Condition 4: context gate — any verb form (VB*).  The stress shift is a
+        // well-known phonological process for English verbs (Rhythm Rule, imperative
+        // emphasis, compound stress).  Nounsing-Pro's shiftLikely already encodes
+        // the phonological possibility; restricting to verb forms excludes nouns
+        // like "potato" (NN, shiftLikely=true) that should NOT shift.  No PP-initial
+        // requirement — the shift applies to verb forms in any position, matching
+        // how English speakers actually shift stress in running speech.
+        if (!/^VB/.test(word.lexicalClass))
+            continue;
+        // Execute the shift: swap lexicalStress (and stress) of the primary(2→1)
+        // and secondary(1→2) syllables.  In our internal mapping:
+        //   CMU/nounsing 1=primary → lexicalStress 2
+        //   CMU/nounsing 2=secondary → lexicalStress 1
+        //   CMU/nounsing 0=unstressed → lexicalStress 0
+        // So we swap the syllable with lexicalStress===2 and the one with ===1.
+        let primarySyl = null;
+        let secondarySyl = null;
+        for (const s of word.syllables) {
+            if ((s.lexicalStress ?? s.stress) === 2)
+                primarySyl = s;
+            if ((s.lexicalStress ?? s.stress) === 1)
+                secondarySyl = s;
+        }
+        if (!primarySyl || !secondarySyl)
+            continue;
+        // Swap lexicalStress
+        const tmpLex = primarySyl.lexicalStress;
+        primarySyl.lexicalStress = secondarySyl.lexicalStress;
+        secondarySyl.lexicalStress = tmpLex;
+        // Swap raw stress too (for consistency with downstream that reads s.stress)
+        const tmpStress = primarySyl.stress;
+        primarySyl.stress = secondarySyl.stress;
+        secondarySyl.stress = tmpStress;
+    }
+}
 /** Archaic verbal suffixes whose orthographic peel cleanly separates a silent-
  *  consonant stem from the suffix for DISPLAY (know·est not kno·west).  Other
  *  suffixes keep the default orthographic syllabifier (it handles them well). */
@@ -468,6 +803,10 @@ const PRESTRESS_SUFFIXES = [
     // data-derived 2026-06-10: final-stressing (ultShift)
     { suffix: 'ette', offset: 1 }, { suffix: 'ese', offset: 1 },
     { suffix: 'eer', offset: 1 }, { suffix: 'ique', offset: 1 },
+    // -oon is a reliable final-stresser (bal·LOON, car·TOON, co·COON, after·NOON);
+    // OOV-only.  -ee/-ade are deliberately NOT added: they are impure (COF·fee,
+    // com·RADE, DEC·ade) and would mis-stress more than they fix.
+    { suffix: 'oon', offset: 1 },
     // data-derived: penult-stressing
     { suffix: 'ion', offset: 2 }, { suffix: 'sive', offset: 2 },
     { suffix: 'lla', offset: 2 }, { suffix: 'llo', offset: 2 },
@@ -493,8 +832,8 @@ const PRESTRESS_SUFFIXES = [
  * falls on a heavy penult, else the antepenult (Hayes 1982).  This fixes e.g.
  * an·FRAC·tuous / e·NIG·ma where blind forestress erred.
  */
-function englishStressRule(w, isContent) {
-    const n = countVowelGroups(w);
+function englishStressRule(w, isContent, properNoun = false) {
+    const n = countVowelGroups(w, properNoun);
     const primary = isContent ? 2 : 1;
     if (n <= 1)
         return [primary];
@@ -512,8 +851,35 @@ function englishStressRule(w, isContent) {
     const penult = n - 2; // final (n-1) is extrametrical
     const heavyPenult = sylls[penult] ? syllableIsHeavy(sylls[penult]) : true;
     pattern[heavyPenult ? penult : Math.max(0, n - 3)] = primary;
+    // A CONTENT polysyllable does not stay flat after its one primary — give it the
+    // rhythmic secondaries English requires (so an OOV 4+-syllable word reads with a
+    // real 'n'-tier beat, not a long unstressed tail).
+    if (isContent) {
+        const heavy = sylls.map(s => (s ? syllableIsHeavy(s) : false));
+        addSecondaryStresses(pattern, heavy);
+    }
     return pattern;
 }
+/** Hayes-style rhythmic SECONDARY stresses for an OOV content polysyllable that the
+ *  English Stress Rule has given a single primary (2).  English does not leave a long
+ *  word with one stress and a flat reduced tail: PRETONIC syllables alternating
+ *  leftward from the primary bear a secondary (1) — the metrical grid's lower beats —
+ *  e.g. Mìs·sis·SÌp·pi, à·pa·là·CHI·an.  Only the PRETONIC pattern is added: English
+ *  pre-stress secondaries are robust, whereas POST-tonic ones are weak and reduce, and
+ *  adding them nudged the meter-fitter on a handful of corpus lines for no qualitative
+ *  gain.  Deliberately conservative — a secondary is placed only ≥ 2 syllables from the
+ *  primary (so it can never clash with the primary or another secondary), so it can
+ *  only ADD the 'n'-tier differentiation the contour was missing, never a competing
+ *  beat. */
+function addSecondaryStresses(pattern, _heavy) {
+    const p = pattern.indexOf(2);
+    if (p < 2)
+        return; // need a primary with ≥ 2 pretonic syllables
+    for (let i = p - 2; i >= 0; i -= 2) { // pretonic alternation only
+        if (pattern[i] === 0)
+            pattern[i] = 1;
+    }
+}
 /**
  * Per-syllable heaviness from nounsing's `syllStruct` CV transcription
  * ("L.CL.CLC": C = consonant, L = lax/short nucleus, T = tense/long nucleus).
@@ -662,10 +1028,16 @@ export function assignLexicalStress(words) {
             word.isContent = isContent;
             // Tier 1: morphological stem (reuse real lexical stress); Tier 2: ESR.
             const morph = morphologicalStress(cleanWord);
-            const pattern = morph ? morph.pattern : englishStressRule(cleanWord, isContent);
+            const pattern = morph ? morph.pattern
+                : englishStressRule(cleanWord, isContent, /^NNPS?$/.test(word.lexicalClass));
             // Record an archaic verbal suffix so the display splits know·est, not kno·west.
             if (morph && DISPLAY_PEEL_SUFFIXES.has(morph.suffix))
                 word.morphSuffix = morph.suffix;
+            // Record a productive prefix so the display splits dis·il·lu·sions, not
+            // di·sil·lu·sions (the Maximal Onset principle would otherwise pull the
+            // prefix's final consonant into the next syllable).
+            if (morph && morph.prefix)
+                word.morphPrefix = morph.prefix;
             const syls = pattern.map(numeric => {
                 // Mirror the in-vocab function-word reduction (primary → secondary).
                 const n = (!isContent && numeric === 2) ? 1 : numeric;
@@ -738,7 +1110,12 @@ export function assignLexicalStress(words) {
         if (rawStress.length >= 2 && /^0+$/.test(rawStress)) {
             const cw = word.word.toLowerCase().replace(/-/g, '').replace(/['’]/g, '');
             const heavy = heavyFromSyllStruct(profile.phonology.syllStruct, rawStress.length);
-            const idx = defaultStressIndex(cw, rawStress.length, heavy);
+            // Rising/iambic function words (be·CAUSE, a·BOUT) recorded fully-reduced
+            // take FINAL-syllable stress; everything else keeps the forestress default
+            // (IN·to, and polysyllabic content artifacts).
+            const idx = RISING_FUNCTION_WORDS.has(cw)
+                ? rawStress.length - 1
+                : defaultStressIndex(cw, rawStress.length, heavy);
             rawStress = rawStress.split('').map((c, i) => (i === idx ? '1' : '0')).join('');
         }
         // Targeted fix for the "I'm" anomaly: a subject-pronoun contraction the
@@ -832,10 +1209,12 @@ export function assignLexicalStress(words) {
 /**
  * Adjust stresses for nominal compounds.
  *
- * Right‑stressed by default: the second content word keeps primary (2),
- * the first is reduced to secondary (1).
- * Known left‑stressed compounds (material, time, measure, location, self)
- * reverse the pattern.
+ * Fore-stressed by default: an N+N compound puts primary (2) on the first
+ * element, secondary (1) on the second — the Compound Stress Rule (Chomsky–
+ * Halle; McAleese marks ICE cream with primary on "ice", KITCHen table,
+ * WINdow frame).  The marked right-stress exceptions — food/temporal "made of"
+ * heads (apple PIE), Adj+N phrases (sweet CREAM), and proper-name sequences
+ * (New YORK) — reverse it.  All of this lives in `compoundStressSide`.
  */
 export function applyCompoundStress(ius) {
     for (const iu of ius) {
@@ -850,13 +1229,10 @@ export function applyCompoundStress(ius) {
                 // Wait, they must be adjacent in the sentence!
                 if (Math.abs(w1.absoluteIndex - w2.absoluteIndex) !== 1)
                     continue;
-                const pos1 = w1.lexicalClass;
-                const pos2 = w2.lexicalClass;
-                const isCompound = (pos2.startsWith('N') && (pos1.startsWith('N') || pos1.startsWith('J')));
-                if (!isCompound)
+                const side = compoundStressSide(w1.word, w1.lexicalClass, w2.word, w2.lexicalClass);
+                if (side === null)
                     continue;
-                const leftStressed = isLeftStressedPair(w1.word, w2.word);
-                if (leftStressed) {
+                if (side === 'left') {
                     setPrimaryStress(w1, 2);
                     setPrimaryStress(w2, 1);
                 }
@@ -869,7 +1245,7 @@ export function applyCompoundStress(ius) {
     }
 }
 /** Locate the syllable with the highest stress and set it to `value`. */
-function setPrimaryStress(word, value) {
+export function setPrimaryStress(word, value) {
     let maxIdx = -1;
     let maxVal = -1;
     for (let i = 0; i < word.syllables.length; i++) {
@@ -894,35 +1270,108 @@ export function applyNuclearStress(ius) {
     for (const iu of ius) {
         for (const pp of iu.phonologicalPhrases) {
             const words = collectPPTokens(pp).sort((a, b) => a.index - b.index);
-            // Find the rightmost content word and boost its primary by 1 level.
+            // The nuclear accent normally lands on the rightmost CONTENT word.
+            let target = null;
             for (let i = words.length - 1; i >= 0; i--) {
                 if (words[i].isContent) {
-                    const word = words[i];
-                    let maxIdx = -1;
-                    let maxVal = -1;
-                    for (let j = 0; j < word.syllables.length; j++) {
-                        if (word.syllables[j].stress > maxVal) {
-                            maxVal = word.syllables[j].stress;
-                            maxIdx = j;
-                        }
+                    target = words[i];
+                    break;
+                }
+            }
+            // But a content-less phrase ending in a non-oblique personal pronoun puts
+            // the nuclear accent on that final pronoun (NSR: the accent falls on the
+            // last accentable item; a clause-final addressee/focus pronoun bears it —
+            // "…to YOU").  Only when there is no content word to carry it, so "I KNOW
+            // you" is untouched; oblique objects (me/him/them) stay deaccented.
+            if (!target) {
+                let lastIdx = -1;
+                for (let i = words.length - 1; i >= 0; i--) {
+                    if (!isPunctuation(words[i].lexicalClass)) {
+                        lastIdx = i;
+                        break;
                     }
-                    if (maxIdx >= 0) {
-                        // Boost the rightmost content word's primary by 1.
-                        word.syllables[maxIdx].stress = word.syllables[maxIdx].stress + 1;
+                }
+                if (lastIdx >= 0) {
+                    const w = words[lastIdx];
+                    if (w.lexicalClass === 'PRP'
+                        && !OBLIQUE_PRONOUNS.has(w.word.toLowerCase().replace(/['’]/g, ''))) {
+                        target = w;
                     }
-                    break; // Only the rightmost content word gets boosted.
                 }
             }
+            if (target) {
+                let maxIdx = -1;
+                let maxVal = -1;
+                for (let j = 0; j < target.syllables.length; j++) {
+                    if (target.syllables[j].stress > maxVal) {
+                        maxVal = target.syllables[j].stress;
+                        maxIdx = j;
+                    }
+                }
+                if (maxIdx >= 0)
+                    target.syllables[maxIdx].stress += 1;
+            }
         }
     }
 }
 // ─── RELATIVE STRESS ASSIGNMENT (4‑LEVEL) ─────────────────────────
+/**
+ * Phrase-edge sets used for the "endings strict / beginnings loose" floor gate.
+ * McAleese (after Hayes & Kaun): metrical and lexical stress coincide at the
+ * ENDS of phonological units (clitic phrase 90% / phonological phrase 97% /
+ * intonational unit 99%); Selkirk notes a function word is not reduced at the
+ * end of a clitic phrase ("of" never → "o'" there).  So a function word at the
+ * right edge of a PP or IU — or the phrase-stress PEAK (nucleus) of its PP —
+ * resists the citation-floor reduction, while interior / left-edge function
+ * words reduce as before.  Reads the Phrase-Stress phase (word.phraseStress).
+ */
+function phraseEdgeSets(ius) {
+    const ppFinal = new Set();
+    const iuFinal = new Set();
+    const ppPeak = new Set();
+    for (const iu of ius) {
+        let iuLast = null;
+        for (const pp of iu.phonologicalPhrases) {
+            const toks = collectPPTokens(pp)
+                .filter(w => !isPunctuation(w.lexicalClass))
+                .sort((a, b) => a.index - b.index);
+            if (toks.length === 0)
+                continue;
+            const last = toks[toks.length - 1];
+            ppFinal.add(last);
+            iuLast = last;
+            let peak = toks[0];
+            let peakVal = peak.phraseStress ?? 0;
+            for (const t of toks) {
+                const v = t.phraseStress ?? 0;
+                if (v > peakVal) {
+                    peak = t;
+                    peakVal = v;
+                }
+            }
+            // Only protect a genuine nuclear ramp peak (phraseStress ≥ 2): an all-floor
+            // PP (all function words, or the Phase-Stress phase not run) has no nucleus
+            // to protect, so we must not spuriously shield its first token.
+            if (peakVal >= 2)
+                ppPeak.add(peak);
+        }
+        if (iuLast)
+            iuFinal.add(iuLast);
+    }
+    return { ppFinal, iuFinal, ppPeak };
+}
 /**
  * Convert numeric per‑syllable stress to McAleese’s symbolic levels
  * (w, n, m, s) and resolve adjacent identical stresses using dependency
  * information.
  */
 export function assignRelativeStresses(words, ius) {
+    // Phrase-edge sets for the endings-strict floor gate (read from Phase-Stress).
+    const edges = phraseEdgeSets(ius);
+    // Syllables raised by dependency-mined prominence (stranded preposition,
+    // contrastive possessive, vocative): protected from the per-PP trailing-run
+    // flatten so the recovered beat survives.
+    const prominenceProtected = new Set();
     // First pass: numeric → symbolic (0→w, 1→n, 2→m, 3+→s)
     // Use lexicalStress (pre-nuclear) so nuclear stress doesn't corrupt meter detection.
     for (const word of words) {
@@ -966,7 +1415,12 @@ export function assignRelativeStresses(words, ius) {
             // wh-word/coordinator is reduced in running speech; flooring it at 'n' is
             // what produced the flat function-word runs ("So on my", "where strange").
             // (Pure clitics the/a/of already read 'x' via the val===0 branch.)
-            if (syl.relativeStress === 'n' && isMonosyllabicClitic(word)) {
+            if (syl.relativeStress === 'n'
+                && (isMonosyllabicClitic(word) || word.word.toLowerCase() === 'am')) {
+                // "am" (1sg copula) is reliably reduced — far more so than beat-bearing
+                // is/are/was/were — so it floors at 'w' (still Attridge-promotable) rather
+                // than surfacing at 'm' as a spurious beat in "As I am BLOOD…".  Kept to
+                // this one form: flooring all be-verbs regressed Wyatt's accentual + corpus.
                 syl.relativeStress = 'w';
             }
             // Downgrade extrametrical syllables by one level.  We do NOT push a weak
@@ -982,6 +1436,55 @@ export function assignRelativeStresses(words, ius) {
                     syl.relativeStress = 'm';
             }
         }
+        // Honest baseline prominence: floor a monosyllabic function word to its true
+        // reading prominence ('x' schwa-clitic / 'w' overt-weak), never raising it.
+        // The dictionary's citation stress on "and"/"in"/"my"/"could" is an artefact;
+        // the meter layer re-promotes these where the metre needs a beat.
+        //
+        // ENDINGS STRICT / BEGINNINGS LOOSE (McAleese; Selkirk): withhold the floor
+        // for a function word at the right edge of a PP or IU, or one that is its
+        // PP's phrase-stress peak — it resists reduction there (a stranded/clause-
+        // final "to"/"you"/"of" is not crushed to a clitic).  Oblique object
+        // pronouns (me/him/thee…) are excepted: they stay default-deaccented even
+        // phrase-finally ("I gave it to HIM" only under focus, handled later).
+        const lemma = word.word.toLowerCase().replace(/['’]/g, '');
+        const edgeProtected = (edges.iuFinal.has(word) || edges.ppFinal.has(word) || edges.ppPeak.has(word))
+            && !OBLIQUE_PRONOUNS.has(lemma);
+        const floor = relativeFloorFor(word);
+        if (floor && !edgeProtected) {
+            const fr = STRESS_RANK[floor];
+            for (const syl of word.syllables) {
+                if (STRESS_RANK[syl.relativeStress ?? 'w'] > fr)
+                    syl.relativeStress = floor;
+            }
+        }
+        // Dependency-mined prominence (the parse IS the semantic layer): recover the
+        // beat a flat POS floor would crush.  A STRANDED preposition ("waiting FOR",
+        // "stare AT") and a CONTRASTIVE possessive ("THY choice, not mine") bear
+        // real stress → raise the peak to at least 'n' (promotable); a VOCATIVE
+        // address ("Sing, O GODDESS") to at least 'm'.  Raise-only; the raised peak
+        // is protected from the per-PP trailing-run flatten below.
+        let promoteTo = null;
+        if (isVocative(word, words) || isDeicticLocative(word, words))
+            promoteTo = 'm';
+        else if (isStrandedPreposition(word, words) || isContrastivePossessive(word, words))
+            promoteTo = 'n';
+        if (promoteTo) {
+            const pk = wordPeak(word);
+            if (pk && STRESS_RANK[pk.relativeStress ?? 'w'] < STRESS_RANK[promoteTo]) {
+                pk.relativeStress = promoteTo;
+            }
+            if (pk)
+                prominenceProtected.add(pk);
+        }
+        // Exclamatory interjection ("O", "Oh", "Ah", "Lo", "Alas"): emphatic, never
+        // reduced — raise its peak to at least 'n' (corrects the mis-tag that floored
+        // vocative "O"→IN→'x').  Raise-only; an exclaimed one is lifted further below.
+        if (EXCLAM_INTERJECTIONS.has(word.word.toLowerCase())) {
+            const pk = wordPeak(word);
+            if (pk && STRESS_RANK[pk.relativeStress ?? 'w'] < STRESS_RANK.n)
+                pk.relativeStress = 'n';
+        }
     }
     // Apply nuclear stress boosts to relative stress.
     // `syl.stress` may be higher than `syl.lexicalStress` after applyNuclearStress
@@ -1011,7 +1514,7 @@ export function assignRelativeStresses(words, ius) {
     for (const iu of ius) {
         for (const pp of iu.phonologicalPhrases) {
             const ppWords = collectPPTokens(pp);
-            resolveAdjacentClashes(ppWords);
+            resolveAdjacentClashes(ppWords, prominenceProtected);
         }
     }
     // Third pass: resolve clashes across prosodic boundaries (PP and IU).
@@ -1034,6 +1537,178 @@ export function assignRelativeStresses(words, ius) {
     // waste shore" leaving "waste"/"shore" non-adjacent in the tree though
     // contiguous in speech).  Catch any residual cardinal s–s clash here.
     resolveLinearClashes(words);
+    // Exclaimed interjection: an interjection immediately followed by "!" (Oh!, Ah!,
+    // O!, Lo!) is an emphatic peak — raise it one tier so it stands out from a flat
+    // run of neighbouring function words ("But—Oh! ye lords…" was a monotone n·n·n,
+    // with the interjection no louder than the conjunction beside it).  Narrow by
+    // construction: only an UH whose very next token is "!".
+    for (let i = 0; i < words.length - 1; i++) {
+        const w = words[i];
+        if (w.lexicalClass !== 'UH' || w.syllables.length === 0)
+            continue;
+        if (words[i + 1].word !== '!')
+            continue;
+        const pk = wordPeak(w);
+        if (!pk)
+            continue;
+        const r = STRESS_RANK[pk.relativeStress ?? 'w'];
+        if (r < STRESS_RANK.s)
+            pk.relativeStress = STRESS_LEVELS[r + 1];
+    }
+}
+/**
+ * Surface-order post-processing passes that re-assert forestress and resolve
+ * residual clashes AFTER the main relativisation.  These run in the Clio engine
+ * inside `assignRelativeStresses`; the Calliope engine calls this separately
+ * after `computeRelativeStress` so the same repairs reach both pipelines.
+ *
+ * The passes are:
+ *   1. resolveCompoundForestress — re-assert left-stress on surface-adjacent
+ *      N+N/J+N compounds the tagger mislabels (WASTE·shore, SEA·shore).
+ *   2. resolveCollocationForestress — forestress lexicalised collocations
+ *      (GOOD old, END-all, OLD days).
+ *   3. resolveHyphenCompounds — resolve dual-strong clashes at hyphen seams
+ *      (torch-flames, blood-red).
+ *   4. resolveLinearClashes — catch residual s-s / m-m / n-n surface clashes
+ *      with the full 7-level demotion cascade (lexical integrity → prominence →
+ *      syntactic headedness → content/function → weight → Rhythm Rule → default).
+ *   5. Exclaimed interjection raise — an interjection immediately followed by
+ *      "!" is lifted one tier ("But—Oh! ye lords…").
+ *
+ * All passes are DEMOTE-ONLY (or forestress re-assertions that raise the LEFT
+ * element of a known compound); none inflate the contour beyond what the lexicon
+ * and phrase-stress rules already established.
+ */
+export function applySurfacePostProcessing(words) {
+    resolveCompoundForestress(words);
+    resolveCollocationForestress(words);
+    resolveHyphenCompounds(words);
+    resolveLinearClashes(words);
+    resolvePhrasalVerbParticle(words);
+    raiseInterrogativePronounFocus(words);
+    // Exclaimed interjection: an interjection immediately followed by "!" (Oh!, Ah!,
+    // O!, Lo!) is an emphatic peak — raise it one tier so it stands out from a flat
+    // run of neighbouring function words.  Only an UH whose very next token is "!".
+    for (let i = 0; i < words.length - 1; i++) {
+        const w = words[i];
+        if (w.lexicalClass !== 'UH' || w.syllables.length === 0)
+            continue;
+        if (words[i + 1].word !== '!')
+            continue;
+        const pk = wordPeak(w);
+        if (!pk)
+            continue;
+        const r = STRESS_RANK[pk.relativeStress ?? 'w'];
+        if (r < STRESS_RANK.s)
+            pk.relativeStress = STRESS_LEVELS[r + 1];
+    }
+}
+/** Interrogative copula pronoun focus: in "Is it YOU?", "Was it HIM?", the
+ *  pronoun is the FOCUSED element — the question asks about identity, so the
+ *  complement pronoun carries the focus stress.  UDPipe mis-tags this as
+ *  NSUBJ (it parses "it" as ROOT, "you" as nsubj of "it"), but the real
+ *  structure is: "it" is the dummy subject, the pronoun is the predicate
+ *  complement.
+ *
+ *  Detection (very narrow, will NOT fire on the counter-examples):
+ *    1. A PRP (personal pronoun, NOT PRP$ possessive) tagged NSUBJ
+ *    2. Its governor is "it" (PRP, ROOT)
+ *    3. "it" has an AUX dependent that is a be-form (is/are/was/were/be/been)
+ *    4. The be-form is the first word of the sentence
+ *
+ *  Counter-examples that are correctly EXCLUDED:
+ *    - "I'm asleep" → "I" is NSUBJ of "asleep" (not of "it") → not matched
+ *    - "his mouth" → "his" is PRP$ (not PRP) → not matched
+ *    - "our youth" → "our" is PRP$ → not matched
+ *    - "we're awake" → "we" governor is "awake" (not "it") → not matched
+ *    - "I would give you" → "you" is DOBJ (not NSUBJ) of "give" → not matched */
+function raiseInterrogativePronounFocus(words) {
+    const BE_FORMS = new Set(['is', 'are', 'was', 'were', 'be', 'been', 'being',
+        "'s", "'re"]);
+    const real = words.filter(w => w.syllables.length > 0 && !isPunctuation(w.lexicalClass));
+    if (real.length === 0)
+        return;
+    for (const w of real) {
+        if (w.lexicalClass !== 'PRP')
+            continue;
+        if ((w.canonicalRel ?? '') !== 'NSUBJ')
+            continue;
+        const gov = w.dependency?.governor;
+        if (!gov || gov === w)
+            continue;
+        if (gov.word.toLowerCase() !== 'it' || gov.lexicalClass !== 'PRP')
+            continue;
+        if ((gov.canonicalRel ?? '') !== 'ROOT')
+            continue;
+        // Find the be-form AUX dependent of "it" that is the first word
+        const aux = real.find(x => (x.canonicalRel ?? '') === 'AUX' &&
+            x.dependency?.governor === gov &&
+            BE_FORMS.has(x.word.toLowerCase()));
+        if (!aux)
+            continue;
+        // The be-form must be the first real word of the sentence (interrogative
+        // verb-subject inversion)
+        const firstWord = real.sort((a, b) => a.absoluteIndex - b.absoluteIndex)[0];
+        if (aux !== firstWord)
+            continue;
+        // Found the interrogative copula construction: "Is it YOU?".
+        // 1. Raise the focused pronoun to 'm' — it is the information-seeking
+        //    element, the strongest stress in the question.
+        const pk = wordPeak(w);
+        if (pk) {
+            const r = STRESS_RANK[pk.relativeStress ?? 'w'];
+            if (r < STRESS_RANK.m)
+                pk.relativeStress = 'm';
+        }
+        // 2. Lower the dummy subject "it" to 'w' — it is an expletive, not a real
+        //    content word, and must not sit at 'n' creating a flat n-n-n chain with
+        //    the pronoun and the following adverb.
+        const itPk = wordPeak(gov);
+        if (itPk) {
+            const r = STRESS_RANK[itPk.relativeStress ?? 'w'];
+            if (r > STRESS_RANK.w)
+                itPk.relativeStress = 'w';
+        }
+    }
+}
+/** Phrasal-verb particle stress: in a VB+RP pair ("come ON", "take OFF", "give
+ *  UP"), the PARTICLE bears the stress — English phonology places the phrasal
+ *  accent on the particle, not the verb.  UDPipe confirms the relation via the
+ *  `compound:prt` dependency (canonicalRel='VPRT') or the RP POS tag.  When the
+ *  verb currently outranks the particle, swap their peaks: demote the verb one
+ *  rung, promote the particle to the verb's former level.  Only fires when they
+ *  are surface-adjacent (the particle immediately follows the verb). */
+function resolvePhrasalVerbParticle(words) {
+    const content = words.filter(w => w.syllables.length > 0 && !isPunctuation(w.lexicalClass));
+    for (let i = 0; i < content.length - 1; i++) {
+        const verb = content[i];
+        const particle = content[i + 1];
+        if (Math.abs(verb.absoluteIndex - particle.absoluteIndex) !== 1)
+            continue;
+        if (!/^VB/.test(verb.lexicalClass))
+            continue;
+        // The partner must be a phrasal-verb particle: RP POS, or has a prt/VPRT
+        // dependency on the verb, or is recovered by isPhrasalParticle.
+        const isParticle = particle.lexicalClass === 'RP' ||
+            (particle.canonicalRel ?? '') === 'VPRT' ||
+            particle.dependency?.dependentType === 'compound:prt' ||
+            (PARTICLE_LEMMAS.has(particle.word.toLowerCase()) &&
+                (particle.dependency?.dependentType === 'prt' ||
+                    particle.dependency?.dependentType === 'advmod'));
+        if (!isParticle)
+            continue;
+        const vPeak = wordPeak(verb);
+        const pPeak = wordPeak(particle);
+        if (!vPeak || !pPeak)
+            continue;
+        const rv = STRESS_RANK[vPeak.relativeStress ?? 'w'];
+        const rp = STRESS_RANK[pPeak.relativeStress ?? 'w'];
+        if (rv <= rp)
+            continue; // particle already ≥ verb → nothing to do
+        // Swap: particle gets the verb's level, verb drops one rung
+        pPeak.relativeStress = STRESS_LEVELS[rv];
+        vPeak.relativeStress = STRESS_LEVELS[Math.max(0, rv - 1)];
+    }
 }
 /** Ascending rank of the 5 relative-stress tiers, for level arithmetic. */
 const STRESS_RANK = { x: 0, w: 1, n: 2, m: 3, s: 4 };
@@ -1082,6 +1757,11 @@ function resolveCollocationForestress(words) {
     const seq = words
         .filter(w => !isPunctuation(w.lexicalClass) && w.syllables.length > 0)
         .sort((a, b) => a.absoluteIndex - b.absoluteIndex);
+    // Track words demoted as the RIGHT element of a collocation — a word just
+    // demoted (e.g. "old" in "GOOD old") must NOT be re-forestressed as the LEFT
+    // element of a following collocation ("old days"), or it would be raised back
+    // up and "days" would be wrongly demoted, destroying "GOOD old DAYS".
+    const demoted = new Set();
     for (let i = 0; i < seq.length - 1; i++) {
         const w1 = seq[i];
         const w2 = seq[i + 1];
@@ -1089,6 +1769,8 @@ function resolveCollocationForestress(words) {
             continue; // truly adjacent
         if (!isLeftStressedCollocation(w1, w2))
             continue;
+        if (demoted.has(w1))
+            continue; // w1 was a prior collocation's right element — don't re-forestress
         const s1 = wordPeak(w1);
         const s2 = wordPeak(w2);
         if (!s1 || !s2)
@@ -1098,6 +1780,7 @@ function resolveCollocationForestress(words) {
         const hi = Math.max(r1, r2);
         s1.relativeStress = STRESS_LEVELS[hi]; // left element ≥ both
         s2.relativeStress = STRESS_LEVELS[Math.min(r2, Math.max(0, hi - 1))]; // demote-only
+        demoted.add(w2);
     }
 }
 /**
@@ -1133,45 +1816,119 @@ function resolveHyphenCompounds(words) {
     }
 }
 /**
- * Resolve cardinal stress clashes on the linear surface sequence: two
- * *contiguous* syllables both at the strongest level ('s') with no weaker
- * syllable between them.  Per McAleese/Hayes, retract the LEFT stress one level
- * (s→m), with within-word-peak protection so a polysyllable's own peak is never
- * demoted for an adjacent monosyllable (the monosyllable yields instead).
+ * THE CLASH FILTER — an absolute surface well-formedness constraint.
+ *
+ * On the STRESSED tier {n, m, s} no two *contiguous* syllables may carry the SAME
+ * level: that is a stress clash (two equal prominences with no gradation between
+ * them), which English categorically disallows.  Gradient pairs (sm/ms/sn/ns/mn/nm)
+ * are fine — there is still a step down — as are runs of the unstressed tiers
+ * {w, x} (an unstressed sequence is tolerated, if not ideal).  This generalises
+ * McAleese's Appendix-A step 3d-ii ("stress clashes (ss, ms) > s-s") and Liberman
+ * & Prince's (1977) grid alternation to every level of the strong tier.
  *
- * Deliberately limited to s–s (the cardinal clash the methodology resolves
- * unconditionally): m–m and lower are often metrically meaningful (spondaic /
- * emphatic substitutions) and are left for the meter layer to weigh.
+ * Resolution is DEMOTE-ONLY (never promote — promotion is the meter layer's job,
+ * McAleese Test 2), so the contour is never inflated to break a clash; we iterate
+ * to a fixed point (each change strictly lowers total stress mass, so it
+ * terminates).  Which member yields is decided by `demoteRightOfClash` (grid-based
+ * relative prominence).  Runs on the LINEAR surface order because a clash is a
+ * property of contiguous *pronounced* syllables (Hayes), which a mis-grouped
+ * dependency parse can scatter across phrases.
  */
-function resolveLinearClashes(words) {
+export function resolveLinearClashes(words) {
     const flat = [];
     for (const w of words)
         for (const s of w.syllables)
             flat.push({ word: w, syl: s });
-    for (let i = 0; i < flat.length - 1; i++) {
-        const a = flat[i];
-        const b = flat[i + 1];
-        if (a.syl.relativeStress !== 's' || b.syl.relativeStress !== 's')
-            continue;
-        if (a.word === b.word)
-            continue; // intra-word clashes → silent beat downstream
-        const aPeak = a.word.syllables.length > 1 && a.syl === wordPeak(a.word);
-        const bPeak = b.word.syllables.length > 1 && b.syl === wordPeak(b.word);
-        // Protect a polysyllable's peak: if only the left is a peak and the right is
-        // a lone monosyllable, retract the monosyllable instead.
-        if (aPeak && !bPeak && b.word.syllables.length === 1) {
-            demoteOneLevel(b.syl);
-        }
-        else {
-            demoteOneLevel(a.syl); // Hayes: retract the left stress
+    let changed = true;
+    let guard = 0;
+    while (changed && guard++ < 24) {
+        changed = false;
+        for (let i = 0; i < flat.length - 1; i++) {
+            const a = flat[i];
+            const b = flat[i + 1];
+            const lvl = a.syl.relativeStress;
+            if (lvl !== b.syl.relativeStress)
+                continue;
+            if (lvl !== 'n' && lvl !== 'm' && lvl !== 's')
+                continue; // only the stressed tier clashes
+            // Intra-word clashes are NOT skipped: a hyphenated-compound seam
+            // (deep·voiced, snow·storm, gate·bolts) or any word with two adjacent equal
+            // stresses is still a clash, and must be made gradient like any other.
+            if (demoteRightOfClash(flat, i))
+                demoteOneLevel(b.syl);
+            else
+                demoteOneLevel(a.syl);
+            changed = true;
         }
     }
 }
+/**
+ * Decide which member of an equal-stress clash at (i, i+1) yields.  Rather than a
+ * blunt leftward retraction, a layered cascade consults — in descending
+ * authority — lexical, syntactic, and phonological context, so the demotion is
+ * theory-grounded and the arbitrary default fires only as a last resort.  Returns
+ * true to demote the RIGHT member (i+1), false to demote the LEFT (i).
+ *
+ *   1. Lexical integrity (Kiparsky): never demote a polysyllable's own stress
+ *      peak for an adjacent monosyllable — the monosyllable yields.
+ *   2. Inherent lexical prominence: a primary-stressed syllable outranks a
+ *      secondary one — the lower-lexical-stress member yields.
+ *   3. Syntactic headedness (Nuclear Stress Rule; Liberman & Prince 1977; Cinque
+ *      1993): when the two words stand in a direct head–dependent relation, the
+ *      DEPENDENT yields to its governor (the phrasal head is the more prominent).
+ *   4. Content/function asymmetry — a coarse proxy for headedness when no direct
+ *      dependency links the pair: the function word yields.
+ *   5. Phonological weight: a light (open, short-vowel) syllable reduces more
+ *      readily than a heavy (closed / long-vowel) one — the lighter member yields.
+ *   6. Rhythm Rule (Liberman & Prince 1977; Hayes 1984): the clash member abutting
+ *      the stronger OUTER beat is that beat's off-beat, so it retracts — "wet
+ *      CHURCH" retracts wet (church is nuclear), "LATE last NIGHT" retracts last
+ *      onto late (night is the following beat).
+ *   7. Default (Hayes): retract the LEFT stress.
+ */
+function demoteRightOfClash(flat, i) {
+    const a = flat[i];
+    const b = flat[i + 1];
+    // (1) lexical integrity
+    const aPeak = a.word.syllables.length > 1 && a.syl === wordPeak(a.word);
+    const bPeak = b.word.syllables.length > 1 && b.syl === wordPeak(b.word);
+    if (aPeak && !bPeak && b.word.syllables.length === 1)
+        return true;
+    if (bPeak && !aPeak && a.word.syllables.length === 1)
+        return false;
+    // (2) inherent lexical prominence
+    const la = a.syl.lexicalStress ?? a.syl.stress ?? 0;
+    const lb = b.syl.lexicalStress ?? b.syl.stress ?? 0;
+    if (la !== lb)
+        return la > lb;
+    // (3) syntactic headedness — the dependent yields to its governor
+    if (a.word !== b.word) {
+        const gov = getGovernor(a.word, b.word);
+        if (gov === a.word)
+            return true; // a heads b → demote b
+        if (gov === b.word)
+            return false; // b heads a → demote a
+    }
+    // (4) content/function asymmetry — the function word yields
+    if (a.word.isContent !== b.word.isContent)
+        return a.word.isContent;
+    // (5) phonological weight — the lighter syllable yields
+    if (a.syl.weight && b.syl.weight && a.syl.weight !== b.syl.weight) {
+        return a.syl.weight === 'H'; // a heavy → demote the lighter b
+    }
+    // (6) Rhythm Rule — yield to the stronger adjacent (outer) beat
+    const outerA = i - 1 >= 0 ? STRESS_RANK[flat[i - 1].syl.relativeStress ?? 'w'] : -1;
+    const outerB = i + 2 < flat.length ? STRESS_RANK[flat[i + 2].syl.relativeStress ?? 'w'] : -1;
+    if (outerA !== outerB)
+        return outerB > outerA;
+    // (7) default: retract the left
+    return false;
+}
 /**
  * Scan across the linear sequence of syllables and adjust any adjacent
  * identical relative stress levels using syntactic governance.
  */
-function resolveAdjacentClashes(words) {
+function resolveAdjacentClashes(words, protect) {
     // "Endings strict": when a phrase ends in a run of two or more bare function
     // words (e.g. "…fast as you MIGHT"), the metrical beat gravitates to one of
     // them; the others are upbeat.  Demote the others so a leftward governance
@@ -1199,6 +1956,9 @@ function resolveAdjacentClashes(words) {
                     // internal stress (be·HIND) to 'w' just because the word is functional.
                     if (w.syllables.length > 1 && s === peak && (s.lexicalStress ?? s.stress) >= 1)
                         continue;
+                    // Protect a dependency-mined prominence (stranded preposition etc.).
+                    if (protect && protect.has(s))
+                        continue;
                     s.relativeStress = 'w';
                 }
             }
@@ -1216,6 +1976,11 @@ function resolveAdjacentClashes(words) {
         const b = flat[i + 1];
         if (a.syl.relativeStress !== b.syl.relativeStress)
             continue;
+        // Only the stressed tier {n,m,s} clashes; {w,x} may repeat (maintainer's rule:
+        // an unstressed run is tolerated, never "resolved" by demoting a clitic to 'x').
+        const lvl = a.syl.relativeStress;
+        if (lvl !== 'n' && lvl !== 'm' && lvl !== 's')
+            continue;
         // Within-word strictness (Kiparsky): a polysyllabic word's own stress peak
         // must not be demoted below its word-mates by a clash with an adjacent
         // monosyllable.  Protect the peak; demote the monosyllable instead.
@@ -1333,6 +2098,10 @@ function resolveCrossBoundaryClashes(words, ius) {
         const b = flat[i + 1];
         if (a.syl.relativeStress !== b.syl.relativeStress)
             continue;
+        // Only the stressed tier {n,m,s} clashes; {w,x} may repeat (maintainer's rule).
+        const lvl = a.syl.relativeStress;
+        if (lvl !== 'n' && lvl !== 'm' && lvl !== 's')
+            continue;
         // Only adjust if they span a prosodic boundary
         if (a.ppKey === b.ppKey)
             continue;
@@ -1345,7 +2114,11 @@ function resolveCrossBoundaryClashes(words, ius) {
             demoteOneLevel(a.syl);
         }
         else {
-            // Both same content/function type — try dependency relationship
+            // Both same content/function type — try dependency relationship.
+            // (A blanket Selkirk "demote the PP-initial" was tried and regressed
+            // litlab/prosodic: the linear-clash cascade's nuanced resolution — weight,
+            // Rhythm Rule, governance — captures "beginnings loose" better than a flat
+            // directional rule, so a clash with no governance is left for it.)
             const governor = getGovernor(a.word, b.word);
             if (governor === a.word) {
                 adjustAdjacent(a.syl, b.syl, governorDependentDirection);