calliope-ts 0.0.2 → 0.0.3

package/dist/calliope/stressrules.d.ts

@@ -0,0 +1,28 @@
+import { ClsWord } from '../types.js';
+type Side = 'left' | 'right';
+/** Which element of an adjacent (modifier w1, head-noun w2) structure carries
+ *  primary stress, per Scenarios A/B/C. */
+export declare function scenarioModifierSide(w1: ClsWord, w2: ClsWord): Side;
+/**
+ * Apply the nominal-modifier stress scenarios over a sentence's words.  Mirrors
+ * the legacy `applyCompoundStress` iteration (adjacent content words, noun head)
+ * but decides via the canonical relations / name flags rather than POS alone, so
+ * the proper-modifier and lexicalised cases come out right.  Replaces
+ * `applyCompoundStress` in the Calliope engine.
+ */
+export declare function applyScenarioStress(words: ClsWord[]): void;
+/**
+ * Make the LEFT-stress scenario decision DURABLE in the relative-stress contour.
+ *
+ * The lexical compound pass (`applyScenarioStress`) sets the modifier primary, but
+ * the nuclear pass + relativiser re-promote the rightmost word, so a *non-curated*
+ * fore-stressed compound (SLATE roof, REAGAN era, WALL Street, HOT dog) would still
+ * surface as end-stressed.  The legacy `resolveCompoundForestress` repairs this only
+ * for the curated `isLeftStressedPair` set; this Calliope post-pass — run AFTER
+ * `assignRelativeStresses` — re-asserts the same demote-only fore-stress for EVERY
+ * scenario-left pair: the modifier rises to the pair's max prominence, the head is
+ * demoted one rung below (never raised), which also keeps the no-equal-clash rule.
+ */
+export declare function enforceScenarioStress(words: ClsWord[]): void;
+export {};
+//# sourceMappingURL=stressrules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stressrules.d.ts","sourceRoot":"","sources":["../../src/calliope/stressrules.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AA8BtC,KAAK,IAAI,GAAG,MAAM,GAAG,OAAO,CAAC;AAE7B;2CAC2C;AAC3C,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CAqBnE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAgB1D;AAeD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAkB5D"}

package/dist/calliope/stressrules.js

@@ -0,0 +1,147 @@
+// calliope/stressrules.ts — Scenario A–O relation-keyed stress (the maintainer's
+// authoritative spec, each rule cross-checked against external linguistics).
+// Operates over POS + word.canonicalRel + the person/place name flags.
+//
+// THIS FILE so far implements the nominal-modifier scenarios — the most directly
+// testable, and where the canonical substrate first pays off:
+//   A  N+N noun-adjunct (NOMD)        → LEFT  (SLATE roof, BIRD nest, MSNBC news,
+//                                              REAGAN era) — the ~⅔ baseline;
+//                                              food/temporal heads stay RIGHT.
+//   B  Adj+N (AMOD)                   → RIGHT (a green ROOF); a LEXICALISED Adj+N
+//                                              compound fore-stresses (HOT dog).
+//   C  Proper NAME (NNP+NNP)          → RIGHT/head (New YORK, Bay BRIDGE) EXCEPT a
+//                                              de-accenting classifier head ("Street"
+//                                              → WALL Street).
+//   M  is subsumed here (proper-name extension → rightmost head).
+// Verbal/clausal/override scenarios (D–L, N, O) are added next.
+//
+// External-theory notes (binding): N+N left is only a ~⅔ baseline (Kunter & Plag),
+// so the curated right-stress heads are first-class; lexicalised Adj+N fore-stress
+// is a documented lexicalisation marker, not merely contrast; "Street" de-accents.
+import { setPrimaryStress, isRightStressedHead } from '../stress.js';
+const NOUN = /^(NN|NNS|NNP|NNPS)$/;
+const PROPER = /^(NNP|NNPS)$/;
+const ADJ = /^JJ/;
+function bare(w) {
+    return w.word.toLowerCase().replace(/[^a-z]/g, '');
+}
+function isNoun(w) { return NOUN.test(w.lexicalClass); }
+function isProper(w) { return PROPER.test(w.lexicalClass); }
+function isAdjMod(w) { return ADJ.test(w.lexicalClass) || w.canonicalRel === 'AMOD'; }
+// Scenario C exception: proper-name heads that de-accent the name LEFT.  "Street"
+// is the well-documented case (WALL Street, STATE Street) vs right-stressing
+// Avenue/Road/Square/Bridge (Fifth AVENUE) — see the plan's external cross-check.
+const PROPER_NAME_LEFT_HEADS = new Set(['street']);
+// Scenario B exception: lexicalised Adj+N compounds that fore-stress despite the
+// AMOD right-stress baseline (the stress shift is the lexicalisation marker:
+// "HOT dog" the food vs "hot DOG" a dog that is hot).  Small, curated, defensible.
+const LEXICALIZED_FORESTRESS = new Set([
+    'hot dog', 'hot dogs', 'high school', 'high schools', 'white house',
+    'black board', 'blackboard', 'green house', 'blue blood', 'hot rod',
+]);
+function isLexicalizedForestress(a, b) {
+    return LEXICALIZED_FORESTRESS.has(`${bare(a)} ${bare(b)}`);
+}
+/** Which element of an adjacent (modifier w1, head-noun w2) structure carries
+ *  primary stress, per Scenarios A/B/C. */
+export function scenarioModifierSide(w1, w2) {
+    // Participial/gerundial HYPHENATED compound modifier (book-carrying, law-abiding,
+    // well-known) is adjectival/phrasal, NOT a noun adjunct — so it end-stresses, the
+    // head keeping prominence: "a book-carrying MAN", "a law-abiding CITIZEN".  (The
+    // table's VBN/VBG-participle → end-stress; only a single-word -ing GERUND like
+    // WAITING room fore-stresses, and those are not hyphenated.)
+    if (/-/.test(w1.word) && /(ing|ed)$/i.test(bare(w1)))
+        return 'right';
+    // C — proper NAME (both proper nouns): head/right, classifier "Street" → left.
+    if (isProper(w1) && isProper(w2)) {
+        return PROPER_NAME_LEFT_HEADS.has(bare(w2)) ? 'left' : 'right';
+    }
+    // B — Adj+N: right (compositional); lexicalised Adj+N compound → left.
+    if (isAdjMod(w1)) {
+        return isLexicalizedForestress(w1, w2) ? 'left' : 'right';
+    }
+    // A — N+N noun-adjunct (incl. proper-modifier + common head, REAGAN era / MSNBC
+    // news): left by default; food/temporal right-stress heads (apple PIE) → right.
+    if (isNoun(w1) && isNoun(w2)) {
+        return isRightStressedHead(w2.word) ? 'right' : 'left';
+    }
+    return 'right';
+}
+/**
+ * Apply the nominal-modifier stress scenarios over a sentence's words.  Mirrors
+ * the legacy `applyCompoundStress` iteration (adjacent content words, noun head)
+ * but decides via the canonical relations / name flags rather than POS alone, so
+ * the proper-modifier and lexicalised cases come out right.  Replaces
+ * `applyCompoundStress` in the Calliope engine.
+ */
+export function applyScenarioStress(words) {
+    const content = words.filter(w => w.isContent);
+    for (let i = 0; i + 1 < content.length; i++) {
+        const w1 = content[i];
+        const w2 = content[i + 1];
+        if (w1.absoluteIndex + 1 !== w2.absoluteIndex)
+            continue; // surface-adjacent only
+        if (!isNoun(w2))
+            continue; // head of the structure is a noun
+        if (!isNoun(w1) && !isAdjMod(w1))
+            continue; // modifier is a noun or adjective
+        if (scenarioModifierSide(w1, w2) === 'left') {
+            setPrimaryStress(w1, 2);
+            setPrimaryStress(w2, 1);
+        }
+        else {
+            setPrimaryStress(w1, 1);
+            setPrimaryStress(w2, 2);
+        }
+    }
+}
+const RANK = { x: 0, w: 1, n: 2, m: 3, s: 4 };
+const LEVELS = ['x', 'w', 'n', 'm', 's'];
+function peakSyll(w) {
+    let best = null;
+    let bestR = -1;
+    for (const s of w.syllables) {
+        const r = RANK[s.relativeStress ?? 'w'];
+        if (r >= bestR) {
+            bestR = r;
+            best = s;
+        }
+    }
+    return best;
+}
+/**
+ * Make the LEFT-stress scenario decision DURABLE in the relative-stress contour.
+ *
+ * The lexical compound pass (`applyScenarioStress`) sets the modifier primary, but
+ * the nuclear pass + relativiser re-promote the rightmost word, so a *non-curated*
+ * fore-stressed compound (SLATE roof, REAGAN era, WALL Street, HOT dog) would still
+ * surface as end-stressed.  The legacy `resolveCompoundForestress` repairs this only
+ * for the curated `isLeftStressedPair` set; this Calliope post-pass — run AFTER
+ * `assignRelativeStresses` — re-asserts the same demote-only fore-stress for EVERY
+ * scenario-left pair: the modifier rises to the pair's max prominence, the head is
+ * demoted one rung below (never raised), which also keeps the no-equal-clash rule.
+ */
+export function enforceScenarioStress(words) {
+    const content = words.filter(w => w.isContent);
+    for (let i = 0; i + 1 < content.length; i++) {
+        const w1 = content[i];
+        const w2 = content[i + 1];
+        if (w1.absoluteIndex + 1 !== w2.absoluteIndex)
+            continue;
+        if (!isNoun(w2))
+            continue;
+        if (!isNoun(w1) && !isAdjMod(w1))
+            continue;
+        if (scenarioModifierSide(w1, w2) !== 'left')
+            continue;
+        const s1 = peakSyll(w1);
+        const s2 = peakSyll(w2);
+        if (!s1 || !s2)
+            continue;
+        const r1 = RANK[s1.relativeStress ?? 'w'];
+        const r2 = RANK[s2.relativeStress ?? 'w'];
+        const hi = Math.max(r1, r2);
+        s1.relativeStress = LEVELS[hi]; // modifier ≥ both
+        s2.relativeStress = LEVELS[Math.min(r2, Math.max(0, hi - 1))]; // demote head only
+    }
+}

package/dist/calliope/syntax.d.ts

@@ -0,0 +1,38 @@
+import { ClsWord } from '../types.js';
+export declare function isPunct(w: ClsWord): boolean;
+export declare function isNoun(w: ClsWord): boolean;
+export declare function isVerb(w: ClsWord): boolean;
+/** A PRONOUN — inherently given (Wagner §7.2.3): a personal/possessive pronoun by
+ *  POS, or any word the parse marks PronType=Prs.  Demonstratives (this/that),
+ *  wh-words (Rel/Int), negative (nobody/nothing) and indefinite-as-focus pronouns
+ *  are NOT treated as inherently given here. */
+export declare function isPronoun(w: ClsWord): boolean;
+export declare function isInherentlyGiven(w: ClsWord): boolean;
+/** A LIGHT nominal head — a personal pronoun or an inherently-given indefinite —
+ *  whose post-nominal PP modifier cannot be hosted inside the head's own group and
+ *  so needs its OWN ϕ (the phrasing break the ear hears after "Something …"). */
+export declare function isLightNominalHead(w: ClsWord): boolean;
+export declare function verbHasArgChild(verb: ClsWord, children: Map<number, ClsWord[]>): boolean;
+export declare function isUnaccusativeOrPassive(subj: ClsWord, verb: ClsWord): boolean;
+/** The preposition lemma governing an oblique noun: its `case`/`CASE` dependent. */
+export declare function prepLemmaOf(obl: ClsWord, words: ClsWord[]): string | null;
+/** An oblique ARGUMENT (goal/source/recipient) — can integrate with the verb so
+ *  the verb is subordinated and the oblique NP bears the single accent. */
+export declare function isObliqueArgument(obl: ClsWord, words: ClsWord[]): boolean;
+/** A LOW LOCATIVE / temporal adjunct (Larson 2005): a VP-final place/time oblique
+ *  that gets its OWN accent regardless of position — NOT a functor of the VP. */
+export declare function isLowLocative(obl: ClsWord, head: ClsWord, words?: ClsWord[]): boolean;
+/** A FRAME-SETTING locative (Wagner §6.5.1): a sentence-initial temporal/spatial
+ *  oblique that frames the proposition — IS a functor, gets its own domain. */
+export declare function isFrameSetting(obl: ClsWord, words: ClsWord[]): boolean;
+/** A TRANSITIVE function word governs a nominal complement (Wagner §6.5.5: only
+ *  complement-taking functors have weak/stressless allomorphs).  An INTRANSITIVE
+ *  or STRANDED preposition/particle keeps stress — returns false. */
+export declare function isTransitiveFunctionWord(w: ClsWord, words: ClsWord[]): boolean;
+export type FunctorSide = 'dep' | 'head' | 'match';
+/** Which sister of a (dep, head) UD edge is the FUNCTOR — or 'match' for an
+ *  associative pairing (Wagner §2.2.2).  This is the relation-keyed mapping in
+ *  the plan's Gap-2 table: for some relations the GOVERNOR is the functor
+ *  (DOBJ/OBL/CCOMP), for others the DEPENDENT is (AMOD/CASE/AUX/DET/ADVMOD). */
+export declare function functorOf(dep: ClsWord): FunctorSide;
+//# sourceMappingURL=syntax.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"syntax.d.ts","sourceRoot":"","sources":["../../src/calliope/syntax.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAQtC,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAE3C;AACD,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAsC;AACjF,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAsC;AAGjF;;;gDAGgD;AAChD,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAG7C;AAaD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAIrD;AAED;;iFAEiF;AACjF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAEtD;AAMD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAC9C,OAAO,CAQT;AASD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAI7E;AAmBD,oFAAoF;AACpF,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,GAAG,IAAI,CAQzE;AAED;2EAC2E;AAC3E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAKzE;AAED;iFACiF;AACjF,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAYrF;AAED;+EAC+E;AAC/E,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAStE;AAkBD;;qEAEqE;AACrE,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAqB9E;AAGD,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;AAEnD;;;gFAGgF;AAChF,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAcnD"}

package/dist/calliope/syntax.js

@@ -0,0 +1,234 @@
+// calliope/syntax.ts — Wagner/Krifka structural predicates shared by the cyclic
+// stress (bracketing.ts) and the relativiser (relstress.ts).
+//
+// These encode the functor/argument geometry of Wagner (2005) Ch. 6 and the
+// argument/adjunct/locative typology of Krifka (2001) §4.5 / Wagner §6.5.1, read
+// off the canonical UD relations + Penn POS + morphological FEATS.  No semantic
+// role labeller is available, so the obl subtyping and transitivity tests are
+// heuristic (preposition lemma + surface position + complement presence); every
+// classification is approximate and, where uncertain, defaults to the reading
+// that preserves prior behaviour (integration / transitive).
+import { feat } from './feats.js';
+const NOUN = /^(NN|NNS|NNP|NNPS)$/;
+const PROPER = /^(NNP|NNPS)$/;
+const VERB = /^VB/;
+const PRON = /^(PRP|PRP\$)$/;
+export function isPunct(w) {
+    return /^[^A-Za-z0-9]+$/.test(w.lexicalClass) || w.syllables.length === 0;
+}
+export function isNoun(w) { return NOUN.test(w.lexicalClass); }
+export function isVerb(w) { return VERB.test(w.lexicalClass); }
+function bare(w) { return w.word.toLowerCase().replace(/['’]/g, ''); }
+/** A PRONOUN — inherently given (Wagner §7.2.3): a personal/possessive pronoun by
+ *  POS, or any word the parse marks PronType=Prs.  Demonstratives (this/that),
+ *  wh-words (Rel/Int), negative (nobody/nothing) and indefinite-as-focus pronouns
+ *  are NOT treated as inherently given here. */
+export function isPronoun(w) {
+    if (PRON.test(w.lexicalClass))
+        return true;
+    return feat(w, 'PronType') === 'Prs';
+}
+/** A POSITIVE indefinite pronoun — inherently given (Wagner §7.2.3): its
+ *  existential presupposition is trivially satisfied in any context, so it is
+ *  subordinated by default and yields the utterance nuclear to a heavier sister
+ *  ("Something for the modern STAGE").  Only the SOME-/ANY- existential series:
+ *  NEGATIVE (nothing/nobody) and temporal/emphatic words are deliberately excluded
+ *  — those are FOCAL, not given (Eliot's "Nothing", McCartney's "Yesterday"), and
+ *  per the maintainer's directive must keep their prominence.  UDPipe routinely
+ *  mis-tags these as NN, so detection is by lemma (+ PronType guard). */
+const INDEFINITE_GIVEN = new Set([
+    'something', 'someone', 'somebody', 'somewhat', 'somewhere', 'someplace',
+]);
+export function isInherentlyGiven(w) {
+    if (!INDEFINITE_GIVEN.has(bare(w)))
+        return false;
+    const pt = feat(w, 'PronType');
+    return pt !== 'Neg'; // never a negative pronoun
+}
+/** A LIGHT nominal head — a personal pronoun or an inherently-given indefinite —
+ *  whose post-nominal PP modifier cannot be hosted inside the head's own group and
+ *  so needs its OWN ϕ (the phrasing break the ear hears after "Something …"). */
+export function isLightNominalHead(w) {
+    return isPronoun(w) || isInherentlyGiven(w);
+}
+/** A child relation that makes a verb BRANCH (carry an internal argument) — the
+ *  specifier-restriction trigger (Wagner §6.3.2): a transitive/clausal VP whose
+ *  branchingness blocks subordination of its subject. */
+const ARG_CHILD = new Set(['DOBJ', 'IOBJ', 'OBJ', 'OBL', 'CCOMP', 'XCOMP']);
+export function verbHasArgChild(verb, children) {
+    return (children.get(verb.absoluteIndex) ?? []).some(c => {
+        const rel = c.canonicalRel ?? '';
+        if (!ARG_CHILD.has(rel))
+            return false;
+        // A low locative oblique is an adjunct, not a branching argument.
+        if (rel === 'OBL' && isLowLocative(c, verb))
+            return false;
+        return true;
+    });
+}
+/** An unaccusative / passive subject is an UNDERLYING OBJECT, so it can bear the
+ *  nuclear accent (Krifka §4.5.2): NSUBJPASS, or Voice=Pass on the verb, or a
+ *  small set of unaccusative intransitives. */
+const UNACCUSATIVE = new Set([
+    'arrive', 'come', 'go', 'fall', 'rise', 'appear', 'die', 'happen', 'remain',
+    'emerge', 'occur', 'vanish', 'grow', 'sink', 'flow', 'melt', 'wake',
+]);
+export function isUnaccusativeOrPassive(subj, verb) {
+    if ((subj.canonicalRel ?? '') === 'NSUBJPASS')
+        return true;
+    if (feat(verb, 'Voice') === 'Pass')
+        return true;
+    return UNACCUSATIVE.has(bare(verb).replace(/(ed|s|ing)$/, ''));
+}
+// ─── oblique typology (Wagner §6.5.1 / Larson 2005 / Krifka §4.5.1) ──────────
+const GOAL_PREPS = new Set(['to', 'into', 'onto', 'toward', 'towards', 'unto']);
+const SOURCE_PREPS = new Set(['from', 'out']);
+const ADJUNCT_PREPS = new Set([
+    'in', 'on', 'at', 'by', 'for', 'during', 'throughout', 'within', 'amid',
+    'amidst', 'among', 'amongst', 'beneath', 'beside', 'over', 'under', 'above',
+]);
+const FRAME_PREPS = new Set([
+    'in', 'on', 'at', 'by', 'during', 'after', 'before', 'since', 'until', 'upon',
+]);
+const TIME_NOUNS = new Set([
+    'hour', 'hours', 'day', 'days', 'week', 'weeks', 'month', 'months', 'year',
+    'years', 'minute', 'minutes', 'moment', 'moments', 'century', 'centuries',
+    'morning', 'evening', 'night', 'nights', 'spring', 'summer', 'autumn', 'winter',
+    'dawn', 'dusk', 'noon', 'midnight', 'season', 'seasons',
+]);
+/** The preposition lemma governing an oblique noun: its `case`/`CASE` dependent. */
+export function prepLemmaOf(obl, words) {
+    for (const w of words) {
+        if (w.dependency?.governor === obl && (w.canonicalRel === 'CASE' ||
+            w.lexicalClass === 'IN' || w.lexicalClass === 'TO')) {
+            return bare(w);
+        }
+    }
+    return null;
+}
+/** An oblique ARGUMENT (goal/source/recipient) — can integrate with the verb so
+ *  the verb is subordinated and the oblique NP bears the single accent. */
+export function isObliqueArgument(obl, words) {
+    const p = prepLemmaOf(obl, words);
+    if (!p)
+        return false;
+    if (GOAL_PREPS.has(p) || SOURCE_PREPS.has(p))
+        return true;
+    return false;
+}
+/** A LOW LOCATIVE / temporal adjunct (Larson 2005): a VP-final place/time oblique
+ *  that gets its OWN accent regardless of position — NOT a functor of the VP. */
+export function isLowLocative(obl, head, words) {
+    // Detect by preposition + noun semantics; if we have no word list, fall back to
+    // the noun being a time word.
+    if (words) {
+        const p = prepLemmaOf(obl, words);
+        if (p && ADJUNCT_PREPS.has(p)) {
+            // VP-final: the oblique follows its verbal head.
+            if (obl.absoluteIndex > head.absoluteIndex)
+                return true;
+        }
+    }
+    if (TIME_NOUNS.has(bare(obl)))
+        return true;
+    return false;
+}
+/** A FRAME-SETTING locative (Wagner §6.5.1): a sentence-initial temporal/spatial
+ *  oblique that frames the proposition — IS a functor, gets its own domain. */
+export function isFrameSetting(obl, words) {
+    const p = prepLemmaOf(obl, words);
+    if (!p || !FRAME_PREPS.has(p))
+        return false;
+    // sentence-initial: the preposition is (near) the first content token.
+    let firstContent = -1;
+    for (let i = 0; i < words.length; i++) {
+        if (!isPunct(words[i])) {
+            firstContent = words[i].absoluteIndex;
+            break;
+        }
+    }
+    return obl.absoluteIndex <= firstContent + 2;
+}
+// ─── function-word transitivity (Wagner §6.5.5) ──────────────────────────────
+const PARTICLE_LEMMAS = new Set([
+    'in', 'out', 'up', 'down', 'off', 'away', 'back', 'forth', 'over', 'around',
+    'along', 'through', 'apart', 'aside', 'onward', 'about',
+]);
+/** Last non-punct token of the clause at/after `w`? (the canonical strand site). */
+function isClauseFinal(w, words) {
+    const idx = words.findIndex(x => x === w);
+    if (idx < 0)
+        return false;
+    for (let k = idx + 1; k < words.length; k++) {
+        if (!isPunct(words[k]))
+            return false;
+    }
+    return true;
+}
+/** A TRANSITIVE function word governs a nominal complement (Wagner §6.5.5: only
+ *  complement-taking functors have weak/stressless allomorphs).  An INTRANSITIVE
+ *  or STRANDED preposition/particle keeps stress — returns false. */
+export function isTransitiveFunctionWord(w, words) {
+    const pos = w.lexicalClass;
+    const rel = w.canonicalRel ?? '';
+    if (pos === 'RP' || rel === 'VPRT')
+        return false; // particles are intransitive
+    if (pos === 'IN' || pos === 'TO' || rel === 'CASE') {
+        // Does it govern a noun (have a nominal complement)?  In UD the preposition is
+        // a CASE dependent of its noun, so check both directions.
+        const gov = w.dependency?.governor;
+        if (gov && !isPunct(gov) && NOUN.test(gov.lexicalClass) &&
+            gov.absoluteIndex > w.absoluteIndex) {
+            return true; // prep → noun complement to its right
+        }
+        const hasNominalDep = words.some(d => d.dependency?.governor === w &&
+            (NOUN.test(d.lexicalClass) || d.canonicalRel === 'OBL' || d.canonicalRel === 'DOBJ'));
+        if (hasNominalDep)
+            return true;
+        // Clause-final adverbial particle/preposition with no complement → stranded.
+        if (PARTICLE_LEMMAS.has(bare(w)) && isClauseFinal(w, words))
+            return false;
+        if (isClauseFinal(w, words))
+            return false; // stranded
+        return true; // default: transitive
+    }
+    return true; // det/aux/cc/etc.: transitive
+}
+/** Which sister of a (dep, head) UD edge is the FUNCTOR — or 'match' for an
+ *  associative pairing (Wagner §2.2.2).  This is the relation-keyed mapping in
+ *  the plan's Gap-2 table: for some relations the GOVERNOR is the functor
+ *  (DOBJ/OBL/CCOMP), for others the DEPENDENT is (AMOD/CASE/AUX/DET/ADVMOD). */
+export function functorOf(dep) {
+    switch (dep.canonicalRel ?? '') {
+        case 'DOBJ':
+        case 'IOBJ':
+        case 'OBJ':
+        case 'OBL':
+        case 'CCOMP':
+        case 'XCOMP':
+        case 'NSUBJ':
+        case 'NSUBJPASS':
+            return 'head'; // governor (verb/VP) is functor
+        case 'AMOD':
+        case 'ADVMOD':
+        case 'ACL':
+        case 'ADVCL':
+        case 'CASE':
+        case 'AUX':
+        case 'AUXPASS':
+        case 'DET':
+        case 'NUMMOD':
+        case 'CC':
+        case 'COMPMARK':
+        case 'ADVMARK':
+        case 'EXPL':
+        case 'VPRT':
+            return 'dep'; // dependent is functor
+        case 'CONJ':
+        case 'DISCOURSE':
+        case 'INTJ':
+            return 'match'; // associative / own accent
+        default:
+            return 'head';
+    }
+}

package/dist/calliope/udpos.d.ts

@@ -0,0 +1,13 @@
+import type { UDWord } from 'udpipe-node';
+/** True if `xpos` is a Penn tag the pipeline consumes directly (EWT/GUM). */
+export declare function isPennTag(xpos: string | undefined): boolean;
+/** The Penn tag for a token: the raw XPOS when it is already Penn (EWT/GUM),
+ *  otherwise derived from UPOS+FEATS (LinES/ParTUT, or a missing XPOS). */
+export declare function pennTagOf(w: UDWord): string;
+/**
+ * Convert one UDPipe token to a Penn Treebank tag from UPOS + FEATS (+ lemma /
+ * deprel for the cases morphology alone can't settle).  Falls back to the raw XPOS
+ * only when UPOS is absent.
+ */
+export declare function udToPenn(w: UDWord): string;
+//# sourceMappingURL=udpos.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"udpos.d.ts","sourceRoot":"","sources":["../../src/calliope/udpos.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAa1C,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAE3D;AAED;2EAC2E;AAC3E,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG3C;AAaD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAiG1C"}

package/dist/calliope/udpos.js

@@ -0,0 +1,156 @@
+// calliope/udpos.ts — UNIVERSAL POS → Penn Treebank conversion.
+//
+// WHY: the phonological pipeline keys on Penn XPOS (NN/VBZ/JJ/DT/IN…), but
+// UDPipe's XPOS column is treebank-specific and INCONSISTENT across models —
+// EWT/GUM emit Penn tags, but LinES emits its own morphological tagset
+// (DEF/SG-NOM/PL-NOM/ING/REL…) and ParTUT an Italian-derived one (RD/S/V/E/A/PD…),
+// neither of which the downstream understands.  UPOS and FEATS, by contrast, are
+// the Universal Dependencies standard and are consistent (and more accurate:
+// ~94% UPOS vs ~93% XPOS) across ALL four models.  So we DERIVE the Penn tag the
+// pipeline needs from UPOS + morphological FEATS, making the parser model-agnostic
+// AND giving us morphology en-parse never had (Number, Tense, Degree, PronType,
+// VerbForm) to make finer, more reliable distinctions.
+// The Penn Treebank tag set the downstream understands.  EWT/GUM emit these
+// directly (and reliably — a lexicalised PDT like "all" stays PDT even when the
+// parse mislabels its relation); LinES/ParTUT do NOT, so for those we derive the
+// Penn tag from UPOS+FEATS instead.
+const PENN_TAGS = new Set([
+    'NN', 'NNS', 'NNP', 'NNPS', 'JJ', 'JJR', 'JJS',
+    'VB', 'VBD', 'VBG', 'VBN', 'VBP', 'VBZ', 'MD',
+    'RB', 'RBR', 'RBS', 'PRP', 'PRP$', 'WP', 'WP$', 'WDT', 'WRB',
+    'DT', 'PDT', 'CD', 'IN', 'TO', 'CC', 'RP', 'EX', 'POS', 'UH', 'FW', 'SYM', 'LS',
+]);
+/** True if `xpos` is a Penn tag the pipeline consumes directly (EWT/GUM). */
+export function isPennTag(xpos) {
+    return !!xpos && PENN_TAGS.has(xpos);
+}
+/** The Penn tag for a token: the raw XPOS when it is already Penn (EWT/GUM),
+ *  otherwise derived from UPOS+FEATS (LinES/ParTUT, or a missing XPOS). */
+export function pennTagOf(w) {
+    if (isPennTag(w.xpos))
+        return w.xpos;
+    return udToPenn(w);
+}
+const MODAL_LEMMAS = new Set([
+    'can', 'could', 'will', 'would', 'shall', 'should', 'may', 'might', 'must',
+    'ought', "'ll", "'d", 'wilt', 'shalt', 'canst', 'wouldst', 'shouldst', 'couldst',
+]);
+// Pre-determiners ("ALL the books", "BOTH his hands", "such a day", "HALF the night").
+const PREDET_LEMMAS = new Set(['all', 'both', 'half', 'such', 'quite', 'many']);
+function feat(w, k) {
+    return w.featsMap ? w.featsMap[k] : undefined;
+}
+/**
+ * Convert one UDPipe token to a Penn Treebank tag from UPOS + FEATS (+ lemma /
+ * deprel for the cases morphology alone can't settle).  Falls back to the raw XPOS
+ * only when UPOS is absent.
+ */
+export function udToPenn(w) {
+    const upos = w.upos || '';
+    const lemma = (w.lemma || w.form || '').toLowerCase();
+    const deprel = (w.deprel || '').toLowerCase();
+    const num = feat(w, 'Number');
+    const degree = feat(w, 'Degree');
+    const pron = feat(w, 'PronType');
+    const poss = feat(w, 'Poss');
+    const vform = feat(w, 'VerbForm');
+    const tense = feat(w, 'Tense');
+    const person = feat(w, 'Person');
+    // Pre-determiner ("ALL the time", "BOTH his hands"): a stress-bearing quantifier
+    // (Penn PDT, content), regardless of whether the model calls it DET or PRON.  UD
+    // marks it with the det:predet relation; the non-Penn models lose that, so back
+    // it up with the lemma list.
+    if (deprel === 'det:predet')
+        return 'PDT';
+    switch (upos) {
+        case 'NOUN':
+            return num === 'Plur' ? 'NNS' : 'NN';
+        case 'PROPN':
+            return num === 'Plur' ? 'NNPS' : 'NNP';
+        case 'ADJ':
+            if (degree === 'Cmp')
+                return 'JJR';
+            if (degree === 'Sup')
+                return 'JJS';
+            // Ordinal numerals tag JJ in UD but CD-like in Penn; keep JJ (attributive).
+            return 'JJ';
+        case 'ADV':
+            if (pron === 'Int' || pron === 'Rel')
+                return 'WRB'; // when/where/why/how
+            if (degree === 'Cmp')
+                return 'RBR';
+            if (degree === 'Sup')
+                return 'RBS';
+            return 'RB';
+        case 'VERB':
+        case 'AUX': {
+            if (upos === 'AUX' && (feat(w, 'VerbType') === 'Mod' || MODAL_LEMMAS.has(lemma)))
+                return 'MD';
+            if (vform === 'Ger')
+                return 'VBG';
+            if (vform === 'Part')
+                return tense === 'Past' ? 'VBN' : 'VBG';
+            if (vform === 'Inf')
+                return 'VB';
+            if (vform === 'Fin') {
+                if (tense === 'Past')
+                    return 'VBD';
+                if (person === '3' && num === 'Sing')
+                    return 'VBZ';
+                return 'VBP';
+            }
+            // No VerbForm feature: best-effort by tense/person.
+            if (tense === 'Past')
+                return 'VBD';
+            if (person === '3' && num === 'Sing')
+                return 'VBZ';
+            return upos === 'AUX' ? 'VBP' : 'VB';
+        }
+        case 'PRON':
+            if (poss === 'Yes')
+                return (pron === 'Rel' || pron === 'Int') ? 'WP$' : 'PRP$';
+            if (pron === 'Rel' || pron === 'Int')
+                return 'WP';
+            if (pron === 'Dem')
+                return 'DT'; // "this/that" pronominal
+            return 'PRP';
+        case 'DET':
+            if (pron === 'Rel' || pron === 'Int')
+                return 'WDT'; // which/that(rel)/what
+            if (poss === 'Yes')
+                return 'PRP$'; // my/your/their (UD DET)
+            if (PREDET_LEMMAS.has(lemma) && deprel === 'det:predet')
+                return 'PDT';
+            return 'DT'; // articles + demonstratives
+        case 'ADP':
+            // A particle of a phrasal verb ("came DOWN", "give UP") is stress-bearing RP;
+            // an ordinary preposition is the reducible IN.  UD marks the particle by the
+            // compound:prt relation.
+            return deprel === 'compound:prt' ? 'RP' : 'IN';
+        case 'SCONJ':
+            return 'IN';
+        case 'CCONJ':
+            return 'CC';
+        case 'PART':
+            if (lemma === 'to')
+                return 'TO';
+            if (lemma === "'s" || lemma === '’s' || deprel === 'case')
+                return 'POS';
+            if (lemma === 'not' || lemma === "n't" || lemma === "n’t")
+                return 'RB';
+            return 'RB';
+        case 'NUM':
+            return 'CD';
+        case 'INTJ':
+            return 'UH';
+        case 'SYM':
+            return 'SYM';
+        case 'X':
+            return 'FW';
+        case 'PUNCT':
+            // EWT/GUM give the punctuation char as XPOS already; otherwise use the form.
+            return (w.xpos && /[^A-Za-z0-9]/.test(w.xpos)) ? w.xpos : (w.form || w.xpos || ':');
+        default:
+            return w.xpos || w.upos || 'NN';
+    }
+}