tonus 0.7.0 → 0.9.0

package/dist/engines/score/emitters/svg.js

@@ -492,7 +492,9 @@ export function toSvg(rows, chant, options = {}) {
                 `fill="${r.noteColor}">${esc(mark.label ?? "")}</text>`);
             return 0;
         }
-        const p = placeGlyph(mark.glyph, atX, yFor(row.staffPosition, L, r), r, "accidental", "", r.noteScale * 0.62);
+        // The sign sits on the line of the pitch it alters, which is not this
+        // row's own line where the sign was written before the figure it governs.
+        const p = placeGlyph(mark.glyph, atX, yFor(mark.degree ?? row.staffPosition, L, r), r, "accidental", "", r.noteScale * 0.62);
         if (!p)
             return 0;
         body.push(p.svg);
@@ -736,9 +738,9 @@ export function toSvg(rows, chant, options = {}) {
         // GABC's `z` says "start a new line here", and it is not a hint: an
         // editor who set a chant chose where its lines end, and that choice
         // carries a reading of the piece a width cannot infer. tonus SKIPPED the
-        // token at parse — 41 Graduale chants carry one and every break was
-        // being thrown away, which is why the automatic breaks looked arbitrary
-        // against a printed copy.
+        // token at parse, so every break the Graduale chants that carry one had
+        // set was being thrown away, which is why the automatic breaks looked
+        // arbitrary against a printed copy.
         //
         // It wins over the fit test. Where it is absent the layout still decides.
         if (r.width != null && figure[0].lineBreak && prevSyllable !== -1) {
@@ -831,8 +833,9 @@ export function toSvg(rows, chant, options = {}) {
             // Break when the NEXT phrase will not fit, rather than once this one has
             // already overrun. The check was `x > width - padding`, which only fires
             // AFTER the boundary is crossed — and since a system may break only at a
-            // divisio, the overrun was a whole phrase wide. Measured over thirty
-            // graduals, every one of them overran a 900px request, by up to 289px.
+            // divisio, the overrun was a whole phrase wide. Measured over a sweep of
+            // graduals, every one of them overran the requested width, some by a
+            // wide margin.
             // That is what made a render wider than the column it was drawn for, and
             // why "sometimes bigger, sometimes smaller" varied by chant: the overrun
             // depends on where the phrases happen to fall.
@@ -984,9 +987,9 @@ export function toSvg(rows, chant, options = {}) {
         // above. But it cannot be the only one: quadrata's break test used to live
         // entirely inside `if (div && phraseEnds)`, so a system could end nowhere
         // else, and a phrase wider than the line simply ran until its next barline.
-        // Measured over 120 graduals, a QUARTER of quadrata's lines came out under
-        // 75% full against 6% in moderna — which breaks between syllables. That gap
-        // was the asymmetry, not a spacing difference.
+        // Measured over a sweep of graduals, a QUARTER of quadrata's lines came out
+        // barely more than half full, against a handful in moderna — which breaks
+        // between syllables. That gap was the asymmetry, not a spacing difference.
         //
         // The books break mid-phrase freely; the unit is the word, never a syllable
         // mid-word (which would split a lyric) and never mid-neume. So: at a word
@@ -1217,8 +1220,9 @@ export function toSvg(rows, chant, options = {}) {
             // ...and a word carried to the NEXT system takes a hyphen at the line's
             // end, which is what the books set. The gap-centred rule above cannot
             // reach this case — the two syllables have no gap between them, they have
-            // a line break — so the hyphen was simply dropped: measured, 351 splits
-            // across 165 of 200 graduals rendered with nothing joining the halves.
+            // a line break — so the hyphen was simply dropped: measured, the great
+            // majority of a sweep of graduals rendered a split word with nothing
+            // joining the halves.
             // "Sanc" ended a line and "tus" opened the next, reading as two words.
             const thisRight = ly.cx + estLyricW(ly.text) / 2;
             lyricSvgs.push(lyricText(thisRight + r.lyricSize * 0.42, ly.systemY, "-"));
@@ -1324,10 +1328,13 @@ export function toSvg(rows, chant, options = {}) {
         phraseIndex: pl.row.phraseIndex,
         syllableIndex: pl.row.syllableIndex,
         neumeGroup: pl.row.neumeGroup,
-        noteIndex: pl.row.neumeIndex,
+        noteIndex: pl.row.noteIndex,
+        neumeIndex: pl.row.neumeIndex,
         system: pl.system,
         x: Number(pl.x.toFixed(2)),
         y: Number(pl.y.toFixed(2)),
+        inkLeft: Number(pl.inkLeft.toFixed(2)),
+        inkRight: Number(pl.inkRight.toFixed(2)),
         systemY: Number(pl.systemY.toFixed(2)),
     }));
     return { svg, geometry };

package/dist/engines/score/emitters/tracks.js

@@ -513,7 +513,7 @@ const SHARE_FLOOR = 10;
  */
 function cadenceLabel(fam, mode) {
     // NO CATALOGUE FAMILY IS ITSELF A MEASUREMENT. CADENTIAE holds the families
-    // above a floor of fifty corpus occurrences — 122 of them — so a close that
+    // above a floor of fifty corpus occurrences — 110 of them — so a close that
     // fails to join is not unknown, it is RARER than anything the catalogue
     // records. A third of inked cadences land here, and leaving them bare made
     // the rarest closes look like the ones the analysis had nothing to say
@@ -570,7 +570,7 @@ export function buildTonarium(notes, data, cfg) {
     const governing = (p) => {
         let best = null;
         for (const m of data.modulations) {
-            if (m.confidence >= 0.4 && m.startPhrase <= p && p <= m.endPhrase &&
+            if (m.confidence >= CONF_FLOOR && m.startPhrase <= p && p <= m.endPhrase &&
                 (!best || m.confidence > best.confidence))
                 best = m;
         }
@@ -579,6 +579,18 @@ export function buildTonarium(notes, data, cfg) {
         return home != null ? { mode: home, conf: 1, kind: "home" } : null;
     };
     const systems = [...new Set(notes.map((n) => n.system))].sort((a, b) => a - b);
+    // WHERE EACH CADENCE LANDS. `notes` is in tabula order, so the last note
+    // carrying a cadenceRef is that cadence's closing note, and the system it
+    // sits in is the only one that may draw the closing dot and the label. A
+    // figure that wraps is re-inked in every system it crosses — the claim spans
+    // them — but it CLOSES once. Drawn per-system, a wrapped cadence printed its
+    // landing dot on the earlier fragment's last sample (a landing mid-figure)
+    // and repeated its label, so one close read as two.
+    const landingSystem = new Map();
+    for (const n of notes) {
+        if (n.row.cadenceRef != null)
+            landingSystem.set(n.row.cadenceRef, n.system);
+    }
     for (const s of systems) {
         const sysNotes = notes.filter((n) => n.system === s);
         const sysY = sysNotes[0].systemY;
@@ -676,17 +688,22 @@ export function buildTonarium(notes, data, cfg) {
             const samples = (samplesByPhrase.get(fig[0].row.phraseIndex) ?? [])
                 .filter(([px]) => px >= x0 && px <= x1 + 2 * k);
             // Where the cadence LANDS — the closing dot, which the label centres on.
+            // Only the landing system draws it; an earlier fragment re-inks the
+            // ribbon and stops there.
+            const lands = landingSystem.get(ci) === s;
             let dot;
             if (samples.length >= 2) {
                 const d = ribbonPath(samples, vat, vmax, 1);
                 g.push(`<path d="${d}" fill="${INK}" fill-opacity="${(STRATUM.cadence * op).toFixed(2)}"/>`);
-                const [nx, ny] = samples[samples.length - 1];
-                dot = nx;
-                const r = sc(1.8 * k);
-                g.push(closes
-                    ? `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="${INK}" opacity="${op.toFixed(2)}"/>`
-                    : `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="none" stroke="${INK}" ` +
-                        `stroke-width="${sc(0.9 * k)}" opacity="${op.toFixed(2)}"/>`);
+                if (lands) {
+                    const [nx, ny] = samples[samples.length - 1];
+                    dot = nx;
+                    const r = sc(1.8 * k);
+                    g.push(closes
+                        ? `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="${INK}" opacity="${op.toFixed(2)}"/>`
+                        : `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="none" stroke="${INK}" ` +
+                            `stroke-width="${sc(0.9 * k)}" opacity="${op.toFixed(2)}"/>`);
+                }
             }
             // The label: how characteristic this close is OF THIS CHANT'S MODE —
             // the family's in-mode share over its corpus share ("×2.1"). The raw
@@ -696,7 +713,7 @@ export function buildTonarium(notes, data, cfg) {
             // system's edge it clamps to the margin rather than jumping to the
             // figure's other side. A light end-ticked bracket ties it to the span.
             const lab = cadenceLabel(fam, data.mode);
-            if (lab) {
+            if (lab && lands) {
                 // The label sits UNDER THE CLOSING DOT, centred on it. The dot is
                 // where the cadence lands — the one point the measure is about — so
                 // the number belongs beneath it rather than trailing the figure at
@@ -704,6 +721,8 @@ export function buildTonarium(notes, data, cfg) {
                 // figure's span, which the re-inked sparkline above already draws,
                 // and two marks for one extent read as two claims.
                 const estW = lab.length * 5.6 * k; // 9px mono advance, measured
+                // With fewer than two samples in the landing slice no dot was drawn;
+                // the label centres on the figure's closing ink instead of orphaning.
                 const dotX = dot ?? x1;
                 const left = xL;
                 const right = cfg.rightFor(s) - 2 * k;

package/dist/engines/score/ir.js

@@ -1,7 +1,7 @@
 import { toPitch } from "../temper/pitch.js";
 import { toStep } from "../temper/step.js";
 import { selectVowel } from "../chant/syllabify.js";
-import { classifyNeume } from "./neume.js";
+import { classifyNeume, classifyFigures } from "./neume.js";
 function rawToNote(raw, scale) {
     const midi = raw.step;
     // One read of the lyric: the nucleus and the diphthong it belongs to.
@@ -65,14 +65,15 @@ function rawToNote(raw, scale) {
 const SALICUS_PROLONGATION = 1.3;
 function makeSyllable(lyric, notes) {
     const neume = classifyNeume(notes);
+    const neumes = classifyFigures(notes);
     if (neume.type === "salicus" && notes.length >= 2) {
         const summit = notes[notes.length - 1];
         summit.performance.duration *= SALICUS_PROLONGATION;
     }
     const runs = notes[0]?.context.runs;
     return runs
-        ? { lyric, runs, notes, neume, melisma: notes.length }
-        : { lyric, notes, neume, melisma: notes.length };
+        ? { lyric, runs, notes, neume, neumes, melisma: notes.length }
+        : { lyric, notes, neume, neumes, melisma: notes.length };
 }
 function partitionByIctus(annotated) {
     const groups = [];
@@ -217,8 +218,27 @@ function applyCompoundBeats(phrases) {
     for (const phrase of phrases) {
         const annotated = [];
         for (const syl of phrase.syllables) {
+            // A note is named by ITS OWN figure. Annotating every note of a melisma
+            // with the whole syllable's name told the two conventional overrides
+            // below (salicus → arsic, doubly-dotted clivis → thetic) that a
+            // three-figure syllable was one "compound" neume, so a clivis inside it
+            // was invisible to the rule that names it. The salicus is classified at
+            // syllable scope and so survives the split — see `classifyFigures`.
+            const byGroup = new Map();
+            let figure = -1;
+            let cursor = -1;
             for (const note of syl.notes) {
-                annotated.push({ note, neumeType: syl.neume.type });
+                if (note.context.neumeGroup !== figure) {
+                    figure = note.context.neumeGroup;
+                    cursor++;
+                }
+                byGroup.set(note.context.neumeGroup, syl.neumes[cursor]?.type ?? syl.neume.type);
+            }
+            for (const note of syl.notes) {
+                annotated.push({
+                    note,
+                    neumeType: byGroup.get(note.context.neumeGroup) ?? syl.neume.type,
+                });
             }
         }
         phrase.beats = classifyCompoundBeats(annotated);

package/dist/engines/score/{prosody.d.ts → metrics.d.ts}

@@ -48,7 +48,7 @@ export interface Arcus {
      */
     archIndex: number;
 }
-export interface Prosody {
+export interface Metrics {
     noteCount: number;
     syllableCount: number;
     phraseCount: number;
@@ -69,5 +69,5 @@ export interface Prosody {
     cadenceWeight: number;
     cadenceDistribution: CadenceDistribution;
 }
-export declare function computeProsody(phrases: Phrase[]): Prosody;
-//# sourceMappingURL=prosody.d.ts.map
+export declare function computeMetrics(phrases: Phrase[]): Metrics;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/engines/score/{prosody.js → metrics.js}

@@ -1,4 +1,4 @@
-export function computeProsody(phrases) {
+export function computeMetrics(phrases) {
     let phraseCount = 0;
     let noteCount = 0;
     let syllableCount = 0;
@@ -175,4 +175,4 @@ export function computeProsody(phrases) {
         cadenceDistribution: cadDist,
     };
 }
-//# sourceMappingURL=prosody.js.map
+//# sourceMappingURL=metrics.js.map

package/dist/engines/score/neume.d.ts

@@ -1,3 +1,22 @@
 import type { Neume, Note } from "./types.js";
 export declare function classifyNeume(notes: Note[]): Neume;
+/**
+ * The syllable's figures, each classified in its own right.
+ *
+ * GABC marks figure boundaries (`!`, `/`, `//`) and the parser records them as
+ * `context.neumeGroup`, but classification read the whole syllable, so a
+ * three-figure melisma was named once and the name was almost always
+ * "compound" — two of every three compounds the corpus reported. A syllable is
+ * not a neume; it carries neumes.
+ *
+ * THE SALICUS IS CLASSIFIED AT SYLLABLE SCOPE, DELIBERATELY, and the exception
+ * is the point rather than an oversight. Its rule reads the oriscus on the
+ * next-to-last note of an ascent (see `classifyNeume` above), and 41 of the
+ * corpus's 255 salici are written across a figure boundary — the oriscus in
+ * one figure, the summit in the next. Splitting first severed them and the
+ * count fell to 251, which would have narrowed Cardine's definition by
+ * refactoring rather than by ruling. The ascent is the neume; where the
+ * scribe broke the figure is a separate fact.
+ */
+export declare function classifyFigures(notes: Note[]): Neume[];
 //# sourceMappingURL=neume.d.ts.map

package/dist/engines/score/neume.js

@@ -56,4 +56,39 @@ export function classifyNeume(notes) {
     }
     return { type, intervals, hasQuilisma, hasLiquescent, hasStrophicus };
 }
+/**
+ * The syllable's figures, each classified in its own right.
+ *
+ * GABC marks figure boundaries (`!`, `/`, `//`) and the parser records them as
+ * `context.neumeGroup`, but classification read the whole syllable, so a
+ * three-figure melisma was named once and the name was almost always
+ * "compound" — two of every three compounds the corpus reported. A syllable is
+ * not a neume; it carries neumes.
+ *
+ * THE SALICUS IS CLASSIFIED AT SYLLABLE SCOPE, DELIBERATELY, and the exception
+ * is the point rather than an oversight. Its rule reads the oriscus on the
+ * next-to-last note of an ascent (see `classifyNeume` above), and 41 of the
+ * corpus's 255 salici are written across a figure boundary — the oriscus in
+ * one figure, the summit in the next. Splitting first severed them and the
+ * count fell to 251, which would have narrowed Cardine's definition by
+ * refactoring rather than by ruling. The ascent is the neume; where the
+ * scribe broke the figure is a separate fact.
+ */
+export function classifyFigures(notes) {
+    if (notes.length === 0)
+        return [];
+    const whole = classifyNeume(notes);
+    if (whole.type === "salicus")
+        return [whole];
+    const figures = [];
+    let group = -1;
+    for (const note of notes) {
+        if (note.context.neumeGroup !== group) {
+            figures.push([]);
+            group = note.context.neumeGroup;
+        }
+        figures[figures.length - 1].push(note);
+    }
+    return figures.map(classifyNeume);
+}
 //# sourceMappingURL=neume.js.map

package/dist/engines/score/parse.js

@@ -2,8 +2,11 @@ import { buildArticulation } from "./articulation.js";
 import { createLyricDecoder } from "./lyric.js";
 import { detectVowelAccent } from "../chant/syllabify.js";
 // Constants
+// `oct` anchors the staff onto the gamut, which is an absolute frame: guido.ts
+// fixes Γ at midi 43. At oct 3 a chant read an octave below that anchor, so
+// most of the corpus sat at or under the gamut's floor.
 const DEFAULT_OPTIONS = {
-    oct: 3,
+    oct: 4,
     useVowelAccent: true,
 };
 // Per-clef diatonic-step offset. A GABC clef names the staff line it sits on

package/dist/engines/score/phrasing.js

@@ -163,7 +163,7 @@ const CADENCE_VELOCITY_FACTOR = 0.5;
 const CADENCE_DURATION_FACTOR = 0.6;
 // The phrasing-side reading of the divisio (bar-line) hierarchy. This is the
 // same bar hierarchy tabulated canonically in ../../../docs/api/score.md and
-// weighted for analysis by prosody.ts's cadenceWeight ladder — but here the
+// weighted for analysis by metrics.ts's cadenceWeight ladder — but here the
 // weights differ on purpose:
 // this is a *shaping* factor, so the virgula (`) gets 0 (a breath, no cadential
 // stress), where the analytic ladder still counts it. Do not unify the three.

package/dist/engines/score/types.d.ts

@@ -221,7 +221,13 @@ export interface Syllable {
     /** Styled lyric spans; present only when GABC markup styled this syllable. */
     runs?: LyricRun[];
     notes: Note[];
+    /** The syllable read as ONE figure. A syllable carrying several neumes
+     *  classifies as "compound" here; `neumes` names them individually. */
     neume: Neume;
+    /** The syllable's figures, as GABC groups them (`!`, `/`, `//`), each
+     *  classified in its own right. One entry for a syllable of one figure —
+     *  then `neumes[0]` and `neume` agree. */
+    neumes: Neume[];
     /** Notes sung on this syllable — its melisma. 1 = syllabic, >1 = melismatic. */
     melisma: number;
 }

package/dist/engines/temper/data/guido.js

@@ -7,8 +7,10 @@
 // finger to cc before crossing to the middle for dd and ee. Reading it with
 // cc on the middle and dd on the ring makes the line cross three times where
 // the hand turns once. The figure that DRAWS the turn lives in the site
-// (orreliquum-next), and its LOCUS table must agree with the fingers named
-// here; the test that holds the two together lives there beside it. The two b/♮ pairs (58/59, 70/71) share a
+// (orreliquum), and its LOCUS table must agree with the fingers named here;
+// the test that holds the two together lives there beside it.
+//
+// The two b/♮ pairs (58/59, 70/71) share a
 // locus by design — one joint, two readings (fa in molle, mi in durum), the
 // tradition, not a duplication to fix. They are one distinction, named for the
 // two shapes of the letter: b rotundum (the round b) against b quadratum (the

package/dist/engines/temper/neume.d.ts

@@ -2,7 +2,7 @@ import type { Interval } from "./interval.js";
 import type { Pitch, PitchInput } from "./pitch.js";
 import type { Scale } from "./scale.js";
 export type { Interval };
-export type NeumeShape = "punctum" | "pes" | "clivis" | "torculus" | "porrectus" | "scandicus" | "salicus" | "climacus" | "torculus resupinus" | "porrectus flexus" | "scandicus flexus" | "climacus resupinus" | "pes subpunctis" | "compound";
+export type NeumeShape = "punctum" | "pes" | "clivis" | "torculus" | "porrectus" | "scandicus" | "salicus" | "climacus" | "torculus resupinus" | "porrectus flexus" | "scandicus flexus" | "climacus resupinus" | "pes subpunctis" | "distropha" | "tristropha" | "tristropha flexa" | "pressus" | "pressus maior" | "scandicus subpunctis" | "compound";
 export interface Neume {
     pitches: Pitch[];
     intervals: Interval[];

package/dist/engines/temper/neume.js

@@ -9,9 +9,12 @@ export function classifyShape(dirs) {
         return "punctum";
     const up = (d) => d === "up";
     const dn = (d) => d === "down";
+    const un = (d) => d === "unison";
     switch (n) {
         case 1:
-            return up(dirs[0]) ? "pes" : dn(dirs[0]) ? "clivis" : "punctum";
+            // A unison here is two notes on one pitch — a distropha, not a punctum.
+            // Reporting "punctum" said a two-note figure was one note.
+            return up(dirs[0]) ? "pes" : dn(dirs[0]) ? "clivis" : "distropha";
         case 2: {
             const [d0, d1] = dirs;
             if (up(d0) && dn(d1))
@@ -22,6 +25,10 @@ export function classifyShape(dirs) {
                 return "scandicus";
             if (dn(d0) && dn(d1))
                 return "climacus";
+            if (un(d0) && un(d1))
+                return "tristropha";
+            if (un(d0) && dn(d1))
+                return "pressus";
             return "compound";
         }
         case 3: {
@@ -36,12 +43,26 @@ export function classifyShape(dirs) {
                 return "climacus resupinus";
             if (up(d0) && dn(d1) && dn(d2))
                 return "pes subpunctis";
+            if (un(d0) && un(d1) && dn(d2))
+                return "tristropha flexa";
+            if (dn(d0) && un(d1) && dn(d2))
+                return "pressus maior";
             return "compound";
         }
-        default:
-            if (up(dirs[0]) && dirs.slice(1).every((d) => dn(d)))
+        default: {
+            // The long forms: a head, then an unbroken descent. Only the head
+            // distinguishes them, and the descent must be total — a figure that
+            // turns again is a compound melisma, which at this length most are.
+            if (up(dirs[0]) && dirs.slice(1).every(dn))
                 return "pes subpunctis";
+            if (up(dirs[0]) && up(dirs[1]) && dirs.slice(2).every(dn)) {
+                return "scandicus subpunctis";
+            }
+            if (dirs.slice(0, -1).every(un) && dn(dirs[dirs.length - 1])) {
+                return "tristropha flexa";
+            }
             return "compound";
+        }
     }
 }
 export function buildNeume(inputs, scala) {

package/dist/index.d.ts

@@ -17,7 +17,7 @@ import type { Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, Accentus
 import type { InscriptioOpts, Inscriptio, NoteGeometry, FontSpec, FontSlot, FontEmbed } from "./engines/score/inscriptio.js";
 import type { ChantTabulaRow } from "./engines/score/tabula.js";
 import type { Imprint, Attractor, VowelAttractor, ModalAffinity } from "./engines/imprint.js";
-import type { Prosody, RhythmicProfile, NoteRange, CadenceDistribution } from "./engines/score/prosody.js";
+import type { Metrics, RhythmicProfile, NoteRange, CadenceDistribution } from "./engines/score/metrics.js";
 import type { Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author } from "./engines/harmonia/api.js";
 import type { HarmonyTabulaRow } from "./engines/harmonia/tabula.js";
 import type { PlanetVowel } from "./engines/harmonia/data/vowels.js";
@@ -58,5 +58,5 @@ export { CADENTIAE, CADENTIAE_POPULATION } from "./data/cadentiae.js";
 export type { CadentiaFamilia } from "./data/cadentiae.js";
 export { ZODIACA } from "./engines/harmonia/data/zodiac.js";
 export { CENSUS_GROUPS, CENSUS_ORDER } from "./data/census.js";
-export type { Feast, FeastQuery, Pascha, Season, Grade, Chant, CantusQuery, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Corpus, GenusCount, ModeCount, SharedCount, CorpusLedger, CorpusFullCount, CorpusQuery, Census, CensusQuery, CensusBy, CensusGroup, CensusGroupProfile, CensusNeighbor, Temperamentum, TemperamentumInput, TemperamentumOpts, Tuning, Pitch, PitchInput, Step, Neume, NeumeShape, Interval, ModeData, CadenceFigure, Modus, TunedNote, GamutOptions, Tonus, TonusOpts, Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, Cadence, CadenceTarget, CadenceApproach, Modulation, InscriptioOpts, Inscriptio, NoteGeometry, FontSpec, FontSlot, FontEmbed, ChantTabulaRow, Note, Performance, Phrase, Syllable, LyricRun, RestEvent, ParseError, ArsisThesis, RhythmicType, CompoundBeat, VoicedPitch, Cosmos, CosmosQuery, Body, BodyName, Aspect, Imprint, Attractor, VowelAttractor, ModalAffinity, Prosody, RhythmicProfile, NoteRange, CadenceDistribution, Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author, HarmonyTabulaRow, PlanetVowel, };
+export type { Feast, FeastQuery, Pascha, Season, Grade, Chant, CantusQuery, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Corpus, GenusCount, ModeCount, SharedCount, CorpusLedger, CorpusFullCount, CorpusQuery, Census, CensusQuery, CensusBy, CensusGroup, CensusGroupProfile, CensusNeighbor, Temperamentum, TemperamentumInput, TemperamentumOpts, Tuning, Pitch, PitchInput, Step, Neume, NeumeShape, Interval, ModeData, CadenceFigure, Modus, TunedNote, GamutOptions, Tonus, TonusOpts, Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, Cadence, CadenceTarget, CadenceApproach, Modulation, InscriptioOpts, Inscriptio, NoteGeometry, FontSpec, FontSlot, FontEmbed, ChantTabulaRow, Note, Performance, Phrase, Syllable, LyricRun, RestEvent, ParseError, ArsisThesis, RhythmicType, CompoundBeat, VoicedPitch, Cosmos, CosmosQuery, Body, BodyName, Aspect, Imprint, Attractor, VowelAttractor, ModalAffinity, Metrics, RhythmicProfile, NoteRange, CadenceDistribution, Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author, HarmonyTabulaRow, PlanetVowel, };
 //# sourceMappingURL=index.d.ts.map

package/docs/api/chant.md

@@ -95,9 +95,9 @@ tonus.corpus();
 ```
 
 **`count` is the number of chants** — the one to quote. `listings` is how long
-the shelf is, and `listings - count` is 580 extra rows, over the 683 chants
-printed in more than one book. The breakdowns describe the same population
-`count` does, so `genera` and `modes` sum to it.
+the shelf is: a melody printed in several books is stored once and listed under
+each, so the shelf runs longer than the repertory. The breakdowns describe the
+same population `count` does, so `genera` and `modes` sum to it.
 
 ```js
 tonus.corpus("am");
@@ -313,9 +313,9 @@ for that chant. The two prefixes in the shipped corpus are `gregobase:` (1,717)
 and `nocturnale:` (470), the latter carrying the Nocturnale's own alphanumeric
 keys rather than numbers.
 
-Within tonus an id is exactly one chant. A melody printed in several books —
-683 of them are — is stored once, under the record `cantus({ id })` returns, so
-`id` is a stable key to a chant rather than to a printing.
+Within tonus an id is exactly one chant. A melody printed in several books is
+stored once, under the record `cantus({ id })` returns, so `id` is a stable key
+to a chant rather than to a printing.
 
 ## The repertoire as of a date — the era view
 
@@ -601,7 +601,7 @@ phrase punctuation ([score.md](score.md#the-tabula)).
 
 Because the encoding is textual, lyrics and neumes stay aligned syllable
 by syllable, which is what lets `tonus.notatio` reconstruct syllables,
-neumes, and prosody without images.
+neumes, and metrics without images.
 
 ### The Mass: proper and ordinary
 

package/docs/api/index.md

@@ -4,7 +4,7 @@ The technical center of tonus: the full public API, the conventions every method
 obeys, and the error contract. The API is **fourteen methods on the `tonus`
 namespace**, no sub-namespaces.
 
-**[Interactive demo →](https://jeffreypierce.github.io/tonus/)**
+**[Orreliquum — the library at work →](https://jeffreypierce.github.io/orreliquum/)**
 
 ```js
 import tonus from "tonus";
@@ -173,7 +173,7 @@ the list resolve their pitches through the ones before.
 - [The tabula](score.md#the-tabula)
 - [Rendering — `inscriptio`](score.md#rendering) · [theme](score.md#theme--faces-and-ink) · [The analysis tracks](score.md#the-analysis-tracks)
 - [The imprint](score.md#the-imprint)
-- [Prosody](score.md#prosody)
+- [Metrics](score.md#metrics)
 - [Cadences](score.md#cadences) · [One spine, two annotations](score.md#one-spine-two-annotations)
 - [Modulations](score.md#modulations)
 - [Theory & Context](score.md#theory--context) · [Sources](score.md#sources)