calliope-ts 0.0.5 → 0.1.0

package/README.md

@@ -1,6 +1,6 @@
-# Calliope TS 0.0.4
+# Calliope TS 0.0.7
 
-**Calliope TS** is a phonological poetry-scansion toolkit for TypeScript / Node.js. Hand it a poem (or a single line), and it will tell you — and *show* you — how that verse actually moves: which syllables carry weight and how much, where the beats fall, what meter each line is in and how confidently, what rhymes with what, and what form the stanzas add up to.
+**Calliope TS** is a bilingual (English & Russian) phonological poetry-scansion toolkit for TypeScript / Node.js. Hand it a poem (or a single line), and it will tell you — and *show* you — how that verse actually moves: which syllables carry weight and how much, where the beats fall, what meter each line is in and how confidently, what rhymes with what, and what form the stanzas add up to. The English pipeline is the primary and most fully documented engine; a parallel Russian pipeline (accentology + SynTagRus dependency parsing) is described under [Russian support](#russian-support).
 
 The premise is that meter is something you *recover from pronunciation*, not something you stamp onto spelling. So Calliope reads a line roughly the way an attentive reader does: it first works out how the words would be said aloud — dictionary stress, the way phrases clump, where the voice peaks at a clause-end — and only then looks for the regular beat that saying settles into. This approach has a name in the linguistics literature, **phonological scansion**, and the bulk of this README is about what that means and how the toolkit puts it to work.
 
@@ -24,6 +24,7 @@ Stress Maps & Meter  — top-3 candidate meters per line
 ## Contents
 
 - [Installation](#installation)
+- [Russian support](#russian-support)
 - [Quick start (CLI)](#quick-start-cli)
 - [Reading the output](#reading-the-output)
 - [What "phonological scansion" means](#what-phonological-scansion-means)
@@ -61,6 +62,31 @@ npm test           # vitest suite
 
 ---
 
+## Russian support
+
+Calliope's Russian pipeline (accentology + ёфикация + SynTagRus dependency parsing + Russian rhyme/meter analysis) runs on a set of large data assets — the SynTagRus UDPipe model plus stress dictionaries and neural-accentuator weights (~122 MB total). To keep the npm package small, **these assets are not bundled in the published package**; the English engine has no such dependency and works immediately after install.
+
+The Russian assets are fetched **automatically on first Russian analysis** and written into the toolkit's `russian/data` folder, after which they are reused offline. You can also pre-fetch them explicitly:
+
+```bash
+npx calliope-fetch-russian   # from an installed package (global or local)
+npm run fetch-russian        # from a clone of this repository
+```
+
+Configuration (all optional):
+
+| Variable | Effect |
+|---|---|
+| `CALLIOPE_RUSSIAN_DATA` | Absolute path to a directory holding the Russian data files (skips download; use a pre-populated location). |
+| `CALLIOPE_RUSSIAN_DATA_URL` | Base URL to fetch the assets from (defaults to the project's HuggingFace space). |
+| `CALLIOPE_RUSSIAN_UDPIPE_MODEL` | Absolute path to just the `.udpipe` model file. |
+
+Asset resolution searches, in order: `$CALLIOPE_RUSSIAN_DATA` → `data/` beside the running module (`src/russian/data` or `dist/russian/data`) → the sibling `src/russian/data` when running compiled code from `dist/` (the Docker / HuggingFace layout) → cwd-relative fallbacks. This means a source checkout, a compiled `dist/`, a Docker/HF deployment, and an npm-installed dependency all locate the data without any manual copying.
+
+The Russian assets — dictionaries, methodology, and the SynTagRus UDPipe model — are redistributed here under the **MIT License** of Ilya Koziev's RussianPoetryScansionTool distribution, which is how they reached this project and which permits commercial use. A CC BY-NC-SA 4.0 reference file is also retained for the SynTagRus model, reflecting the terms under which it is distributed elsewhere; see [License and credits](#license-and-credits).
+
+---
+
 ## Quick start (CLI)
 
 ```bash
@@ -98,6 +124,36 @@ There are two display modes:
 
 ---
 
+## The web app (browser interface)
+
+Everything the CLI prints — and several instruments beyond it — is also available
+as a local web app with two visual skins (a bright-on-black **Terminal** display
+and a parchment **Manuscript** display, switchable in ⚙ Settings):
+
+```bash
+# from a clone or an installed package
+npm run web            # then open http://localhost:4321
+
+# or, installed globally / via npx
+calliope-web
+PORT=8080 calliope-web # any port you like
+```
+
+The app serves four instruments in one place:
+
+| Tab | What it does |
+|---|---|
+| **Scansion** | The full reading view: every syllable tinted by stress, per-line meter tags with fit %, rhyme letters, a per-line detailed scan (feet, syllable anatomy, prosodic phrasing, key stresses, dependency arcs, Scandroid comparison), poem synopsis, phonopoetics, and rich word/syllable hover-profiles backed by Nounsing Pro. A **⧉ Copy stress map** button exports the whole poem's stress keys as CLI-style plain text. |
+| **Rhyme Forge** | Word dossiers from the augmented lexicon: rhymes (strict or by syllable count), rime phonemes, metrical feet inside words, and Meter Match — cast a stress contour (`010`) and summon every word that carries it. |
+| **Rewrites** | Nounsing Pro's transmutations: stress-skeleton, phoneme-echo, or rhyme-swap rewrites with POS-fidelity and word-frequency (Zipf floor) controls. |
+| **Syntax** | The UDPipe dependency parse (with DepEdit-TS repairs) as arc diagrams and a glossed register, line-by-line or fused into one continuous text. |
+
+The web app has **no extra dependencies** — it is a single zero-dependency Node
+server (`webapp/server.mjs`) importing the same `dist/` build the CLI uses, plus
+a vanilla-JS front-end. It only talks to `localhost`; nothing leaves your machine.
+
+---
+
 ## Reading the output
 
 ### The five stress levels
@@ -360,7 +416,7 @@ Calliope TS is developed by **Aleksey Calvin** / [SilverAgePoets.com](https://ww
 ---
 
 **Limitations to know about.**
-- English only (the dictionary and phonological rules are English; while the UDPipe backend natively supports multilingual parsing, other languages will produce nonsense rather than errors).
+- Two languages are supported: **English** (the primary engine — its dictionary and phonological rules) and **Russian** (a parallel accentological engine, see [Russian support](#russian-support)). Other languages will produce nonsense rather than errors, since the UDPipe backend parses them but the prosodic rules are language-specific.
 - Stress-doublet words (*rebel*, *content*, names like *Hugo*) are read with their dictionary stress; a correction is on the roadmap.
 - Rare or foreign proper names fall back to rule-based stress guesses.
 
@@ -400,4 +456,14 @@ Methodological and conceptual debts:
 - the makers of Prosodic (Heuser et al, for establishing an admirable state-of-the-art to compare against, differentiate from, and hopefully surpass in due time, in select ways),
 - Milan Straka and the UDPipe project (for the robust neural parsing architecture now driving the core mechanics), 
 - as well as broader generative-metrics, constraint-based metrics, and OT traditions, including Kiparsky, Prince & Smolensky, Groves, Blumenfeld, Lilja, Chomsky & Halle, Fabb & Halle (rule-based grid scansion theory), Einarsson (Metremic theory), Russom (Universalist metrics), K. M. Ryan (gradient syllable weight), big daddy Jakobson who had once roped the whole world with subtle strings and often hung out with Mayakovsky, and many others. <br>
+
+### The Russian pipeline
+
+Calliope's Russian side owes an especial and foundational debt to **Ilya Koziev** and the **"Natural Language Processing in Russian"** group, whose [RussianPoetryScansionTool](https://github.com/Koziev/RussianPoetryScansionTool) served as the principal blueprint for much (though not all) of Calliope's Russian accentology and scansion methodology. Koziev's tool is generously distributed under the **MIT License** (which permits commercial use), and it is through it that the **SynTagRus UDPipe model** first came to this project. With deep respect and gratitude for their excellent work, any questions concerning the SynTagRus model or the underlying Russian-scansion methodology are most appropriately directed to Ilya Koziev and the NLP-in-Russian group.
+
+The Russian data assets bundle their license files, mirrored in the project's [HuggingFace deployment](https://huggingface.co/spaces/AlekseyCalvin/cts/tree/main/src/russian/data):
+- `src/russian/data/LICENSE.txt` — the **MIT** license of the RussianPoetryScansionTool / NLP-in-Russian group. This is the license under which the Russian assets used here — dictionaries, methodology, and the SynTagRus UDPipe model — were obtained and are redistributed. It permits commercial use.
+- `src/russian/data/LICENSE_UDpipe_SynTagRus.txt` — a **CC BY-NC-SA 4.0** reference file, retained because SynTagRus/UDPipe models are distributed under those terms in other (upstream) channels. It is kept for transparency around that residual ambiguity; it does not govern the copy bundled here, which came via the MIT distribution above.
+
+**A note on commercial use:** the Calliope-TS code (Apache-2.0) and the Russian assets as obtained here (MIT, via Koziev's distribution) permit commercial use. Because SynTagRus/UDPipe models are elsewhere distributed under CC BY-NC-SA 4.0 (non-commercial), anyone with strict compliance requirements may wish to independently confirm the provenance of their model file or substitute one whose licensing they control (point `CALLIOPE_RUSSIAN_UDPIPE_MODEL` at it). The **SynTagRus** treebank and the **UDPipe** framework are the work of Milan Straka et al. (Charles University / LINDAT); the Russian stress dictionaries and neural accentuator derive from the RussianPoetryScansionTool corpus.
 *Gareth McAleese: If you're reading this, please do email me!

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

@@ -1 +1 @@
-{"version":3,"file":"bracketing.d.ts","sourceRoot":"","sources":["../../src/calliope/bracketing.ts"],"names":[],"mappings":"AAsCA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AA4HnD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAmF3D;AA4GD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CA6BzE"}
+{"version":3,"file":"bracketing.d.ts","sourceRoot":"","sources":["../../src/calliope/bracketing.ts"],"names":[],"mappings":"AAsCA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAiJnD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAsG3D;AAyHD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CA6BzE"}

package/dist/calliope/bracketing.js

@@ -36,6 +36,8 @@
 // Output is per-word `phraseStress` (1 = strongest, punctuation = 0): the structural
 // prominence the relativiser then reads PER PHONOLOGICAL PHRASE to place beats.
 import { isPunct, isVerb, verbHasArgChild, isUnaccusativeOrPassive, isLowLocative, isFrameSetting, isLightNominalHead, } from './syntax.js';
+import { compoundStressSide } from '../stress.js';
+import { isMarginalModalUse, isSemiModalHaveTo } from './syntax.js';
 const NOUN = /^(NN|NNS|NNP|NNPS)$/;
 /** A head-dependent combination is a COMPOUND (Compound Stress Rule → primary LEFT)
  *  when the parse labels it NOMD, or when a common-/proper-noun modifier sits
@@ -46,6 +48,12 @@ function isCompound(dep, head) {
         return true;
     if ((dep.canonicalRel ?? '') === 'EXT')
         return false;
+    // A POSSESSIVE noun modifier ("love's sway", "the belfies' bee-buzz" —
+    // nmod:poss, canonical CASE) is a syntactic PHRASE, not a compound: the NSR
+    // right-stresses it (love's SWAY).  Without this the N+N surface-adjacency
+    // fallback swallowed possessives and fore-stressed them.
+    if ((dep.canonicalRel ?? '') === 'CASE')
+        return false;
     return NOUN.test(dep.lexicalClass) && NOUN.test(head.lexicalClass)
         && Math.abs(dep.absoluteIndex - head.absoluteIndex) === 1;
 }
@@ -88,9 +96,17 @@ function combineDecision(dep, head, children, words) {
     const depBefore = dep.absoluteIndex < head.absoluteIndex;
     const rightWins = depBefore ? 'head' : 'dep'; // NSR rightmost
     const leftWins = depBefore ? 'dep' : 'head'; // CSR leftmost
-    // Compound Stress Rule first (handles the backwards-parsed N+N the tagger mislabels).
-    if (isCompound(dep, head))
-        return leftWins;
+    // Compound Stress Rule first (handles the backwards-parsed N+N the tagger
+    // mislabels) — but through compoundStressSide, the SINGLE source of truth the
+    // lexical pass and scenario rules already share, so the curated right-stress
+    // heads hold here too: a temporal/product head keeps phrasal end-stress
+    // ("a wondrous Moscow DAY", "apple PIE") — those are N+N by POS yet phrasal
+    // by prosody, and fore-stressing them handed the φ nuclear to the modifier.
+    if (isCompound(dep, head)) {
+        const [w1, w2] = depBefore ? [dep, head] : [head, dep];
+        const side = compoundStressSide(w1.word, w1.lexicalClass, w2.word, w2.lexicalClass);
+        return side === 'right' ? rightWins : leftWins;
+    }
     if (rel === 'EXT')
         return rightWins; // proper-name head (New YORK)
     switch (rel) {
@@ -126,8 +142,13 @@ function combineDecision(dep, head, children, words) {
         case 'AMOD':
             return depBefore ? 'match' : 'head'; // pre-modifier → own domain; post → subordinate
         case 'ADVMOD':
-            if (/^JJ/.test(head.lexicalClass))
-                return 'head'; // degree adv ("very TALL") integrates
+            // A degree/measure adverb premodifying an ADJECTIVE or another ADVERB
+            // integrates with its head — the head is the argument and keeps the
+            // accent ("very TALL", "far aWAY", "so MUCH"): adverb-over-adverb
+            // premodification is essentially always degree, unlike VP-adverbs,
+            // which keep their own accentual domain.
+            if (/^(JJ|RB)/.test(head.lexicalClass))
+                return 'head';
             return depBefore ? 'match' : 'head'; // pre-adv → own domain; post → subordinate
         case 'ACL':
         case 'ADVCL':
@@ -260,6 +281,25 @@ export function computePhraseStress(sent) {
     // Accent-level clash reduction (Wagner §6.4.1): runs BEFORE the syllable-level
     // resolveStressClashes (relstress.ts) and is additional to it.  See below.
     reduceAccentClashes(words);
+    // Newman's generalization (1946; Wagner §2.4.1): "nuclear stress is perceived
+    // on the LAST of the grid marks that project highest."  MATCH cycles
+    // legitimately co-designate sisters (coordination, the specifier restriction),
+    // so the cyclic levels can tie at the top — but the utterance NUCLEAR is
+    // unique: the final co-equal keeps the top rank and earlier co-equals are
+    // perceived one step lower (Mary(2) ate sweet ICE(1) cream — the subject
+    // matched the branching VP, yet the ear resolves rightward).  One demotion
+    // step only; the rest of the gradient is untouched, so per-φ beat selection
+    // (which reads the LOCAL minimum) is unaffected.
+    {
+        const ranked = words.filter(w => (w.phraseStress || 0) > 0);
+        if (ranked.length > 1) {
+            const min = Math.min(...ranked.map(w => w.phraseStress));
+            const atMin = ranked.filter(w => w.phraseStress === min)
+                .sort((a, b) => a.absoluteIndex - b.absoluteIndex);
+            for (let i = 0; i < atMin.length - 1; i++)
+                atMin[i].phraseStress = min + 1;
+        }
+    }
 }
 /** Accent-level clash reduction (Wagner §6.4.1).  Operates on which CONTENT words
  *  bear a phrasal accent (a local prominence), NOT on syllable stress.  A run of
@@ -330,6 +370,20 @@ function phiProjects(dep, head, children, words) {
     switch (dep.canonicalRel ?? '') {
         case 'CCOMP':
         case 'XCOMP':
+            // A BARE-infinitive complement of a marginal modal ("dare [he] aspire",
+            // "dare seize the fire") is one prosodic verb cluster with its functor —
+            // the modal reduces and the infinitive holds the beat, so splitting them
+            // into separate φs would strand the reduced modal as a beat-less φ (which
+            // the anchor fallback would then wrongly re-promote).
+            if (isMarginalModalUse(head, words))
+                return false;
+            // The TO-infinitive complement of semi-modal "have to" is likewise one
+            // prosodic verb cluster with its reduced functor ("do I have to bless"):
+            // splitting φ between "have" and "to bless" strands the reduced "have",
+            // which the anchor fallback then wrongly re-promotes to the φ nuclear.
+            if (isSemiModalHaveTo(head, words))
+                return false;
+            return true;
         case 'ADVCL':
         case 'CONJ':
             return true;

package/dist/calliope/deps.d.ts

@@ -1,4 +1,8 @@
 import { ClsSentence } from '../types.js';
-/** Populate `canonicalRel` for every word, then apply label-only repairs. */
+/** Populate `canonicalRel` for every word, then apply label-only repairs.
+ *  One HEAD-CHANGING repair (fixPossessiveApposition) runs first, before the
+ *  labels are computed — it is the single exception to this file's additive
+ *  contract, and like the POS corrections of Stage F1 it mutates only the
+ *  Calliope view of the parse (Clio never runs this pass). */
 export declare function normalizeDeps(sent: ClsSentence): void;
 //# sourceMappingURL=deps.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../src/calliope/deps.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAW,MAAM,aAAa,CAAC;AAkBnD,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAIrD"}
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../src/calliope/deps.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAW,MAAM,aAAa,CAAC;AAkBnD;;;;8DAI8D;AAC9D,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAKrD"}

package/dist/calliope/deps.js

@@ -26,18 +26,68 @@ function gov(w) {
 function preHead(w, head) {
     return w.absoluteIndex + 1 === head.absoluteIndex;
 }
-/** Populate `canonicalRel` for every word, then apply label-only repairs. */
+/** Populate `canonicalRel` for every word, then apply label-only repairs.
+ *  One HEAD-CHANGING repair (fixPossessiveApposition) runs first, before the
+ *  labels are computed — it is the single exception to this file's additive
+ *  contract, and like the POS corrections of Stage F1 it mutates only the
+ *  Calliope view of the parse (Clio never runs this pass). */
 export function normalizeDeps(sent) {
+    fixPossessiveApposition(sent.words);
     for (const w of sent.words)
         w.canonicalRel = canonical(w);
     fixDitransitive(sent.words);
     inferPrenominalModifiers(sent.words);
 }
-/** Reliable structural relations whose label adjacency must NOT override. */
+/** A POSSESSIVE-marked noun cannot head a following noun as its APPOSITION —
+ *  a possessor is a dependent by definition.  UDPipe parses Shakespeare's
+ *  "…more red than her lips' red" with red₂ ←appos← lips' (and lips' ←obl←
+ *  red₁), inverting the real structure ("the red of her lips"): the deep
+ *  demotion this hands red₂ wrecked the line's iambic grid.  Repair: the
+ *  appositive noun takes over the possessive's relation and governor; the
+ *  possessive becomes its poss dependent — which the NSR right-stresses
+ *  (her lips' RED, like love's SWAY).  Gated on the OVERT possessive mark
+ *  (trailing 's or s'), so genuine appositions ("my brother the doctor")
+ *  never match. */
+function fixPossessiveApposition(words) {
+    for (const b of words) {
+        if (rawRel(b) !== 'appos')
+            continue;
+        if (!NOUN.test(b.lexicalClass))
+            continue;
+        const a = gov(b);
+        if (!a || !NOUN.test(a.lexicalClass))
+            continue;
+        if (a.absoluteIndex >= b.absoluteIndex)
+            continue; // possessive precedes
+        if (!/['’]s$|s['’]$/.test(a.word))
+            continue; // overt possessive mark
+        const aGov = gov(a);
+        if (!aGov || aGov === b || !a.dependency || !b.dependency)
+            continue;
+        // B inherits A's governor and relation; A becomes B's possessive.
+        b.dependency.governor = aGov;
+        b.dependency.dependentType = a.dependency.dependentType;
+        a.dependency.governor = b;
+        a.dependency.dependentType = 'nmod:poss';
+        // A's case marker ("than") re-points to B, the true oblique head.
+        for (const c of words) {
+            if (c !== a && c !== b && gov(c) === a && c.dependency &&
+                (rawRel(c) === 'case' || c.lexicalClass === 'IN' || c.lexicalClass === 'TO')) {
+                c.dependency.governor = b;
+            }
+        }
+    }
+}
+/** Reliable structural relations whose label adjacency must NOT override.
+ *  CASE is here for the POSSESSIVE noun ("her lips' red" — nmod:poss →
+ *  CASE): a possessive NNS immediately precedes its noun head, and letting
+ *  surface adjacency relabel it NOMD hands it to the Compound Stress Rule,
+ *  fore-stressing what the NSR must right-stress (her lips' RED, love's
+ *  SWAY). */
 const STRUCTURAL = new Set([
     'ROOT', 'NSUBJ', 'NSUBJPASS', 'DOBJ', 'IOBJ', 'OBL', 'AUX', 'AUXPASS',
     'CCOMP', 'XCOMP', 'ADVCL', 'ADVMOD', 'AMOD', 'ACL', 'CC', 'CONJ', 'EXPL',
-    'INTJ', 'DISCOURSE', 'VPRT', 'COMPMARK', 'ADVMARK', 'EXT',
+    'INTJ', 'DISCOURSE', 'VPRT', 'COMPMARK', 'ADVMARK', 'EXT', 'CASE',
 ]);
 /**
  * Pre-head modifier inference by SURFACE ADJACENCY — independent of en-parse's

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

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/calliope/engine.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AA0D7C,eAAO,MAAM,cAAc,EAAE,aAG5B,CAAC"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/calliope/engine.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AA+D7C,eAAO,MAAM,cAAc,EAAE,aAG5B,CAAC"}

package/dist/calliope/engine.js

@@ -10,7 +10,7 @@
 // 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 { assignLexicalStress, applySurfacePostProcessing, detectDisplayPrefixes, applyStressShift, applyRhythmicPeakPlacement } from '../stress.js';
 import { correctPosWithLexicon } from './postag.js';
 import { tagNames } from './names.js';
 import { parseFeats } from './feats.js';
@@ -55,6 +55,11 @@ function analyzeSentenceCalliope(sent) {
     // 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);
+    // Rhythm-Rule peak placement for bistable disyllables (contourless
+    // shift-likely words like "into"; fused negatives like "cannot"): the peak
+    // is selected by grid alternation with the neighbouring lexical stresses,
+    // before phrase stress reads the contour.
+    applyRhythmicPeakPlacement(sent.words);
     computePhraseStress(sent);
     computeRelativeStress(sent.words, ius);
     // Surface-order post-processing passes shared with the Clio engine: compound

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

@@ -1 +1 @@
-{"version":3,"file":"relstress.d.ts","sourceRoot":"","sources":["../../src/calliope/relstress.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAyB,MAAM,aAAa,CAAC;AAmkB/E,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAkCrF"}
+{"version":3,"file":"relstress.d.ts","sourceRoot":"","sources":["../../src/calliope/relstress.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAyB,MAAM,aAAa,CAAC;AAq7B/E,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAkCrF"}