calliope-ts 0.0.2 → 0.0.4

package/dist/calliope/engine.js

@@ -0,0 +1,71 @@
+// calliope/engine.ts — the "Calliope" engine: the faithful, default,
+// syntax-driven prosody pipeline.  It derives the κ/ϕ/ι prosodic hierarchy and
+// word prominence from a canonical, DepEdit-normalised dependency parse via the
+// Scenario A–O relation-keyed stress rules and the corrected Match-Theory
+// boundary map.
+//
+// Build status: STAGE 0 — the engine seam is in place but the per-sentence
+// sequence is, for now, identical to the legacy ("Clio") one, so the default
+// output is unchanged and the existing tests stay green.  Stages 1–4 progressively
+// replace the body with: canonical deps (Stage 1) → Match-Theory hierarchy
+// (Stage 2) → Scenario A–O stress (Stage 3) → phrase-stress ramp + relativise
+// (Stage 4).  The legacy path remains untouched in `src/clio/engine.ts`.
+import { assignLexicalStress, applySurfacePostProcessing, detectDisplayPrefixes, applyStressShift } from '../stress.js';
+import { correctPosWithLexicon } from './postag.js';
+import { tagNames } from './names.js';
+import { parseFeats } from './feats.js';
+import { normalizeDeps } from './deps.js';
+import { buildProsodicHierarchy } from './prosodic.js';
+import { computePhraseStress } from './bracketing.js';
+import { computeRelativeStress } from './relstress.js';
+function analyzeSentenceCalliope(sent) {
+    // ── Stage F1: reliable parse over the whole utterance (Calliope-only). ──
+    // Correct spurious proper-noun tags via en-lexicon (Pale/High → JJ); type real
+    // proper nouns as person/place names; normalise en-parse's hybrid relations into
+    // the Scenario label space on word.canonicalRel (with surface-adjacency fallback
+    // for pre-head modifiers).  Mutates the Calliope-only view of the parse; Clio,
+    // invoked via --clio, never runs these and keeps its frozen reading.
+    correctPosWithLexicon(sent);
+    tagNames(sent);
+    // Parse UD morphological FEATS (Number/VerbForm/Voice/PronType/Definite/Degree/…)
+    // from lexicalDetails onto word.featsMap so the Wagner/Krifka stress + bracketing
+    // refinements can read morphology.  Must precede normalizeDeps (which may consult it).
+    parseFeats(sent);
+    normalizeDeps(sent);
+    // ── Stress path: lexical → genuine phrase stress → relative, per McAleese E4. ──
+    // 1. Lexical stress (syllabification + word contour 0-3).
+    // 2. κ/ϕ/ι hierarchy fixed over the whole utterance from the dependency relations.
+    // 3. PHRASE STRESS: the genuine cyclic Compound + Nuclear Stress Rules over the
+    //    dependency tree's constituent bracketing (bracketing.ts) — an integer
+    //    prominence ranking (1 = strongest utterance nuclear), NOT a ramp.
+    // 4. RELATIVE STRESS: the x/w/n/m/s contour DERIVED per φ from that phrase stress
+    //    (the φ's lowest-phraseStress word is its beat), then clash-resolved.  The two
+    //    layers are separate signals — global integer vs local contour — free to
+    //    diverge.  (Replaces the legacy compound→nuclear→phrase→relativise chain, which
+    //    Clio still runs.)
+    assignLexicalStress(sent.words);
+    // Display-only prefix detection: set `morphPrefix` on words whose productive
+    // prefix + dictionary stem split would guide the display syllabifier to
+    // respect the morpheme boundary (dis·il·lu·sions, un·ed·u·ca·ted).  Runs for
+    // ALL words (in-vocab AND OOV), never affects stress or meter.
+    detectDisplayPrefixes(sent.words);
+    const ius = buildProsodicHierarchy(sent);
+    // Stress Shift: swap primary↔secondary for words where Nounsing-Pro confirms
+    // shiftLikely=true AND the context motivates it (imperative at phrase start or
+    // Rhythm Rule clash).  Runs after hierarchy (needs PP-initial info) but before
+    // phrase stress (so the shifted peak flows into the NSR ramp).
+    applyStressShift(sent.words, ius);
+    computePhraseStress(sent);
+    computeRelativeStress(sent.words, ius);
+    // Surface-order post-processing passes shared with the Clio engine: compound
+    // forestress, lexicalised collocation forestress, hyphen-seam clash resolution,
+    // residual linear clash resolution, and exclaimed-interjection raise.  These
+    // re-assert forestress on surface-adjacent pairs the hierarchy-order passes may
+    // miss (mis-grouped parses) and catch any residual equal-stress clashes.
+    applySurfacePostProcessing(sent.words);
+    return ius;
+}
+export const calliopeEngine = {
+    name: 'calliope',
+    analyzeSentence: analyzeSentenceCalliope,
+};

package/dist/calliope/feats.d.ts

@@ -0,0 +1,9 @@
+import { ClsSentence, ClsWord } from '../types.js';
+/** Populate `word.featsMap` for every word in the sentence from `lexicalDetails`. */
+export declare function parseFeats(sent: ClsSentence): void;
+/** Read one morphological feature, undefined if absent.  Lazily parses on demand
+ *  so callers reached before `parseFeats` still work. */
+export declare function feat(w: ClsWord, key: string): string | undefined;
+/** True when a feature has the given value. */
+export declare function featIs(w: ClsWord, key: string, value: string): boolean;
+//# sourceMappingURL=feats.d.ts.map

package/dist/calliope/feats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feats.d.ts","sourceRoot":"","sources":["../../src/calliope/feats.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAgBnD,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAKlD;AAED;yDACyD;AACzD,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGhE;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEtE"}

package/dist/calliope/feats.js

@@ -0,0 +1,45 @@
+// calliope/feats.ts — parse UD morphological FEATS onto ClsWord (Phase 1 enabler).
+//
+// The parser stores the raw FEATS string ("Number=Sing|Person=3|Tense=Pres|
+// VerbForm=Fin") on `word.lexicalDetails`, but no downstream module could read it:
+// `udpos.ts:feat()` only sees the UDPipe-level `UDWord.featsMap` at parse time.  This
+// pass parses `lexicalDetails` into `word.featsMap` ONCE, early in the Calliope
+// pipeline, so the stress / bracketing / relativiser modules can key on morphology
+// (VerbForm=Part → participle, Voice=Pass → underlying object subject, PronType=Prs →
+// inherently given, Degree=Cmp → JJR, …).  Pure plumbing — it mutates only the
+// additive `featsMap`, never the parse.
+/** Parse a UD FEATS string ("A=b|C=d") into a key→value record. */
+function parseFeatsString(raw) {
+    const out = {};
+    if (!raw)
+        return out;
+    for (const pair of raw.split('|')) {
+        const eq = pair.indexOf('=');
+        if (eq <= 0)
+            continue;
+        const k = pair.slice(0, eq).trim();
+        const v = pair.slice(eq + 1).trim();
+        if (k && v)
+            out[k] = v;
+    }
+    return out;
+}
+/** Populate `word.featsMap` for every word in the sentence from `lexicalDetails`. */
+export function parseFeats(sent) {
+    for (const w of sent.words) {
+        if (w.featsMap)
+            continue; // already parsed (idempotent)
+        w.featsMap = parseFeatsString(w.lexicalDetails);
+    }
+}
+/** Read one morphological feature, undefined if absent.  Lazily parses on demand
+ *  so callers reached before `parseFeats` still work. */
+export function feat(w, key) {
+    if (!w.featsMap)
+        w.featsMap = parseFeatsString(w.lexicalDetails);
+    return w.featsMap[key];
+}
+/** True when a feature has the given value. */
+export function featIs(w, key, value) {
+    return feat(w, key) === value;
+}

package/dist/calliope/names.d.ts

@@ -0,0 +1,7 @@
+import { ClsSentence } from '../types.js';
+export declare const PERSON: Record<string, number>;
+export declare const PLACE: Record<string, number>;
+export declare function inList(list: Record<string, number>, surface: string): boolean;
+/** Flag proper-noun tokens as person and/or place names (membership only). */
+export declare function tagNames(sent: ClsSentence): void;
+//# sourceMappingURL=names.d.ts.map

package/dist/calliope/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/calliope/names.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAa1C,eAAO,MAAM,MAAM,wBAAyB,CAAC;AAC7C,eAAO,MAAM,KAAK,wBAA0B,CAAC;AAG7C,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAK7E;AAED,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAMhD"}

package/dist/calliope/names.js

@@ -0,0 +1,42 @@
+// calliope/names.ts — proper-NOUN (person) vs proper-NAME (place) typing via the
+// `humannames` and `cities-list` membership lists.  These packages are JUST lists
+// ({ "John": 1, … }), so this is a boolean enrichment, not a pipeline: it flags a
+// token as a known person and/or place name to drive Scenario C (proper-name
+// head-stress) and EXT.
+//
+// Lookups are GATED to proper-noun-tagged tokens (NNP/NNPS).  Both lists are huge
+// (197k names, 79k cities) and overlap heavily with common words — "Will", "May",
+// "Rose", "Sun", "York", "Reading" are all in them — so flagging an untyped token
+// would be noise.  Restricting to NNP(S) keeps the signal honest.
+import { createRequire } from 'module';
+const req = createRequire(import.meta.url);
+function loadList(pkg) {
+    try {
+        const m = req(pkg);
+        return (m && typeof m === 'object' ? m : {});
+    }
+    catch {
+        return {};
+    }
+}
+export const PERSON = loadList('humannames');
+export const PLACE = loadList('cities-list');
+const PROPER = /^(NNP|NNPS)$/;
+export function inList(list, surface) {
+    const key = surface.replace(/['’].*$/, '').replace(/[^A-Za-z-]/g, '');
+    if (!key)
+        return false;
+    const cap = key[0].toUpperCase() + key.slice(1);
+    return !!(list[key] || list[cap]);
+}
+/** Flag proper-noun tokens as person and/or place names (membership only). */
+export function tagNames(sent) {
+    for (const w of sent.words) {
+        if (!PROPER.test(w.lexicalClass))
+            continue;
+        if (inList(PERSON, w.word))
+            w.isPersonName = true;
+        if (inList(PLACE, w.word))
+            w.isPlaceName = true;
+    }
+}

package/dist/calliope/postag.d.ts

@@ -0,0 +1,8 @@
+import { ClsSentence } from '../types.js';
+/**
+ * Demote spurious proper-noun tags to their true common reading via en-lexicon.
+ * Mutates `word.lexicalClass` / `word.isContent` in place for the Calliope engine.
+ */
+export declare function correctPosWithLexicon(sent: ClsSentence): void;
+export declare function correctUDPipePos(sent: ClsSentence): void;
+//# sourceMappingURL=postag.d.ts.map

package/dist/calliope/postag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postag.d.ts","sourceRoot":"","sources":["../../src/calliope/postag.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,WAAW,EAAW,MAAM,aAAa,CAAC;AA0CnD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAqC7D;AAgDD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CA+FxD"}

package/dist/calliope/postag.js

@@ -0,0 +1,250 @@
+// calliope/postag.ts — Calliope-only POS correction via en-lexicon.
+//
+// THE BUG THIS FIXES: en-pos tags a capitalised line-initial common word as a
+// proper noun ("Pale rain" → Pale/NNP, "High tide" → High/NNP), purely from the
+// capital.  That mis-tag flips content class, derails the dependency parse, and —
+// once relation-keyed stress is reintroduced — fore-stresses an adjective.
+//
+// en-lexicon (a CORE FinNLP module, the POS dictionary that en-pos/en-parse are
+// built on) carries the true multi-role reading keyed on the LOWERCASE form:
+//   lexicon['pale'] = "JJ|VBP|NN|VB"      (adjective first)
+//   lexicon['Pale'] = "NNP|RB"            (the capitalised key is the trap)
+//   lexicon['high'] = "JJ|NN|RB|RP"
+// so consulting the lowercase entry recovers the real word class.
+//
+// This runs as the FIRST Calliope step — NOT in the shared `tagfix.ts`, because
+// that seam feeds BOTH engines and would un-freeze Clio.  It corrects the ClsWord
+// POS in place (Calliope's own pre-pass); Clio, invoked via `--clio`, never calls
+// it and so keeps its frozen reading.  (It does not re-run en-parse; the κ/ϕ/ι
+// builder downstream is built to be robust to residual head-attachment errors,
+// and `normalizeDeps` re-derives `canonicalRel` from the corrected POS.)
+//
+// Discipline (anti-gaming): the demotion is gated so it can ONLY fire where the
+// capital is uninformative (sentence/line-initial) and the word is demonstrably a
+// common word, never a known or sequenced proper name.
+import { createRequire } from 'module';
+const req = createRequire(import.meta.url);
+function loadLexicon() {
+    try {
+        const m = req('en-lexicon');
+        return (m && (m.lexicon ?? m));
+    }
+    catch {
+        return {};
+    }
+}
+const LEXICON = loadLexicon();
+const PRONOUN_SUBJECT_CONTRACTIONS_LOCAL = new Set([
+    "i'm", "i'll", "i've", "i'd",
+    "you're", "you'll", "you've", "you'd",
+    "he'll", "he'd", "he's", "she'll", "she'd", "she's", "it'll",
+    "we're", "we'll", "we've", "we'd",
+    "they're", "they'll", "they've", "they'd",
+]);
+const PROPER = /^(NNP|NNPS)$/;
+const PUNCT = /^[^A-Za-z0-9]+$/;
+// Content POS, matching parser.ts CONTENT_POS (kept local to avoid a cycle).
+const CONTENT = new Set([
+    'NN', 'NNS', 'NNP', 'NNPS', 'JJ', 'JJR', 'JJS',
+    'VB', 'VBD', 'VBG', 'VBN', 'VBP', 'VBZ', 'RB', 'RBR', 'RBS', 'CD',
+]);
+// Demotion is restricted to the ATTRIBUTIVE/NOMINAL common classes — the exact
+// mis-as-proper class (pale→JJ, slate→NN).  A lowercase-primary that is a finite
+// VERB (rose→VBD) is genuinely ambiguous sentence-initially, so we leave NNP
+// rather than risk a wrong verb tag wrecking the parse.
+const DEMOTE_TARGET = /^(JJ|JJR|JJS|NN|NNS)$/;
+function bareLower(w) {
+    return w.word.toLowerCase().replace(/[^a-z]/g, '');
+}
+function isPunctTag(tag) {
+    return PUNCT.test(tag) || tag === '-LRB-' || tag === '-RRB-';
+}
+/**
+ * Demote spurious proper-noun tags to their true common reading via en-lexicon.
+ * Mutates `word.lexicalClass` / `word.isContent` in place for the Calliope engine.
+ */
+export function correctPosWithLexicon(sent) {
+    const words = sent.words;
+    // Index of the first non-punctuation word — the one whose capital is forced by
+    // sentence/line position and therefore carries no proper-noun evidence.
+    let firstContentIdx = -1;
+    for (let i = 0; i < words.length; i++) {
+        if (!isPunctTag(words[i].lexicalClass)) {
+            firstContentIdx = i;
+            break;
+        }
+    }
+    for (let i = 0; i < words.length; i++) {
+        const w = words[i];
+        if (!PROPER.test(w.lexicalClass))
+            continue;
+        // (a) The lowercase lexicon PRIMARY reading must be an attributive/nominal
+        //     common word.  This — not name-list membership — is the real signal: the
+        //     huge humannames/cities-list flag almost every capitalised common word
+        //     ("Pale", "Slate", "Green" are all in them), so membership cannot gate
+        //     here.  Genuinely proper words are protected instead: their lowercase
+        //     entry is either absent (london, york) or proper-primary (reagan → NNP).
+        const entry = LEXICON[bareLower(w)];
+        if (!entry)
+            continue;
+        const primary = entry.split('|')[0];
+        if (!DEMOTE_TARGET.test(primary))
+            continue;
+        // (b) Caps must be uninformative: the token is the sentence/line-initial word,
+        //     and it is NOT part of a proper-name sequence (a neighbour tagged NNP).
+        if (i !== firstContentIdx)
+            continue;
+        const prev = i > 0 ? words[i - 1] : undefined;
+        const next = i + 1 < words.length ? words[i + 1] : undefined;
+        const adjacentProper = (prev && PROPER.test(prev.lexicalClass)) || (next && PROPER.test(next.lexicalClass));
+        if (adjacentProper)
+            continue;
+        w.lexicalClass = primary;
+        w.isContent = CONTENT.has(primary);
+    }
+}
+// ─── UDPipe XPOS correction (the role en-pos + tagfix.ts played pre-UD) ──────
+//
+// UDPipe is trained on running prose and systematically MIS-TAGS terse,
+// decontextualised verse fragments — it has no sentence context to lean on.
+// Observed on the test corpus: "hat"→WP, "Woolen"→NNS, "gray"→VBP, "constantly"
+// →NN, "slate"/"clay"→JJ, "bicycle"→NN.  The faithful downstream then scans the
+// garbage.  en-pos avoided this because it is lexicon-backed; we restore that by
+// cross-checking UDPipe's XPOS against en-lexicon's multi-role reading (AGENTS.md:
+// "nounsing-pro / lexicon POS to aid FinNLP… cross-check").  HIGH PRECISION — it
+// only overrides a tag the lexicon positively contradicts; an unknown word keeps
+// UDPipe's tag.
+/** Coarse word-class of a Penn tag (N/V/J/R), else the exact tag. */
+function coarseClass(tag) {
+    if (/^(NN|NNS|NNP|NNPS)$/.test(tag))
+        return 'N';
+    if (/^VB/.test(tag))
+        return 'V';
+    if (/^JJ/.test(tag))
+        return 'J';
+    if (/^RB/.test(tag))
+        return 'R';
+    return tag;
+}
+const NOUN_TAG = /^(NN|NNS|NNP|NNPS)$/;
+function retag(w, tag) {
+    w.lexicalClass = tag;
+    w.isContent = CONTENT.has(tag);
+    w.lexicalPlural = tag === 'NNS' || tag === 'NNPS';
+}
+/** Is the immediately-preceding non-punctuation word a subject pronoun? */
+function prevIsSubjectPronoun(words, i) {
+    for (let k = i - 1; k >= 0; k--) {
+        if (isPunctTag(words[k].lexicalClass))
+            continue;
+        const rel = (words[k].dependency?.dependentType ?? '').toLowerCase();
+        return words[k].lexicalClass === 'PRP' && /nsubj/.test(rel);
+    }
+    return false;
+}
+/** Next non-punctuation word, or undefined. */
+function nextContentful(words, i) {
+    for (let k = i + 1; k < words.length; k++) {
+        if (!isPunctTag(words[k].lexicalClass))
+            return words[k];
+    }
+    return undefined;
+}
+export function correctUDPipePos(sent) {
+    const words = sent.words;
+    for (let i = 0; i < words.length; i++) {
+        const w = words[i];
+        if (isPunctTag(w.lexicalClass))
+            continue;
+        // (0) CONTRACTED SUBJECT PRONOUNS: UDPipe/FinNLP often mis-tags
+        //     "I'll", "I've", "I'd", "I'm" as JJ, NNP, or other content classes,
+        //     giving them a spurious content beat. Correct them to PRP (personal
+        //     pronoun) so they floor to 'w' or 'n' like other pronouns.
+        const lowerWord = w.word.toLowerCase().replace(/[’]/g, "'");
+        if (PRONOUN_SUBJECT_CONTRACTIONS_LOCAL.has(lowerWord)) {
+            retag(w, 'PRP');
+            continue;
+        }
+        // (0) POSSESSIVE clitic mis-tagged as a verb: UDPipe tags the genitive "'s"
+        //     in "laugher's licence" as VBZ (confusing it with the copula "he's" = he
+        //     is), giving the clitic a spurious content beat.  The genitive 's carries
+        //     a `case` relation onto its possessor noun; the copula does not — so that
+        //     relation distinguishes them.  Retag POS (0 syllables downstream).
+        // (0) POSSESSIVE clitic mis-tagged as a verb: UDPipe sometimes tags the
+        //     genitive "'s" (in "laugher's licence") as VBZ — confusing it with the
+        //     copula "he's" = he is — giving the clitic a spurious content beat.  The
+        //     genitive 's carries a `case` relation onto its possessor noun; the copula
+        //     does not — so that relation distinguishes them.  Retag POS.
+        if ((w.word === "'s" || w.word === "’s") && /^VB/.test(w.lexicalClass)
+            && (w.dependency?.dependentType ?? '').toLowerCase() === 'case') {
+            retag(w, 'POS');
+            continue;
+        }
+        // The possessive ending itself is never corrected by the lexicon pass below
+        // (en-lexicon has a spurious verb entry for the bare letter "s").
+        if (w.lexicalClass === 'POS')
+            continue;
+        const lemma = bareLower(w);
+        if (lemma.length <= 1)
+            continue; // "s"/"a"/"o" → too ambiguous
+        const entry = LEXICON[lemma];
+        if (!entry)
+            continue; // unknown → trust UDPipe
+        const classes = entry.split('|');
+        const primary = classes[0];
+        const lexCoarse = new Set(classes.map(coarseClass));
+        const udCoarse = coarseClass(w.lexicalClass);
+        const CONTENT_COARSE = new Set(['N', 'V', 'J', 'R']);
+        // (1) PLAUSIBILITY: UDPipe's coarse class is absent from the lexicon entirely
+        //     (hat→WP, Woolen→NNS, constantly→NN, clay→JJ) → fall back to the lexicon's
+        //     primary reading.  Only fires on a positive contradiction AND only when the
+        //     correction is TOWARD a content class (never invents a function tag).
+        if (!lexCoarse.has(udCoarse) && CONTENT_COARSE.has(coarseClass(primary))
+            && coarseClass(primary) !== udCoarse) {
+            retag(w, primary);
+            continue;
+        }
+        // (2) ATTRIBUTIVE NOUN mis-tagged JJ: a lexicon-primary noun UDPipe tagged JJ,
+        //     sitting immediately before a noun, is the modifier of an N+N compound
+        //     ("SLATE roof", "CLAY jar"), not an adjective.  Retag NN so the compound
+        //     fore-stresses (deps.ts NOMD).
+        if (/^JJ/.test(w.lexicalClass) && coarseClass(primary) === 'N') {
+            const nxt = nextContentful(words, i);
+            if (nxt && NOUN_TAG.test(nxt.lexicalClass) && nxt.absoluteIndex === w.absoluteIndex + 1) {
+                retag(w, 'NN');
+                continue;
+            }
+        }
+        // (3) NOUN that should be a finite VERB: a lexicon-verb-capable common noun
+        //     UDPipe tagged NN, immediately preceded by a SUBJECT PRONOUN ("they
+        //     BICYCLE through", "we PAPER walls"), is the clause's predicate → VBP.
+        if (NOUN_TAG.test(w.lexicalClass) && lexCoarse.has('V') && prevIsSubjectPronoun(words, i)) {
+            retag(w, 'VBP');
+            continue;
+        }
+        // (4) TEMPORAL ADVERB mis-tagged IN: "before"/"after"/"since"/"once" tagged IN
+        //     but with no nominal complement before the next clause boundary is an
+        //     adverb (RB), not a preposition.  Penn treebank: IN takes an NP
+        //     complement ("before the storm"); RB does not ("never before", "long
+        //     after").  A following verb/pronoun signals a subordinate clause ("before
+        //     I go") → leave as IN (subordinating conjunction sense).
+        const TEMPORAL_ADVS = new Set(['before', 'after', 'since', 'once']);
+        if (w.lexicalClass === 'IN' && TEMPORAL_ADVS.has(lemma)) {
+            let hasNoun = false, hasClauseStart = false;
+            for (let k = i + 1; k < words.length; k++) {
+                if (isPunctTag(words[k].lexicalClass))
+                    break;
+                if (NOUN_TAG.test(words[k].lexicalClass)) {
+                    hasNoun = true;
+                    break;
+                }
+                if (/^(VB|VBP|VBD|VBG|VBN|VBZ|PRP)$/.test(words[k].lexicalClass))
+                    hasClauseStart = true;
+            }
+            if (!hasNoun && !hasClauseStart) {
+                retag(w, 'RB');
+                continue;
+            }
+        }
+    }
+}

package/dist/calliope/prosodic.d.ts

@@ -0,0 +1,3 @@
+import { ClsSentence, IntonationalUnit } from '../types.js';
+export declare function buildProsodicHierarchy(sent: ClsSentence): IntonationalUnit[];
+//# sourceMappingURL=prosodic.d.ts.map

package/dist/calliope/prosodic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prosodic.d.ts","sourceRoot":"","sources":["../../src/calliope/prosodic.ts"],"names":[],"mappings":"AA0BA,OAAO,EACL,WAAW,EAA4C,gBAAgB,EACxE,MAAM,aAAa,CAAC;AA0LrB,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,gBAAgB,EAAE,CA+C5E"}