calliope-ts 0.0.2 → 0.0.4

package/src/calliope/stressrules.ts

@@ -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 { ClsWord } from '../types.js';
+import { setPrimaryStress, isRightStressedHead } from '../stress.js';
+
+const NOUN = /^(NN|NNS|NNP|NNPS)$/;
+const PROPER = /^(NNP|NNPS)$/;
+const ADJ = /^JJ/;
+
+function bare(w: ClsWord): string {
+  return w.word.toLowerCase().replace(/[^a-z]/g, '');
+}
+function isNoun(w: ClsWord): boolean { return NOUN.test(w.lexicalClass); }
+function isProper(w: ClsWord): boolean { return PROPER.test(w.lexicalClass); }
+function isAdjMod(w: ClsWord): boolean { 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: ClsWord, b: ClsWord): boolean {
+  return LEXICALIZED_FORESTRESS.has(`${bare(a)} ${bare(b)}`);
+}
+
+type Side = 'left' | 'right';
+
+/** Which element of an adjacent (modifier w1, head-noun w2) structure carries
+ *  primary stress, per Scenarios A/B/C. */
+export function scenarioModifierSide(w1: ClsWord, w2: ClsWord): Side {
+  // 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: ClsWord[]): void {
+  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: Record<string, number> = { x: 0, w: 1, n: 2, m: 3, s: 4 };
+const LEVELS = ['x', 'w', 'n', 'm', 's'] as const;
+
+function peakSyll(w: ClsWord) {
+  let best = null as ClsWord['syllables'][number] | 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: ClsWord[]): void {
+  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/src/calliope/syntax.ts

@@ -0,0 +1,218 @@
+// 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 { ClsWord } from '../types.js';
+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: ClsWord): boolean {
+  return /^[^A-Za-z0-9]+$/.test(w.lexicalClass) || w.syllables.length === 0;
+}
+export function isNoun(w: ClsWord): boolean { return NOUN.test(w.lexicalClass); }
+export function isVerb(w: ClsWord): boolean { return VERB.test(w.lexicalClass); }
+function bare(w: ClsWord): string { 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: ClsWord): boolean {
+  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: ClsWord): boolean {
+  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: ClsWord): boolean {
+  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: ClsWord, children: Map<number, ClsWord[]>,
+): boolean {
+  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: ClsWord, verb: ClsWord): boolean {
+  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: ClsWord, words: ClsWord[]): string | null {
+  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: ClsWord, words: ClsWord[]): boolean {
+  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: ClsWord, head: ClsWord, words?: ClsWord[]): boolean {
+  // 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: ClsWord, words: ClsWord[]): boolean {
+  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: ClsWord, words: ClsWord[]): boolean {
+  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: ClsWord, words: ClsWord[]): boolean {
+  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
+}
+
+// ─── functor of a head-dependent pair (Wagner §6.2.2 mapping) ────────────────
+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 function functorOf(dep: ClsWord): FunctorSide {
+  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/src/calliope/udpos.ts

@@ -0,0 +1,152 @@
+// 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.
+
+import type { UDWord } from 'udpipe-node';
+
+// 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: string | undefined): boolean {
+  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: UDWord): string {
+  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: UDWord, k: string): string | undefined {
+  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: UDWord): string {
+  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';
+  }
+}