calliope-ts 0.0.2 → 0.0.3

package/dist/clio/semantics.d.ts

@@ -0,0 +1,44 @@
+import { ClsWord } from '../types.js';
+/**
+ * A STRANDED preposition: an IN preposition whose complement has been extracted
+ * (wh-movement / relativisation / topicalisation), so it governs no object and
+ * sits clause-finally — "what are you waiting FOR", "…what you stare AT".  Such
+ * a preposition bears stress (it is not the reducible proclitic of "in the
+ * house").  Conservative: IN only (infinitival TO is excluded — "I want to go"
+ * is not stranding), no dependent, and clause-final (the canonical strand site).
+ */
+export declare function isStrandedPreposition(word: ClsWord, words: ClsWord[]): boolean;
+/**
+ * A CONTRASTIVE possessive: a possessive determiner (PRP$: thy/my/your/her…)
+ * in the elliptical contrast frame "X's … not/but MINE" — the contrast lifts
+ * the possessor out of reduction ("it was THY choice, not mine").  Tight by
+ * construction: requires a contrast marker (not/but/nor) adjacent to an
+ * absolute possessive somewhere in the clause, so an ordinary unfocused
+ * possessive ("I lost my way") is left alone.
+ */
+export declare function isContrastivePossessive(word: ClsWord, words: ClsWord[]): boolean;
+/**
+ * A fronted DEICTIC LOCATIVE "there"/"here" in locative inversion — "THERE
+ * could I marvel", "HERE could I rest".  FinNLP mis-tags the fronted locative
+ * as existential (EX / expl) or reduces it as a discourse adverb, flattening it
+ * to 'w'; but a fronted locative that triggers subject-aux inversion (an
+ * aux/modal immediately followed by a subject pronoun) is a stressed deictic
+ * focus, NOT the reduced existential of "there IS a house" (no inversion) or
+ * the presentational "there LIVED a king" (verb + NP, no inversion).
+ */
+export declare function isDeicticLocative(word: ClsWord, words: ClsWord[]): boolean;
+/**
+ * Imperative clause: the ROOT is a base-form verb (VB) with no overt subject
+ * (no NSUBJ dependent) — "Tell me…", "Do not go…".  Used by the nuclear pass:
+ * the accent falls on the verb / its object, not on a (dropped) subject, and an
+ * imperative-clause vocative is a direct address.
+ */
+export declare function isImperativeClause(words: ClsWord[]): boolean;
+/**
+ * A VOCATIVE (direct address): a noun tagged DISCOURSE/INTJ/DEP and set off by
+ * adjacent punctuation (a comma or "!"), in a clause that is imperative or
+ * subject-less — "Sing, O GODDESS…", "blow, BUGLE, blow".  Conservative: the
+ * noun must be comma/!-adjacent so an ordinary argument noun is not swept in.
+ */
+export declare function isVocative(word: ClsWord, words: ClsWord[]): boolean;
+//# sourceMappingURL=semantics.d.ts.map

package/dist/clio/semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.d.ts","sourceRoot":"","sources":["../../src/clio/semantics.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAsBtC;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAI9E;AAQD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAQhF;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAc1E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAS5D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAUnE"}

package/dist/clio/semantics.js

@@ -0,0 +1,139 @@
+// semantics.ts — Prominence signals mined from the dependency parse + POS.
+//
+// Dependency roles ARE the semantic layer: NSUBJ=agent, DOBJ/IOBJ=patient/
+// recipient, OBL/ADVMOD/ADVCL=peripheral, PRP$=possessor, INTJ/DISCOURSE=
+// address.  A flat POS floor crushes function words that these configurations
+// reveal to be prominent — a STRANDED preposition ("what are you waiting FOR"),
+// a CONTRASTIVE possessive ("thy choice, not mine"), a VOCATIVE.  These
+// detectors recover that prominence from observable structure only (no semantic
+// guessing, no cross-poem givenness).  They are consumed by the relativiser
+// (stress.ts) as targeted floor RAISES, and by the nuclear pass (Phase 4).
+import { isPunctuation } from './parser.js';
+/** True if some other token has `word` as its dependency governor (i.e. word
+ *  has a complement/dependent of its own). */
+function hasDependent(word, words) {
+    for (const w of words) {
+        if (w !== word && w.dependency && w.dependency.governor === word)
+            return true;
+    }
+    return false;
+}
+/** Last non-punctuation token index in the sentence at/after `from`? */
+function isClauseFinal(word, words) {
+    const idx = words.indexOf(word);
+    if (idx < 0)
+        return false;
+    for (let k = idx + 1; k < words.length; k++) {
+        if (!isPunctuation(words[k].lexicalClass))
+            return false;
+    }
+    return true;
+}
+/**
+ * A STRANDED preposition: an IN preposition whose complement has been extracted
+ * (wh-movement / relativisation / topicalisation), so it governs no object and
+ * sits clause-finally — "what are you waiting FOR", "…what you stare AT".  Such
+ * a preposition bears stress (it is not the reducible proclitic of "in the
+ * house").  Conservative: IN only (infinitival TO is excluded — "I want to go"
+ * is not stranding), no dependent, and clause-final (the canonical strand site).
+ */
+export function isStrandedPreposition(word, words) {
+    if (word.lexicalClass !== 'IN')
+        return false;
+    if (hasDependent(word, words))
+        return false; // has a complement → ordinary preposition
+    return isClauseFinal(word, words);
+}
+/** Absolute / elliptical possessive pronouns used as the contrasted element. */
+const ABSOLUTE_POSSESSIVES = new Set([
+    'mine', 'thine', 'yours', 'hers', 'ours', 'theirs', 'his',
+]);
+const CONTRAST_MARKERS = new Set(['not', 'but', 'nor']);
+/**
+ * A CONTRASTIVE possessive: a possessive determiner (PRP$: thy/my/your/her…)
+ * in the elliptical contrast frame "X's … not/but MINE" — the contrast lifts
+ * the possessor out of reduction ("it was THY choice, not mine").  Tight by
+ * construction: requires a contrast marker (not/but/nor) adjacent to an
+ * absolute possessive somewhere in the clause, so an ordinary unfocused
+ * possessive ("I lost my way") is left alone.
+ */
+export function isContrastivePossessive(word, words) {
+    if (word.lexicalClass !== 'PRP$')
+        return false;
+    for (let i = 0; i + 1 < words.length; i++) {
+        const a = words[i].word.toLowerCase();
+        const b = words[i + 1].word.toLowerCase().replace(/['’]/g, '');
+        if (CONTRAST_MARKERS.has(a) && ABSOLUTE_POSSESSIVES.has(b))
+            return true;
+    }
+    return false;
+}
+/** Finite auxiliaries / modals whose appearance before a subject pronoun marks
+ *  subject-aux inversion. */
+const INVERSION_AUX = new Set(['MD', 'VBP', 'VBZ', 'VBD']);
+/**
+ * A fronted DEICTIC LOCATIVE "there"/"here" in locative inversion — "THERE
+ * could I marvel", "HERE could I rest".  FinNLP mis-tags the fronted locative
+ * as existential (EX / expl) or reduces it as a discourse adverb, flattening it
+ * to 'w'; but a fronted locative that triggers subject-aux inversion (an
+ * aux/modal immediately followed by a subject pronoun) is a stressed deictic
+ * focus, NOT the reduced existential of "there IS a house" (no inversion) or
+ * the presentational "there LIVED a king" (verb + NP, no inversion).
+ */
+export function isDeicticLocative(word, words) {
+    const lemma = word.word.toLowerCase().replace(/['’]/g, '');
+    if (lemma !== 'there' && lemma !== 'here')
+        return false;
+    const idx = words.indexOf(word);
+    // must be the first non-punctuation token (fronted)
+    let first = -1;
+    for (let i = 0; i < words.length; i++) {
+        if (!isPunctuation(words[i].lexicalClass)) {
+            first = i;
+            break;
+        }
+    }
+    if (idx !== first)
+        return false;
+    // subject-aux inversion: <there/here> <aux|modal> <subject pronoun>
+    const aux = words[idx + 1];
+    const subj = words[idx + 2];
+    return !!(aux && subj && INVERSION_AUX.has(aux.lexicalClass) && subj.lexicalClass === 'PRP');
+}
+/**
+ * Imperative clause: the ROOT is a base-form verb (VB) with no overt subject
+ * (no NSUBJ dependent) — "Tell me…", "Do not go…".  Used by the nuclear pass:
+ * the accent falls on the verb / its object, not on a (dropped) subject, and an
+ * imperative-clause vocative is a direct address.
+ */
+export function isImperativeClause(words) {
+    const root = words.find(w => w.dependency && w.dependency.dependentType === 'root');
+    if (!root)
+        return false;
+    if (root.lexicalClass !== 'VB' && root.lexicalClass !== 'VBP')
+        return false;
+    for (const w of words) {
+        if (w.dependency && w.dependency.governor === root
+            && /nsubj/i.test(w.dependency.dependentType))
+            return false;
+    }
+    return true;
+}
+/**
+ * A VOCATIVE (direct address): a noun tagged DISCOURSE/INTJ/DEP and set off by
+ * adjacent punctuation (a comma or "!"), in a clause that is imperative or
+ * subject-less — "Sing, O GODDESS…", "blow, BUGLE, blow".  Conservative: the
+ * noun must be comma/!-adjacent so an ordinary argument noun is not swept in.
+ */
+export function isVocative(word, words) {
+    if (!/^(NN|NNS|NNP|NNPS)$/.test(word.lexicalClass))
+        return false;
+    const role = word.dependency?.dependentType ?? '';
+    if (!/discourse|intj|dep|vocative/i.test(role))
+        return false;
+    const idx = words.indexOf(word);
+    const prev = idx > 0 ? words[idx - 1] : null;
+    const next = idx + 1 < words.length ? words[idx + 1] : null;
+    const commaAdjacent = (prev && /^[,!]$/.test(prev.word)) || (next && /^[,!]$/.test(next.word));
+    return !!commaAdjacent && isImperativeClause(words);
+}

package/dist/clio/stress.d.ts

@@ -0,0 +1,83 @@
+import { ClsWord, IntonationalUnit } from '../types.js';
+/** Check if a pair of words forms a left‑stressed compound. */
+export declare function isLeftStressedPair(w1: string, w2: string): boolean;
+/** True if `w2` is a head noun that keeps phrasal/right stress against an N1
+ *  modifier (apple PIE, summer DAY, Fifth AVenue) — the marked right-stress
+ *  exceptions to the otherwise fore-stressing Compound Stress Rule. */
+export declare function isRightStressedHead(w2: string): boolean;
+/**
+ * Direction of primary stress for an adjacent two-word modification structure,
+ * the SINGLE source of truth shared by the lexical compound pass
+ * (`applyCompoundStress`) and the Phrase-Stress phase (`computePhraseStress`),
+ * so the two layers cannot disagree.
+ *
+ *   'left'  = fore-stress, primary on w1 — the Compound Stress Rule default for
+ *             an N+N compound (Chomsky–Halle; McAleese's worked example marks
+ *             ICE cream with primary on "ice", not "cream"): KITCHen table,
+ *             WINdow frame, BEDroom door, plus the curated LEFT_STRESS_* sets.
+ *   'right' = end-stress, primary on w2 — the marked exceptions: food/temporal
+ *             "made of N1" heads (apple PIE, summer DAY), Adj+N which is phrasal
+ *             not compound (sweet CREAM, red CAR), and proper-name sequences
+ *             which carry their own right-headed prosody (New YORK, John SMITH).
+ *   null    = not a compound/modification pair at all.
+ *
+ * The fore-stress default is restricted to COMMON-noun N+N: proper-noun pairs
+ * (NNP/NNPS) are excluded because place- and personal-name sequences are not
+ * reliably fore-stressed, and flipping them would mis-teach New YORK / John SMITH.
+ */
+export declare function compoundStressSide(w1: string, pos1: string, w2: string, pos2: string): 'left' | 'right' | null;
+/**
+ * Assign per‑syllable lexical stress to each word in a sentence.
+ *
+ * Uses the first CMU pronunciation.  Function words have their
+ * primary stress downgraded to secondary (2 → 1).
+ */
+export declare function assignLexicalStress(words: ClsWord[]): void;
+/**
+ * Adjust stresses for nominal compounds.
+ *
+ * Fore-stressed by default: an N+N compound puts primary (2) on the first
+ * element, secondary (1) on the second — the Compound Stress Rule (Chomsky–
+ * Halle; McAleese marks ICE cream with primary on "ice", KITCHen table,
+ * WINdow frame).  The marked right-stress exceptions — food/temporal "made of"
+ * heads (apple PIE), Adj+N phrases (sweet CREAM), and proper-name sequences
+ * (New YORK) — reverse it.  All of this lives in `compoundStressSide`.
+ */
+export declare function applyCompoundStress(ius: IntonationalUnit[]): void;
+/** Locate the syllable with the highest stress and set it to `value`. */
+export declare function setPrimaryStress(word: ClsWord, value: number): void;
+/**
+ * Recursively assign higher stress to content words from right to left.
+ * Only the rightmost content word receives a boost (+1 above lexical primary).
+ * All other content words keep their lexical stress.
+ * This preserves lexical stress for meter detection while still indicating
+ * the nuclear accent for phonological phrasing.
+ */
+export declare function applyNuclearStress(ius: IntonationalUnit[]): void;
+/**
+ * Convert numeric per‑syllable stress to McAleese’s symbolic levels
+ * (w, n, m, s) and resolve adjacent identical stresses using dependency
+ * information.
+ */
+export declare function assignRelativeStresses(words: ClsWord[], ius: IntonationalUnit[]): void;
+/**
+ * THE CLASH FILTER — an absolute surface well-formedness constraint.
+ *
+ * On the STRESSED tier {n, m, s} no two *contiguous* syllables may carry the SAME
+ * level: that is a stress clash (two equal prominences with no gradation between
+ * them), which English categorically disallows.  Gradient pairs (sm/ms/sn/ns/mn/nm)
+ * are fine — there is still a step down — as are runs of the unstressed tiers
+ * {w, x} (an unstressed sequence is tolerated, if not ideal).  This generalises
+ * McAleese's Appendix-A step 3d-ii ("stress clashes (ss, ms) > s-s") and Liberman
+ * & Prince's (1977) grid alternation to every level of the strong tier.
+ *
+ * Resolution is DEMOTE-ONLY (never promote — promotion is the meter layer's job,
+ * McAleese Test 2), so the contour is never inflated to break a clash; we iterate
+ * to a fixed point (each change strictly lowers total stress mass, so it
+ * terminates).  Which member yields is decided by `demoteRightOfClash` (grid-based
+ * relative prominence).  Runs on the LINEAR surface order because a clash is a
+ * property of contiguous *pronounced* syllables (Hayes), which a mis-grouped
+ * dependency parse can scatter across phrases.
+ */
+export declare function resolveLinearClashes(words: ClsWord[]): void;
+//# sourceMappingURL=stress.d.ts.map

package/dist/clio/stress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stress.d.ts","sourceRoot":"","sources":["../../src/clio/stress.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAyB,gBAAgB,EAAsB,MAAM,aAAa,CAAC;AA2VnG,+DAA+D;AAC/D,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAelE;AAED;;uEAEuE;AACvE,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GACjD,MAAM,GAAG,OAAO,GAAG,IAAI,CASzB;AAiSD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAkR1D;AAID;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CA2BjE;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYnE;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAwChE;AA8CD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAsLtF;AA8FD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAuB3D"}