calliope-ts 0.0.2 → 0.0.3

package/src/phonological.ts

@@ -596,9 +596,33 @@ function quickSyllableCount(s: string): number {
   return Math.max(1, groups);
 }
 
-export function syllabifyWord(word: string, syllableCount: number, vowelLengths?: VowelLength[], morphSuffix?: string): string[] {
+export function syllabifyWord(word: string, syllableCount: number, vowelLengths?: VowelLength[], morphSuffix?: string, morphPrefix?: string): string[] {
   if (syllableCount <= 1) return [word];
 
+  // Morpheme-aware prefix peel: when OOV stress assignment validated a productive
+  // prefix ("dis"), split it off as the first syllable(s) so the stem keeps its
+  // spelling (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).
+  // The prefix's own syllable count is estimated orthographically; the stem gets
+  // the remaining syllables.
+  if (morphPrefix && syllableCount >= 2
+      && word.toLowerCase().startsWith(morphPrefix)
+      && word.length > morphPrefix.length + 1) {
+    const prefixSylls = quickSyllableCount(morphPrefix);
+    if (prefixSylls < syllableCount) {
+      const prefixChunk = word.slice(0, morphPrefix.length);
+      const stemChunk = word.slice(morphPrefix.length);
+      const stemChunks = syllabifyWord(stemChunk, syllableCount - prefixSylls,
+        vowelLengths ? vowelLengths.slice(prefixSylls) : undefined, morphSuffix);
+      // If the prefix is polysyllabic, syllabify it on its own; monosyllabic → as-is.
+      const prefixChunks = prefixSylls > 1
+        ? syllabifyWord(prefixChunk, prefixSylls)
+        : [prefixChunk];
+      const result = [...prefixChunks, ...stemChunks];
+      if (result.length === syllableCount) return result;
+    }
+  }
+
   // Lexical compound boundary (someone → some·one, not so·meone).  Only when the
   // constituents' own syllable counts add up to the requested total.
   {
@@ -653,8 +677,14 @@ export function syllabifyWord(word: string, syllableCount: number, vowelLengths?
   const lower = cleanWord.toLowerCase();
   const n = lower.length;
 
-  // Common English consonant digraphs
-  const DIGRAPHS = new Set(['ch', 'sh', 'th', 'wh', 'ph', 'gh', 'ck', 'ng', 'wr', 'kn', 'gn']);
+  // Common English consonant digraphs.  "kn"/"gn"/"wr" are EXCLUDED: they are
+  // digraphs only WORD-INITIALLY (where the first consonant is silent — "know",
+  // "gnaw", "write"), and the digraph set is used only for MEDIAL boundary
+  // placement.  In medial position ("frankness") "kn" is two pronounced
+  // consonants: /k/ closes the first syllable (frank), /n/ opens the second
+  // (ness) — treating it as a medial digraph sends both to the next syllable
+  // ("fran-kness"), which is wrong.
+  const DIGRAPHS = new Set(['ch', 'sh', 'th', 'wh', 'ph', 'gh', 'ck', 'ng']);
   // Digraphs that commonly end syllables (codas)
   const CODA_DIGRAPHS = new Set(['ch', 'sh', 'ck', 'ng', 'th']);
   // "Muta cum liquida": an obstruent + liquid/glide that, between vowels, stays
@@ -679,6 +709,17 @@ export function syllabifyWord(word: string, syllableCount: number, vowelLengths?
   // (want·ed, embed·ded), so those are excluded.
   const endsSilentEd = n >= 3 && lower.endsWith('ed')
     && !VOWEL_CHARS.has(lower[n - 3]) && lower[n - 3] !== 't' && lower[n - 3] !== 'd';
+  // Non-syllabic inflectional "-es": the 'e' in a final "…Xes" (X a consonant
+  // other than a vowel — so "goes"/"shoes" are excluded, where 'e' is part of a
+  // vowel digraph) is silent when the nucleus count exceeds the CMU syllable
+  // count.  This is the VCe pattern extended to plurals/3sg: the 'e' makes the
+  // preceding vowel long and is not itself pronounced (receives = re·CEIVES,
+  // makes = MAKES, writes = WRITES).  When the stem ends in a sibilant
+  // (bus→buses, bush→bushes) the 'e' IS syllabic, but in that case the nucleus
+  // count already matches the syllable count and this check never fires — the
+  // surplus-nucleus guard makes it safe.
+  const endsSilentEs = n >= 3 && lower.endsWith('es')
+    && !VOWEL_CHARS.has(lower[n - 3]);
 
   interface Nucleus { start: number; end: number }
   const nuclei: Nucleus[] = [];
@@ -707,6 +748,33 @@ export function syllabifyWord(word: string, syllableCount: number, vowelLengths?
     const last = nuclei[nuclei.length - 1];
     if (last.start === n - 2 && last.end === n - 1) nuclei.pop();
   }
+  // Same for non-syllabic "-es": drop the silent 'e' when there's a surplus
+  // (receives = 3 nuclei → 2 syllables → drop → re·ceives, not recei·ves).
+  if (nuclei.length > syllableCount && endsSilentEs) {
+    const last = nuclei[nuclei.length - 1];
+    if (last.start === n - 2 && last.end === n - 1) nuclei.pop();
+  }
+
+  // Vowel hiatus: if we have TOO FEW nuclei, a multi-vowel nucleus (≥2 vowel
+  // characters scanned as one group) is a HIATUS — two syllabic vowels in
+  // adjacent syllables — not a diphthong.  Split the rightmost multi-vowel
+  // nucleus, peeling off its last vowel char as a new nucleus, until nuclei
+  // match the syllable count.  English hiatus tends word-ward ("-ia", "-eo"),
+  // so rightmost-first is the right priority.  This respects the authoritative
+  // CMU syllable count ("hysterias" = 4: hys·te·ri·as, not 3) and prevents the
+  // crude fallback chunker from producing nonsensical splits like "hy·ST·eri·as"
+  // (treating "ST" as a syllable nucleus).
+  while (nuclei.length < syllableCount) {
+    let splitIdx = -1;
+    for (let j = nuclei.length - 1; j >= 0; j--) {
+      if (nuclei[j].end - nuclei[j].start >= 2) { splitIdx = j; break; }
+    }
+    if (splitIdx < 0) break;                         // no multi-vowel nucleus left
+    const nuc = nuclei[splitIdx];
+    nuclei.splice(splitIdx, 1,
+      { start: nuc.start, end: nuc.end - 1 },
+      { start: nuc.end - 1, end: nuc.end });
+  }
 
   while (nuclei.length > syllableCount && nuclei.length > 1) {
     let minConsonants = Infinity;
@@ -830,7 +898,7 @@ export function flattenDisplayEntries(words: ClsWord[]): SyllableDisplayEntry[]
   for (const w of words) {
     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++) {
       result.push({
         wordText: w.word,

package/src/phrasestress.ts

@@ -0,0 +1,108 @@
+// phrasestress.ts — McAleese's Phrase-Stress phase (previously SKIPPED).
+//
+// The pipeline used to map lexical stress straight to relative stress (plus a
+// single "+1 on the rightmost content word"), leaving `ClsWord.phraseStress`
+// a vestigial field stuck at 0.  This module restores the genuine phase that
+// sits BETWEEN lexical and relative stress in McAleese's procedure (thesis
+// Appendix A; Chomsky & Halle's Nuclear + Compound Stress Rules):
+//
+//   1. every word starts at 1;
+//   2. the Compound Stress Rule pins a compound's subordinate element at the
+//      floor while its principal stays in the ramp;
+//   3. the recursive Nuclear Stress Rule ramps the principal stress of each
+//      successive *stressed* word left-to-right, so prominence rises to the
+//      phrase's nuclear (rightmost) peak.
+//
+// For the right-branching structure of English declaratives the recursive NSR
+// reduces to a monotone ramp over the stressed words — function words and
+// compound-subordinates pinned at 1.  NOTE the convention: here 1 is the FLOOR
+// and the ramp climbs RIGHTWARD to the nuclear peak (the "If hairs…" example
+// below).  McAleese's "Mary ate sweet ice cream" worked example uses the
+// OPPOSITE (SPE) numbering — 1 = PRIMARY/strongest, weakened outward — so his
+// ICE cream (primary on "ice") is reproduced here as ice=PEAK, cream=floor
+// (the compound's HEAD "cream" is the subordinate, pinned at 1):
+//
+//   "Mary ate sweet ice cream"  -> Mary2 ate3 sweet4 ice5 cream1  (ICE cream: head subordinate)
+//   "If hairs be wires, black wires grow on her head" -> 1 2 3 4 5 6 7 1 1 8
+//
+// (Marked / left-branching structures are approximated by the same ramp; a
+// constituent-tree-driven refinement over `sentence.nodes` is a flagged
+// follow-up.  This module reads only POS / content flags and surface order,
+// and writes only the previously-unused phraseStress field — purely additive.)
+
+import { ClsWord } from './types.js';
+import { isPunctuation } from './parser.js';
+import { compoundStressSide } from './stress.js';
+
+/** Sentence-final punctuation resets the nuclear ramp (the NSR is
+ *  sentence-bounded).  A comma / colon / dash does NOT — the ramp runs across
+ *  an internal intonational break (cf. "If hairs…, black wires…" → 1234…5,678). */
+const SENTENCE_FINAL = new Set(['.', '!', '?', '…']);
+
+/** Common-/proper-noun POS tags, gating which compounds floor an element. */
+const NOUN_TAGS = new Set(['NN', 'NNS', 'NNP', 'NNPS']);
+
+/**
+ * Proclitic POS tags pinned at the phrase-stress floor: the NSR ramp applies to
+ * *stressed words* (nouns, adjectives, adverbs, and VERBS — including the
+ * copula/auxiliary "be" and modals, which bear lexical stress even though they
+ * reduce in the contour), while pure clitics carry none.  Verbs are NOT here,
+ * so McAleese's "if hairs BE wires…" keeps `be` in the ramp (=3).  A word the
+ * earlier pipeline promoted to content (a phrasal-verb particle, a focus
+ * demonstrative — `isContent === true`) is un-pinned and ramps.
+ */
+const PINNED_POS = new Set([
+  'IN', 'TO', 'DT', 'CC', 'PRP', 'PRP$', 'WP', 'WP$', 'WDT', 'EX', 'POS',
+]);
+
+/**
+ * Populate `word.phraseStress` for every word of a parsed sentence.
+ */
+export function computePhraseStress(words: ClsWord[]): void {
+  const subordinate = compoundSubordinates(words);
+  let ramp = 1; // running nuclear ramp; the floor for pinned words is 1
+  for (const w of words) {
+    if (isPunctuation(w.lexicalClass)) {
+      w.phraseStress = 0;
+      if (SENTENCE_FINAL.has(w.word)) ramp = 1;
+      continue;
+    }
+    // Pinned at the floor: a proclitic function word bears no nuclear ramp, and
+    // a compound's subordinate element is demoted by the Compound Stress Rule.
+    const isClitic = PINNED_POS.has(w.lexicalClass) && !w.isContent;
+    if (isClitic || subordinate.has(w)) {
+      w.phraseStress = 1;
+      continue;
+    }
+    w.phraseStress = ++ramp;
+  }
+}
+
+/**
+ * Identify the subordinate (pinned) element of each surface-adjacent compound,
+ * delegating the direction to `compoundStressSide` (the shared rule, so phrase
+ * stress and the lexical compound pass cannot disagree).
+ *   - fore-stress ('left') → the HEAD (right) element is subordinate: SEA·shore,
+ *     ICE cream, KITCHen table — the Compound Stress Rule default for N+N;
+ *   - right-stress ('right') → the MODIFIER (left) is subordinate: apple PIE,
+ *     and proper-name pairs (New YORK);
+ *   - Adjective+noun ("sweet cream") is phrasal, not a compound (`side` is
+ *     'right' there too, so the modifier "sweet" is pinned and "cream" ramps —
+ *     i.e. end-stress, as desired).
+ */
+function compoundSubordinates(words: ClsWord[]): Set<ClsWord> {
+  const subs = new Set<ClsWord>();
+  for (let i = 0; i + 1 < words.length; i++) {
+    const a = words[i], b = words[i + 1];
+    if (isPunctuation(a.lexicalClass) || isPunctuation(b.lexicalClass)) continue;
+    if (!a.isContent || !b.isContent) continue;
+    const side = compoundStressSide(a.word, a.lexicalClass, b.word, b.lexicalClass);
+    // Floor an element only for a genuine N+N compound; an Adj+N ("sweet ice",
+    // "red car") is phrasal — its end-stress emerges from the ramp itself, so we
+    // pin nothing and let the adjective ramp (McAleese: sweet=4, above cream).
+    const bothNouns = NOUN_TAGS.has(a.lexicalClass) && NOUN_TAGS.has(b.lexicalClass);
+    if (side === 'left') subs.add(b);              // fore-stress compound: head subordinate (ICE cream)
+    else if (side === 'right' && bothNouns) subs.add(a); // right-stress N+N: modifier subordinate (apple PIE)
+  }
+  return subs;
+}