tonus 0.9.0 → 0.9.1

package/CHANGELOG.md

@@ -2,6 +2,68 @@
 
 All notable changes to tonus. Newest first.
 
+## 0.9.1 — 2026-08-24
+
+Moderna reads the pitch it was given: the whole page had been sitting a sixth
+too high, and a transposed chant said nothing about its own accidentals.
+
+### Fixed
+
+- **Moderna drew every note a sixth above where it belonged.** `writtenY`
+  measured the note against a reference term that had not been normalised the
+  same way (`4 * 7` against a note term carrying `+2`), so sounding E4 computed
+  as 14 staff steps instead of 0. Every note of every moderna score sat above
+  the top line. The port was faithful — the same expression is in the locked
+  reference generator, which was fed pitches an octave below today's corpus, so
+  two errors cancelled; when the corpus moved to true octaves only one of them
+  moved. The clef's octave lift is now stated once, explicitly.
+- **A transposed chromatic rendered as a silent wrong pitch.** `temperamentum`'s
+  `transpose` moves what a chant sounds, and moderna reads sounding pitch — but
+  the accidental was parsed and discarded, so `Ab3` and `A3` landed on one slot
+  with no sign drawn. The page read a semitone off with nothing to say so.
+  Spelling now follows `spn`: flats stay flats, sharps stay sharps. Signs
+  written in the GABC are unaffected — `computeAccidentals` remains
+  authoritative wherever it has an opinion, keyed on the degree a sign alters
+  rather than the row that carries it.
+- **Moderna had no ledger lines at all.** A note outside the five rendered as a
+  head floating in blank space. One line per staff line the note has passed,
+  drawn behind the head: the spaces immediately outside (steps 9 and −1) get
+  none, and a line-note and the space above it share one.
+- **`midiToGabc` threw on every B-flat** — the one accidental chant sings, and
+  the whole reason `parse.ts` carries a flat state machine. It now spells it
+  `ix`, and `gabcToMidi` reads that back, so the two stay inverses. Other
+  chromatic pitch classes still throw. Verified over 222 round-trips.
+- **The GABC clef tables disagreed about which clefs exist.** `temper/gabc.ts`
+  knew six (`c1`–`c4`, `f3`, `f4`) while `parse.ts` accepted sixteen, so a
+  `cb2` the parser reads happily raised "Unknown clef". `CLEFS` is now derived
+  rather than hand-listed; all six original entries are reproduced exactly.
+
+### Changed
+
+- **A low moderna chant is written an octave up.** One clef throughout — what
+  floats is the written octave, the move the hand already makes when it lifts a
+  chant onto the gamut's fingers. Chant sounds below this staff (corpus median
+  50–62 against a window of 52–65), and transposing down pushes it further: at
+  −4 an unlifted score put 43.6% of all notes under the bottom line, now 9.8%.
+  Untransposed moderna output moves for most chants as a result, always toward
+  the staff (7.8% off-staff to 5.8%). Whole octaves only, and one lift for the
+  whole chant — a page that changed register partway would read as two pieces.
+  The limit is honest: an ambitus straddling the window cannot be aligned by
+  any multiple of 12, and 59 of 200 measured chants are wider than the staff.
+  `notatio`'s `spn` remains the authority on what actually sounds.
+- **Quadrata is untouched by all of this**, by construction: it draws from
+  staff position, which transposition does not move. Verified byte-identical.
+
+### Packaging
+
+- `.npmignore` removed — it contradicted the `files` allowlist, and two
+  mechanisms deciding what ships is one more than can be reasoned about.
+  Measured before and after: the tarball is byte-identical at 216 files.
+- `"sideEffects": false` declared, and verified true — nothing in `dist/` runs
+  at module scope and no data file is read at import time.
+- The description no longer claims "and performance"; the voice lives in
+  tonus-sonus.
+
 ## 0.9.0 — 2026-08-19
 
 The tracks stop promising a contract they never kept, and the geometry says

package/README.md

@@ -8,7 +8,7 @@ belong to which day and returns analysis and notation, and calculates the
 _music of the spheres_ proposed by Pythagoras, Boethius, and more as real
 intervals.
 
-**[Orreliquum — the library at work →](https://jeffreypierce.github.io/orreliquum/)**
+**[Interactive demo](https://orreliquum.com/)**
 
 Everything is computed locally and deterministically: the same question always
 returns the same answer, from data that ships inside the package, with no network
@@ -72,8 +72,8 @@ its final, dominant, ambitus, and ethos, with its psalm tones.
 **The calendar** is Tridentine, resolved against Easter by
 the Julian or the Gregorian computus.
 
-**The repertoire** is 2,187 chants across ten books — nine Solesmes editions and
-the _Nocturnale Romanum_ night office — in
+**The repertoire** is 2,187 chants across ten books, nine Solesmes editions and
+the _Nocturnale Romanum_ night office in
 [GABC](https://gregorio-project.github.io/) notation: Mass propers, the Kyriale,
 the Office hours, the psalter, and the Matins nocturns.
 

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

@@ -30,7 +30,53 @@ const G = {
     noteheadBlack: "E0A4",
     augmentationDot: "E1E7",
     quilisma: "EA20", // medRenQuilismaCMN
+    accidentalFlat: "E260",
+    accidentalNatural: "E261",
+    accidentalSharp: "E262",
 };
+// The staff holds nine written diatonic slots — bottom line E4 to top line F5
+// — which under the transposing gClef8vb sounds E3–F4, MIDI 52–65.
+const STAFF_LO = 52;
+const STAFF_HI = 65;
+/**
+ * How many octaves to lift the written notes so the chant sits on the staff.
+ *
+ * ONE clef, always: moderna draws a gClef8vb and nothing else. What floats is
+ * the written octave, the same move the orreliquum hand already makes when it
+ * lifts a chant by whole octaves onto the gamut's fingers.
+ *
+ * It earns its place going DOWN, which is the direction chant is transposed:
+ * the corpus already sounds below this staff (median 50–62 against 52–65), so
+ * a transposition of −4 puts 43.6% of all notes below the bottom line, some
+ * four ledger lines deep. Choosing the octave takes that to 15.8%. Upward it
+ * changes little, because chant does not sit high to begin with.
+ *
+ * Whole octaves only, and the same lift for the whole chant: shifting by
+ * anything else would respell the music, and shifting per-phrase would make
+ * one page read in two registers.
+ *
+ * The honest limit: an 8vb clef already says "sounds an octave lower", so a
+ * further lift understates the true pitch with nothing on the page confessing
+ * it. That is the accepted cost of keeping one clef; `notatio`'s `spn` remains
+ * the authority on what actually sounds.
+ */
+function pickOctaveLift(rows) {
+    const midis = rows.map((r) => r.midi).filter((m) => typeof m === "number");
+    if (midis.length === 0)
+        return 0;
+    let best = 0;
+    let fewest = Infinity;
+    // Nearest first, so a tie keeps the chant where it was written.
+    for (const lift of [0, 1, -1]) {
+        const shifted = lift * 12;
+        const off = midis.filter((m) => m + shifted < STAFF_LO || m + shifted > STAFF_HI).length;
+        if (off < fewest) {
+            fewest = off;
+            best = lift;
+        }
+    }
+    return best;
+}
 // ── geometry, as a function of the staff ──────────────────────────────────
 //
 // THE CONTRACT (ruled 2026-08-04): `staffHeight` is the height of the STAFF
@@ -114,14 +160,42 @@ export function metrics(staffHeight) {
 }
 const LETTERS = { C: 0, D: 1, E: 2, F: 3, G: 4, A: 5, B: 6 };
 const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-/** Written y for a scientific pitch name on the treble-8 staff (bottom line E4). */
-function writtenY(spn, systemY, gm) {
-    const m = /([A-G])[#b]?(-?\d)/.exec(spn);
+/**
+ * Written y for a scientific pitch name on the treble-8 staff (bottom line
+ * written E4, sounding E3).
+ *
+ * `spn` is a SOUNDING pitch; the gClef8vb this species draws transposes, so the
+ * note is WRITTEN an octave above where it sounds. Hence the `+ 1` below:
+ * sounding G3 is written G4 and sits on the second line, where mode VII's final
+ * belongs. The reference generator folded that lift into a short reference term
+ * (`4 * 7` against a note term carrying `+2`) because it was fed pitches an
+ * octave below today's corpus; the two errors cancelled. Stated once, plainly,
+ * both halves now agree — and the chant lands on the staff instead of a sixth
+ * above it.
+ *
+ * `lift` is the further whole-octave shift `pickOctaveLift` chose for this
+ * chant, so a low or downward-transposed piece is written where it can be read
+ * rather than on a stack of ledger lines.
+ *
+ * The ACCIDENTAL is read but never changes the slot: a flat and its natural
+ * share one line (B-flat sits on the B line), which is why the letter alone
+ * fixes `steps`. It is returned separately so the caller can draw the sign.
+ * Discarding it was a silent wrong pitch — under transposition `Ab3` and `A3`
+ * landed on the same slot with nothing to tell them apart.
+ */
+function writtenY(spn, systemY, gm, lift = 0) {
+    const m = /([A-G])([#b]?)(-?\d)/.exec(spn);
     if (!m)
-        return { y: systemY + gm.MTOP + 4 * gm.MSP, steps: 0 };
-    const di = (Number(m[2]) + 2) * 7 + LETTERS[m[1]];
-    const steps = di - (4 * 7 + LETTERS["E"]); // relative to bottom line E4
-    return { y: systemY + gm.MTOP + 4 * gm.MSP - steps * (gm.MSP / 2), steps };
+        return { y: systemY + gm.MTOP + 4 * gm.MSP, steps: 0, accidental: 0 };
+    const accidental = m[2] === "b" ? -1 : m[2] === "#" ? 1 : 0;
+    const written = Number(m[3]) + 1 + lift; // the 8vb clef writes an octave up
+    const di = (written + 2) * 7 + LETTERS[m[1]];
+    const steps = di - ((4 + 2) * 7 + LETTERS["E"]); // relative to bottom line E4
+    return {
+        y: systemY + gm.MTOP + 4 * gm.MSP - steps * (gm.MSP / 2),
+        steps,
+        accidental,
+    };
 }
 // Moderna's ink, as a CSS custom property with the house default as fallback —
 // the same three properties quadrata emits, so one stylesheet themes both
@@ -229,6 +303,35 @@ function accidentalWidth(code, gm) {
 function accidentalMark(x, y, code, gm) {
     return classedGlyph("accidental", code, x - gm.NH_W / 2 - accidentalWidth(code, gm), y, (gm.SCALE * 0.62));
 }
+/**
+ * The short lines that carry a notehead outside the five, as quadrata's
+ * `ledger` does: one per LINE position the note has passed, not one per step.
+ *
+ * `steps` counts diatonic slots up from the bottom line, so the staff occupies
+ * 0–8 and its lines are the even positions. A note at 10 gets a ledger at 10;
+ * at 11 (a space above that) it still gets only the one at 10. Below, the same
+ * downward: -1 draws nothing, -2 draws at -2.
+ *
+ * Rendered wider than the head by a quarter of its width on each side, the
+ * proportion quadrata uses, so the line reads as staff rather than as a tick.
+ */
+function ledgerLines(steps, mx, systemY, gm) {
+    if (steps >= 0 && steps <= 8)
+        return [];
+    const half = gm.NH_W / 2 + gm.NH_W * 0.25;
+    const out = [];
+    const emit = (lp) => {
+        const ly = systemY + gm.MTOP + 4 * gm.MSP - lp * (gm.MSP / 2);
+        out.push(`<line class="ledger" x1="${(mx - half).toFixed(2)}" y1="${ly.toFixed(2)}" ` +
+            `x2="${(mx + half).toFixed(2)}" y2="${ly.toFixed(2)}" ` +
+            `stroke="${INK}" stroke-width="0.7"/>`);
+    };
+    for (let lp = 10; lp <= steps; lp += 2)
+        emit(lp);
+    for (let lp = -2; lp >= steps; lp -= 2)
+        emit(lp);
+    return out;
+}
 const DIV_KIND = {
     "`": "tick", ",": "tick", ";": "half", ":": "full", "::": "double",
 };
@@ -290,6 +393,17 @@ export function toModerna(rows, chant, options = {}) {
     const markByRow = new Map();
     rows.forEach((row, i) => { const m = marks[i]; if (m)
         markByRow.set(row, m); });
+    // One lift for the whole chant, chosen before any note is placed — a page
+    // that changed register partway would read as two pieces.
+    const lift = pickOctaveLift(rows);
+    // The pitches an engine-computed sign already accounts for. `degreeSpn` is
+    // the mark's own statement of which pitch it alters, so this is the engine
+    // speaking rather than a second guess at its scoping rules — the spelled
+    // path below stays silent wherever a written sign has already spoken.
+    const alteredSpns = new Set();
+    for (const m of marks)
+        if (m?.kind === "glyph" && m.degreeSpn)
+            alteredSpns.add(m.degreeSpn);
     // ── Front matter ── The same official display quadrata sets (title centered
     // over the score, the genus/mode mark stacked at the left margin — the
     // `annotation: "auto"` params), honoured here so both species open a piece
@@ -316,6 +430,10 @@ export function toModerna(rows, chant, options = {}) {
     }
     const body = [];
     const slurs = [];
+    // Ledger lines, collected as the notes are placed but emitted with the STAFF
+    // — they are staff, continuing it for one note, and must lie behind the
+    // notehead rather than cross it. `staff` is joined before `body` below.
+    const ledgers = [];
     const lyricSvgs = [];
     const lyricRuns = [];
     const placements = [];
@@ -415,25 +533,45 @@ export function toModerna(rows, chant, options = {}) {
             const mk = markByRow.get(r);
             if (mk?.kind === "glyph")
                 nx += accidentalWidth(mk.glyph, gm); // room for the accidental
-            const { y, steps } = writtenY(r.spn, systemY, gm);
-            notePos.push({ mx: nx, my: y, steps });
+            const { y, steps, accidental } = writtenY(r.spn, systemY, gm, lift);
+            // A sign the SPELLING demands. `computeAccidentals` speaks for the marks
+            // written in the GABC (`accidentalSource: "explicit"`); a transposed
+            // score carries its accidentals in `spn` alone, where nothing was ever
+            // written, so those would otherwise go undrawn and the note would read a
+            // semitone off with no sign to say so.
+            //
+            // The guard is `alteredSpns`, NOT this row's own `mk`. A written sign is
+            // carried by the note BEFORE the one it governs — on gregobase:1180 the
+            // three signs sit on rows 27/39/62 and their B-flats on 31/40/66, wholly
+            // disjoint — so asking "does this row carry a mark?" says no on the very
+            // note the sign already covers, and drew a second glyph for each.
+            const spelled = accidental !== 0 && !alteredSpns.has(r.spn)
+                ? (accidental === -1 ? G.accidentalFlat : G.accidentalSharp)
+                : null;
+            if (spelled)
+                nx += accidentalWidth(spelled, gm);
+            notePos.push({ mx: nx, my: y, steps, spelled });
             nx += gm.ADV + 4.6 * r.mora;
         }
         const notesW = nx - x - gm.ADV + gm.NH_W / 2 + 2;
         const sylW = Math.max(notesW, textW(lyr));
         // Draw notes.
         srows.forEach((r, i) => {
-            const { mx, my, steps } = notePos[i];
+            const { mx, my, steps, spelled } = notePos[i];
             const onLine = steps % 2 === 0;
+            ledgers.push(...ledgerLines(steps, mx, systemY, gm));
             if (r.quilisma)
                 body.push(quilismaMark(mx, my, gm));
             const mk = markByRow.get(r);
             if (mk?.kind === "glyph") {
                 // Vertically the sign belongs to the pitch it alters, not to the note
                 // it was written before; horizontally it stays at this note's column.
-                const ay = mk.degreeSpn ? writtenY(mk.degreeSpn, systemY, gm).y : my;
+                const ay = mk.degreeSpn ? writtenY(mk.degreeSpn, systemY, gm, lift).y : my;
                 body.push(accidentalMark(mx, ay, mk.glyph, gm));
             }
+            // A spelled accidental alters THIS note, so it sits on this note's line.
+            else if (spelled)
+                body.push(accidentalMark(mx, my, spelled, gm));
             else if (mk?.kind === "cents") {
                 // Cents labels float in a band above the staff (not glued to the
                 // head) — an analytic overlay, not an engraving mark.
@@ -599,7 +737,7 @@ export function toModerna(rows, chant, options = {}) {
         `width="${W}" height="${height}" class="tonus-chant moderna">${svgTitle}` +
         lyricEmbed +
         header.join("") +
-        staff.join("") + clefSvgs.join("") + body.join("") + slurs.join("") + lyricSvgs.join("") +
+        staff.join("") + ledgers.join("") + clefSvgs.join("") + body.join("") + slurs.join("") + lyricSvgs.join("") +
         `</svg>`;
     const geometry = placements.map((pl) => ({
         phraseIndex: pl.row.phraseIndex,

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

@@ -1,3 +1,15 @@
+/**
+ * The GABC letter for a MIDI pitch under `clef` — with `x` appended when the
+ * pitch is a B-flat (`jx`, the flat sign then the note).
+ *
+ * B-flat is the ONE accidental chant sings — the b molle of the medieval gamut,
+ * the whole reason `parse.ts` carries a flat state machine and the `b` clefs
+ * exist. This function used to throw "is not diatonic" on it, which made the
+ * apparent inverse of `gabcToMidi` unable to spell a pitch the parser reads on
+ * every other page. Every other chromatic pitch class still throws: those are
+ * outside the gamut, and inventing a spelling for them would be a worse answer
+ * than refusing.
+ */
 export declare function midiToGabc(midi: number, clef?: string): string;
 export declare function gabcToMidi(letter: string, clef?: string): number;
 export declare function pcToGabc(pc: number, clef?: string, oct?: number): string;

package/dist/engines/temper/gabc.js

@@ -18,26 +18,52 @@ const LETTERS = "abcdefghijklm";
 // A higher c-clef (c4 vs c1) moves "do" up the staff, so the same letter reads a
 // lower pitch — hence doIdx climbs 3→5→7→9 across c1→c4. The f-clefs anchor on
 // fa (MIDI 53) and are used for lower-tessitura chant.
-const CLEFS = {
-    c1: { doMidi: 60, doIdx: 3 },
-    c2: { doMidi: 60, doIdx: 5 },
-    c3: { doMidi: 60, doIdx: 7 },
-    c4: { doMidi: 60, doIdx: 9 },
-    // f-clefs anchor fa on the named line. Staff lines (bottom→top) sit at
-    // letters d/f/h/j (per the Gregorio spec: 2-line staff = a–i, 3-line = a–k,
-    // 4-line = a–m, pinning the lines at slots 3/5/7/9), so f3 puts fa at 'h'
-    // (7) and f4 at 'j' (9). Previous values (5 and 3) were off by a third and
-    // read every f-clef chant at the wrong staff position.
-    f3: { doMidi: 53, doIdx: 7 },
-    f4: { doMidi: 53, doIdx: 9 },
-};
+// The staff-line slots the clefs anchor to, low to high: letters d/f/h/j per
+// the Gregorio spec (2-line staff = a–i, 3-line = a–k, 4-line = a–m).
+const LINE_SLOTS = [3, 5, 7, 9];
+// Every clef GABC can declare, built from the same two rules rather than listed
+// by hand: a c-clef puts "do" (MIDI 60) on its named line, an f-clef puts "fa"
+// (MIDI 53) there. cN/fN for N in 1–4, plus the `b` variants (cbN/fbN) that
+// additionally declare a B-flat key signature.
+//
+// This table used to hold six entries — c1–c4, f3, f4 — while `parse.ts`'s
+// CLEF_OFFSETS held all sixteen. Two tables disagreeing about what a clef is,
+// with the smaller one throwing "Unknown clef" on inputs the parser accepts
+// happily. Deriving them removes the chance of a third disagreement.
+const CLEFS = {};
+for (let n = 1; n <= 4; n++) {
+    const doIdx = LINE_SLOTS[n - 1];
+    // An f-clef names fa's line, and fa is the 4th diatonic step (index 3), so
+    // "do" sits three slots below the named line — which is what doMidi 53
+    // (the F below middle C) is measured from.
+    CLEFS[`c${n}`] = { doMidi: 60, doIdx };
+    CLEFS[`cb${n}`] = { doMidi: 60, doIdx };
+    CLEFS[`f${n}`] = { doMidi: 53, doIdx };
+    CLEFS[`fb${n}`] = { doMidi: 53, doIdx };
+}
+/**
+ * The GABC letter for a MIDI pitch under `clef` — with `x` appended when the
+ * pitch is a B-flat (`jx`, the flat sign then the note).
+ *
+ * B-flat is the ONE accidental chant sings — the b molle of the medieval gamut,
+ * the whole reason `parse.ts` carries a flat state machine and the `b` clefs
+ * exist. This function used to throw "is not diatonic" on it, which made the
+ * apparent inverse of `gabcToMidi` unable to spell a pitch the parser reads on
+ * every other page. Every other chromatic pitch class still throws: those are
+ * outside the gamut, and inventing a spelling for them would be a worse answer
+ * than refusing.
+ */
 export function midiToGabc(midi, clef = "c4") {
     const def = CLEFS[clef];
     if (!def)
         throw new Error(`Unknown clef: ${clef}`);
-    const octave = Math.floor(midi / 12) - 1;
     const pc = midi % 12;
-    const diatIdx = DIATONIC.indexOf(pc);
+    // A flat is spelled on the staff slot of the natural ABOVE it: B-flat takes
+    // B's line with an `x`. Resolve to that natural, then mark the result.
+    const flat = pc === 10;
+    const natural = flat ? midi + 1 : midi;
+    const octave = Math.floor(natural / 12) - 1;
+    const diatIdx = DIATONIC.indexOf(natural % 12);
     if (diatIdx === -1)
         throw new Error(`MIDI note ${midi} (pc ${pc}) is not diatonic`);
     const doOctave = Math.floor(def.doMidi / 12) - 1;
@@ -45,13 +71,19 @@ export function midiToGabc(midi, clef = "c4") {
     const letter = LETTERS[staffPos];
     if (!letter)
         throw new Error(`MIDI ${midi} out of GABC range for clef ${clef}`);
-    return letter;
+    return flat ? `${letter}x` : letter;
 }
 export function gabcToMidi(letter, clef = "c4") {
     const def = CLEFS[clef];
     if (!def)
         throw new Error(`Unknown clef: ${clef}`);
-    const staffPos = LETTERS.indexOf(letter.toLowerCase());
+    // Accept the `x` that `midiToGabc` emits, so the two stay inverses. A flat
+    // lowers the natural it marks by a semitone; only B carries one in the gamut,
+    // but the arithmetic is written once for whatever letter arrives.
+    const raw = letter.toLowerCase();
+    const flat = raw.endsWith("x");
+    const bare = flat ? raw.slice(0, -1) : raw;
+    const staffPos = LETTERS.indexOf(bare);
     if (staffPos === -1)
         throw new Error(`Unknown GABC letter: ${letter}`);
     // Diatonic steps from "do", split into whole octaves (÷7) and the step within
@@ -61,7 +93,8 @@ export function gabcToMidi(letter, clef = "c4") {
     const octOffset = Math.floor(stepsFromDo / 7);
     const diatStep = ((stepsFromDo % 7) + 7) % 7;
     const doOctave = Math.floor(def.doMidi / 12) - 1;
-    return (doOctave + octOffset + 1) * 12 + DIATONIC[diatStep];
+    const natural = (doOctave + octOffset + 1) * 12 + DIATONIC[diatStep];
+    return flat ? natural - 1 : natural;
 }
 export function pcToGabc(pc, clef = "c4", oct = 0) {
     const def = CLEFS[clef];

package/docs/api/calendar.md

@@ -108,7 +108,7 @@ The feast returned **carries the view** (`feast.before`), and every chant
 verb reads it back: `proprium`, `ordinarium`, and `officium`
 serve only chants attested by the same year, without being told the year
 twice. One `before` at the calendar door views the whole day. The chant side
-— what "attested" means, and what a slot the view excludes does — is in
+(what "attested" means, and what a slot the view excludes does) is in
 [chant.md](chant.md#the-repertoire-as-of-a-date--the-era-view).
 
 ```ts
@@ -142,12 +142,12 @@ interface Feast {
 }
 ```
 
-The `masses` list is derived from the Kyriale's own printed rubric — one
+The `masses` list is derived from the Kyriale's own printed rubric, one
 category per mass, by RANK: "In Paschal Time", "For feasts of the I class",
 "For Sundays throughout the Year", "For ferias". A day resolves to exactly
 one rubric (a BVM feast is "of the Blessed Virgin" even in Paschaltide),
 and the masses carrying that rubric are the masses it may sing, in the
-book's own numbering — where a rubric names several (II class 1–5), that
+book's own numbering. Where a rubric names several (II class 1–5), that
 numbering is the book's invitation to choose, and `ordinarium` rotates
 among them by year. The book's per-mass nicknames (_Orbis factor_ for
 Sundays, and so on) record customary use, which disagrees with the rubric for 9
@@ -211,7 +211,7 @@ derived from the date; overflow entries, such as the Epiphany weeks
 resumed before Septuagesima, take the season of the day they fall on.
 
 Season drives real liturgy in the ordinary: in the penitential seasons
-(`adv`, `quadp`, `quad`) the Gloria is omitted, and the Ite with it — the
+(`adv`, `quadp`, `quad`) the Gloria is omitted, and the Ite with it. The
 Benedicamus dismissal appears only where the selected mass carries a
 setting ([chant.md](chant.md#the-ordinary--ordinarium)).
 

package/docs/api/census.md

@@ -20,7 +20,7 @@ is, where it is unusual, and what it is near.
 tonus.census({ id: "gregobase:1210" });
 ```
 
-Everything comes back in one call — profile, balance, neighbors:
+Everything comes back in one call: profile, balance, neighbors.
 
 ```js
 {
@@ -56,7 +56,7 @@ interface CensusQuery {
 }
 ```
 
-The census covers the **2,187 chants tonus ships** — the same population
+The census covers the **2,187 chants tonus ships**, the same population
 `cantus({ id })` addresses, one block per chant. An id with no block throws
 rather than returning an empty answer, because a silent nothing reads as "this
 chant is unlike everything," which is a different claim.
@@ -78,24 +78,24 @@ what they describe:
 | `textual`       |      7 | vowel distribution by sung duration, accent rate, melisma mean                    |
 
 Four more fields ride in the block and are **not** similarity dimensions:
-`flags` (a bitfield), `attest` (dating — that is what `before` reads),
+`flags` (a bitfield), `attest` (dating, which is what `before` reads),
 `extras`, and `reserve`. `by` will not accept them.
 
 ## How the measurement works
 
-Every number in a block reads off a single `notatio()` parse — the same parse
-`score` gives you — so the census can never disagree with the library about
+Every number in a block reads off a single `notatio()` parse (the same parse
+`score` gives you), so the census can never disagree with the library about
 what a chant is.
 
 Each float is a named measurement, not a learned one: time spent on the
 subfinal, how often a rising second follows a falling third. When the census
 calls two chants near, the profile says in what respect.
 
-Most groups are normalized to sum to one, so a group holds a distribution —
-where the melody's time goes, not how much of it there is; length is not a
+Most groups are normalized to sum to one, so a group holds a distribution:
+where the melody's time goes, not how much of it there is. Length is not a
 similarity. The trigram and cadence groups count against dictionaries mined
-from the corpus itself — its commonest motifs, its commonest closing gestures,
-one bucket for the rest — so the corpus supplies the vocabulary and the chant
+from the corpus itself (its commonest motifs, its commonest closing gestures,
+one bucket for the rest), so the corpus supplies the vocabulary and the chant
 supplies the usage.
 
 The reference is the mean block over all 2,187 chants, group by group. Because
@@ -105,15 +105,15 @@ divided by their count, are the season's mean profile in the same 221 slots.
 ## Distance is cosine per field group
 
 **This is a contract, not an implementation note.** The census answers about
-one chant at a time; grouping — "all Communions," "this season," "this
-manuscript" — is yours to do. The moment you pool blocks yourself you are
+one chant at a time. Grouping ("all Communions," "this season," "this
+manuscript") is yours to do. The moment you pool blocks yourself you are
 computing a distance, and if you compute it differently from the rule below
 your numbers will not agree with `census()`'s. Nothing will error.
 
 The rule, in three lines:
 
 1. Cosine **per field group**, never over the flat 221.
-2. `by: "all"` is the **equal-weight mean** of the per-group cosines — every
+2. `by: "all"` is the **equal-weight mean** of the per-group cosines: every
    dimension one vote, no tunable weights.
 3. Ties break to the lower id, so the same question always has the same answer.
 
@@ -122,7 +122,7 @@ sheer magnitude, so a long Tract would neighbor other long chants for being
 long. Per-group cosine asks about **shape within each dimension**.
 
 [`CENSUS_GROUPS`](index.md#the-appendix) gives you the group names and their
-field counts, and [`CENSUS_ORDER`](index.md#the-appendix) every censused id —
+field counts, and [`CENSUS_ORDER`](index.md#the-appendix) every censused id,
 so you can pool a set without guessing at either.
 
 ### Reading the numbers
@@ -140,7 +140,7 @@ per-group version spreads from about 0.85 down to 0.65. That compression comes
 from one wide block outvoting the other eight.
 
 **`before` filters before ranking.** It restricts the candidate pool, then
-ranks — so `k` stays satisfiable, and a filtered list is *not* a subset of the
+ranks, so `k` stays satisfiable, and a filtered list is *not* a subset of the
 unfiltered one. Chants that were ranked out by later material rise into it.
 Typicality is unaffected: it is always measured against the whole shipped
 corpus (see [Profile and typicality](#profile-and-typicality)).
@@ -201,7 +201,7 @@ const ranked = ids
 
 The per-group breakdown is where the answer becomes legible. _Quinque
 prudentes_ leads on `textual`, `cadenceMedial` and `trigram`, at about 0.99 on
-each — it sets its text and turns its phrases the way Communions do — while its
+each (it sets its text and turns its phrases the way Communions do), while its
 `cadenceFinal` is only about 0.82, so the one thing it does unlike a typical
 Communion is end. A chant is typical of its genus in some dimensions and not
 others.
@@ -213,8 +213,8 @@ Each group's `typicality` is its cosine against the corpus mean for that group:
 "unlike the rest."
 
 The two numbers above are a fair illustration. _Ab occultis meis_ is a mode-2
-Gradual whose `modal` typicality is about 0.99 — modally it is a typical
-mode-2 chant — while its `melodic` typicality is about 0.70, because its
+Gradual whose `modal` typicality is about 0.99, so modally it is a typical
+mode-2 chant. Its `melodic` typicality is about 0.70, because its
 interval
 vocabulary is its own. One chant can be conventional in one dimension and
 distinctive in another, which is the reason the groups are kept apart.
@@ -233,7 +233,7 @@ balance: { distance: 0.091, deviantGroups: ["degreeHist", "melodic"] }
 the corpus mean, 1 has nothing in common with it.
 
 `deviantGroups` names where a chant is unusual **relative to its own mean**,
-most deviant first — not against an absolute threshold. The question it answers
+most deviant first, not against an absolute threshold. The question it answers
 is "given how typical this chant is overall, where does it depart from
 itself?", which is what makes the answer legible for a chant that is unusual
 everywhere or nowhere.
@@ -273,12 +273,12 @@ tonus.census({ id: "gregobase:1210", before: 1100 });
 ```
 
 Restricts neighbors to chants a manuscript of the 11th century or earlier
-already holds — 1,790 of the 2,186 candidates. This is the same rule as
+already holds, 1,790 of the 2,186 candidates. This is the same rule as
 [`cantus({ before })`](chant.md#the-repertoire-as-of-a-date--the-era-view),
 through the same admissibility door: **evidence, not existence**, so a chant
 with no dated witness is excluded rather than assumed old.
 
-The seed chant itself is never filtered — you asked about it by name.
+The seed chant itself is never filtered, because you asked about it by name.
 
 ## What the census is not
 

package/docs/api/chant.md

@@ -69,7 +69,7 @@ those marks too.
 The corpus is **assignment-driven**: a chant ships when some day of the
 liturgical year calls for it. The calendar is walked year by year until it stops
 finding new assignments (39 years, in the event), and what it never reaches is
-not shipped — 10,156 book chants become 2,187.
+not shipped: 10,156 book chants become 2,187.
 
 Everything here answers "what was sung on this day". A query for a chant the
 calendar never calls for returns nothing.
@@ -77,11 +77,11 @@ calendar never calls for returns nothing.
 ## The books — `corpus`
 
 `corpus(code)` returns one book's bibliographic identity and a breakdown of what
-it holds — how many chants, in what genres, in what modes. `corpus({ book })` is
+it holds: how many chants, in what genres, in what modes. `corpus({ book })` is
 the same question in the query form every other verb uses; both spellings return
 one answer.
 
-`corpus()` with no argument returns **the whole shelf** — the rollup plus every
+`corpus()` with no argument returns **the whole shelf**, the rollup plus every
 book's ledger:
 
 ```js
@@ -94,7 +94,7 @@ tonus.corpus();
 //   books:  [ …10 Corpus entries, in registry order ] }
 ```
 
-**`count` is the number of chants** — the one to quote. `listings` is how long
+**`count` is the number of chants**, the one to quote. `listings` is how long
 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.
@@ -141,7 +141,7 @@ am.genera[0];         // { office: "an", genus: "Antiphona", count: 458 }
 am.full.genera[0];    // { office: "an", genus: "Antiphona", count: 1049 }
 ```
 
-Reading the two tallies side by side names what was left out — 1,049 antiphons
+Reading the two tallies side by side names what was left out: 1,049 antiphons
 in the book, 458 sung.
 
 Only the extractor can measure this. By the time tonus loads, the keep set has
@@ -163,7 +163,7 @@ is largely the Graduale and the Antiphonarius bound together (it shares hundreds
 of chants with each), while the Antiphonale Monasticum is almost entirely its own.
 
 The Nocturnale (`nr`) is compared differently, because it has no GregoBase
-catalogue: its counts come from its own extract, and it shares **nothing** —
+catalogue: its counts come from its own extract, and it shares **nothing**, so
 `unique` is all 1,564 chants it holds. That is a measurement, not a gap. The
 nocturnale–GregoBase crosswalk is a route to metadata, not a claim that the two
 books print the same chant, so it does not count as sharing.
@@ -295,18 +295,18 @@ A plain search does not sweep it in: `{ mode: 5 }` returns the shelf. Ask for a
 Kyrie and you get Kyries.
 
 For the setting a given DAY calls for, [`ordinarium`](#the-ordinary--ordinarium)
-is the verb — it applies the Kyriale's own rubrics. This is flat retrieval.
+is the verb, and it applies the Kyriale's own rubrics. This is flat retrieval.
 
 ### On chant ids
 
-An id's prefix names **the catalogue the identifier came from** — not the book
+An id's prefix names **the catalogue the identifier came from**, not the book
 the chant is printed in, and not a claim about who the melody belongs to. A
 chant carrying `gregobase:1210` is a Solesmes book chant that GregoBase happens
 to have catalogued; the corpus is assembled from ten books, and GregoBase is
 one source among several.
 
 The prefix is therefore **not a namespace you can query against**. GregoBase
-holds 18,148 chants; tonus ships 1,717 of them — 9.5% — because the corpus is
+holds 18,148 chants; tonus ships 1,717 of them (9.5%), because the corpus is
 assignment-driven, so an id copied from the GregoBase site will usually return
 `[]` here. That is not a lookup failure; it means no day of the calendar calls
 for that chant. The two prefixes in the shipped corpus are `gregobase:` (1,717)
@@ -322,7 +322,7 @@ to a chant rather than to a printing.
 `before: 1098` keeps only chants a manuscript of the 10th century or earlier
 already holds. This is **evidence, not existence**: the dates come from
 CANTUS's manuscript index, a terminus ante quem, so the filter answers "what
-is attested by then," never "what existed then" — and a chant with no dated
+is attested by then," never "what existed then." A chant with no dated
 witness is excluded rather than assumed old. CANTUS dates only to the century,
 so a year admits the centuries that have CLOSED before it (`before: 1098` →
 through the 900s).
@@ -339,7 +339,7 @@ tonus.ordinarium({ feast: easter }); // the ordinary the view attests
 ```
 
 What happens to a slot the view excludes differs by verb, on the rubric's
-own logic: `ordinarium` **re-picks** — the Kyriale offers ranked
+own logic: `ordinarium` **re-picks**, because the Kyriale offers ranked
 alternatives by design, so the rotation runs over the admissible pool and
 the day still sings. `proprium` and `officium` have no pool
 of alternatives, so an excluded chant **falls silent**. A `before` given to a
@@ -371,15 +371,15 @@ interface PropriumQuery extends CantusQuery {
 ## The ordinary — `ordinarium`
 
 `ordinarium(query?)` retrieves the fixed chants of the Mass from the
-Kyriale. A feast drives mass selection through its `masses` list — the
+Kyriale. A feast drives mass selection through its `masses` list, the
 masses the day's Kyriale RUBRIC appoints, derived as described in
 [calendar.md](calendar.md#the-days-feasts--festum); `mass` pins a kyriale
 number directly. Where the rubric names several masses, the year rotates
 through them (same feast, same year → same answer, every time), and sibling
 printings under one number (Mass I prints two dismissals; Mass XVII prints
 Kyrie A/B/C) rotate with it. Slots resolve independently, which the book
-licenses outright — "chants from one Mass may be used together with those
-from others" — with one exception, the book's own: **"the Ferial Masses
+licenses outright ("chants from one Mass may be used together with those
+from others") with one exception, the book's own: **"the Ferial Masses
 excepted."** Under a ferial rubric the sung ordinary is not gathered from
 several masses; only the dismissal travels.
 
@@ -397,10 +397,10 @@ tonus.ordinarium({ feast: easter });
 
 The **Gloria follows the day's rank rubric, not its season**: the ferial
 masses print none (XVI, XVIII) and the penitential-Sunday mass none (XVII),
-while a I-class feast inside Advent or Lent — the Immaculate Conception —
+while a I-class feast inside Advent or Lent (the Immaculate Conception)
 keeps its Gloria. At a Gloria-less Mass the dismissal is the Benedicamus
 Domino, and a mass with no dismissal of its own borrows one exactly as the
-book directs: "Benedicamus Domino **as in Mass II**" — so a green feria
+book directs: "Benedicamus Domino **as in Mass II**," so a green feria
 sings Mass XVI whole with the Mass II Benedicamus. The ad libitum appendix
 is a **solemnity boost**, reachable only under the festal rubrics (it takes
 its turn in the rotation once every _n + 1_ years); it never reaches a
@@ -475,7 +475,7 @@ seasonal ordo and returned in liturgical order. With no feast, each resolves
 for the [default epoch](index.md#dates).
 
 **Matins is returned flat.** The night office answers like any other hour,
-its responsories drawn from the Nocturnale Romanum (`nr`) — but the
+its responsories drawn from the Nocturnale Romanum (`nr`). But the
 three-nocturn, twelve-psalm division is not modelled: the chants are right,
 their grouping into nocturns is not expressed.
 
@@ -492,7 +492,7 @@ interface OfficiumQuery extends CantusQuery {
 }
 ```
 
-The eight hours ship as [`HORAE`](index.md#the-appendix), Matins first — read
+The eight hours ship as [`HORAE`](index.md#the-appendix), Matins first. Read
 them from there rather than transcribing them, and an unrecognised `hora`
 throws rather than matching nothing, so a misspelling cannot read as an empty
 hour.
@@ -507,9 +507,9 @@ tonus.officium({ hora: "vespers" });  // throws: unknown hora "vespers"
 
 ### One cursus, the Benedictine
 
-tonus assembles a single office — the monastic cursus — with no option to
+tonus assembles a single office (the monastic cursus) with no option to
 choose another. The chants come from the Antiphonale Monasticum (`am`) and its
-companions; the psalmody follows the Benedictine distribution — the little
+companions; the psalmody follows the Benedictine distribution, the little
 hours take the gradual psalms (Terce 119–121, Sext 122–124, None 125–127),
 with Sunday and Monday walking their portions of Ps 118 instead; Prime walks
 Pss 1–19 across the week (Sunday opens Ps 118); and Compline is the fixed
@@ -530,7 +530,7 @@ the opening formula is included, as it is for a psalm's first verse.
 mediant, as a psalm sung without an antiphon; `solemn` uses a tone's
 ornamented mediant where it has one. Canticles are addressed by name:
 `benedictus`, `magnificat`, `nunc dimittis`, `benedicite`. (The Te Deum
-is not psalmody — it carries its own melody and is not addressable here.)
+is not psalmody: it carries its own melody and is not addressable here.)
 
 ```js
 tonus.psalmus({ psalm: 109, verse: "1a", mode: 1 });

package/docs/api/heavens.md

@@ -168,12 +168,12 @@ and moves with precession; a table carrying "March 21" would be wrong for most
 of the period this library models, and wrong differently every century.
 
 **What is omitted, and why.** The exaltation degrees Ptolemy gives (the Sun at
-19° Arietis and the rest) are not carried — the sign is the resolution anything
-here reads. Nor are the lunar nodes' exaltations, because the nodes are not
+19° Arietis and the rest) are not carried, because the sign is the resolution
+anything here reads. Nor are the lunar nodes' exaltations, because the nodes are not
 tonus bodies. Five signs exalt nobody: that silence is the tradition's, not a
 gap in the table.
 
-The `melothesia` is the *homo signorum* of medieval calendars — Aries at the
+The `melothesia` is the *homo signorum* of medieval calendars, Aries at the
 head down to Pisces at the feet. It was practice, not decoration: phlebotomy
 was timed against it, and while the Moon stood in a sign its member was not to
 be touched. Sourced from Ptolemy's *Tetrabiblos* I.17 and I.19
@@ -216,7 +216,7 @@ The doctrinae:
 Sphere pitches are computed directly from the doctrina's pure ratios,
 anchored at the temperamentum's A4, so historical coherence holds:
 `temperamentum("ptolemy-intense")` with `harmonia({ doctrina: "ptolemy" })`
-gives pure Ptolemaic intervals throughout — Sun→Jupiter a pure 3/2,
+gives pure Ptolemaic intervals throughout: Sun→Jupiter a pure 3/2,
 Sun→Saturn a pure 2/1. The temperamentum's scale governs pitch naming and
 the imprint.
 
@@ -322,7 +322,7 @@ h.tabula.find((r) => r.name === "Jupiter");
 ```
 
 `ratio` is the doctrina's own fraction against the mese, the primary datum of
-the whole scheme — `spn` and `hz` are that ratio sounded against A4, not
+the whole scheme. `spn` and `hz` are that ratio sounded against A4, not
 independent claims. Comparing doctrinae means comparing these: the table
 under [Theory & Context](#theory--context) is what the field returns.
 
@@ -364,7 +364,7 @@ The doctrina ratios are reconstructed from the primary texts through
 Joscelyn Godwin's syntheses, mapping each body to a Greek tone-name and
 deriving its ratio by Pythagorean interval arithmetic normalized to the
 mese (Sun = 1/1). The full method, the taxonomy, and the decisions taken
-along the way are documented at the data — see `DOCTRINAE` in
+along the way are documented at the data. See `DOCTRINAE` in
 [`harmonia/data/doctrines.ts`](https://github.com/jeffreypierce/tonus/blob/main/src/engines/harmonia/data/doctrines.ts).
 The same arithmetic is laid out from the tuning side in
 [tuning.md](tuning.md#theory--context).
@@ -385,7 +385,7 @@ The resulting ratios, by sphere from the outermost:
 
 The single pitch separating Pythagoras from Boethius is Venus: a whole
 tone above the Sun in the disjunct system (9/8, B durum), a semitone in
-the conjunct (256/243, B molle) — the origin of the durum/molle
+the conjunct (256/243, B molle). This is the origin of the durum/molle
 distinction that runs through all of medieval music theory.
 
 ## Sources

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.
 
-**[Orreliquum — the library at work →](https://jeffreypierce.github.io/orreliquum/)**
+**[Interactive demo](https://orreliquum.com/)**
 
 ```js
 import tonus from "tonus";
@@ -123,7 +123,7 @@ is for.
 | `CENSUS_GROUPS` | the field groups → `{ offset, count }`; the keys are the valid `by:` values **and** the `profile` keys |
 | `CENSUS_ORDER`  | every censused chant id, in block order — so membership is a lookup, not a `try/catch`                 |
 
-Use these to pool blocks without reproducing the distance rule — see [the census
+Use these to pool blocks without reproducing the distance rule. See [the census
 contract](census.md#distance-is-cosine-per-field-group).
 
 ## Full contents
@@ -218,7 +218,7 @@ Other fields carry only one register. Latin-only, _e.g._ `genus`, `ordinarium`,
 `incipit`, `differentia`, `accentus`. English-only, _e.g._ `date`, `velocity`, `hz`.
 
 Display strings live in exported maps (_e.g._ `SEASON_LABEL`),
-never as label fields on objects — the maps are [the appendix](#the-appendix).
+never as label fields on objects. The maps are [the appendix](#the-appendix).
 
 ### Dates
 
@@ -238,14 +238,14 @@ an ensemble) it is seeded, so the same seed yields byte-identical output.
 
 ### Error contract
 
-- Query functions return `[]` on no match, never throw — but an **empty or
+- Query functions return `[]` on no match, never throw. But an **empty or
   unknown-key query** throws (a mistyped filter is a bug, not an empty result):
   `festum({ month: 12 })` and `cantus({})` throw rather than silently resolving a
   plausible-looking answer.
 - Builder functions throw `Error` with a descriptive message on invalid input.
 - `notatio` throws on invalid `Chant` input.
 - `inscriptio` throws on a non-`Score` argument or an unknown notation species.
-- `temperamentum.tonus()` throws if `mode` is `"auto"` — mode must be set
+- `temperamentum.tonus()` throws if `mode` is `"auto"`. Mode must be set
   explicitly.
 - Malformed `comma`, ratio, or Scala input throws `RangeError`; custom scales
   must supply 7 or 12 steps, beginning at `1/1` (a degree list) or ending at

package/docs/api/score.md

@@ -42,8 +42,8 @@ const score = tonus.notatio(introit, { temperamentum: t });
 ```
 
 The structured view is `score.phrases`; the flat view, one row per note,
-is `score.tabula`. Phrases split at every divisio — the bars of chant
-notation, signs of punctuation rather than measure:
+is `score.tabula`. Phrases split at every divisio, the bars of chant
+notation, which are signs of punctuation rather than measure:
 
 | divisio | name                         |
 | ------- | ---------------------------- |
@@ -103,7 +103,7 @@ text: the `<sp>` shortcuts arrive as real characters (`<sp>V/</sp>` → ℣,
 `\greheightstar` verbatim → the raised *), centering braces and layout tags
 (`<clear>`, `<nlba>`) vanish, above-lines text (`<alt>`) is not lyric text,
 and page cross-references (`\pageref`) to the paper books are dropped. Style
-tags — `<i>`, `<b>`, `<sc>`, `<c>` (rubric color), `<e>` (elision) — survive
+tags (`<i>`, `<b>`, `<sc>`, `<c>` for rubric color, `<e>` for elision) survive
 as `runs`, styled spans that concatenate to `lyric`; a style opened in one
 syllable and closed several later (the common `<i>ij.</i>` and euouae
 patterns) styles every syllable it crosses. Both notation species draw the
@@ -289,7 +289,7 @@ analysis, visualization, or emission.
 
 `Harmony` exposes the same surface for voiced bodies
 ([heavens.md](heavens.md#the-tabula)). The tabula is also the rendering
-surface — the SVG renderer ([below](#rendering)) consumes it directly, which is
+surface. The SVG renderer ([below](#rendering)) consumes it directly, which is
 why `hz`, `velocity`, `bend`, and the ornament flags live on each row.
 
 ```js
@@ -364,7 +364,7 @@ interface ChantTabulaRow {
 
 ## Rendering
 
-The score is drawn as **SVG** — a self-contained, square-note chant staff with
+The score is drawn as **SVG**: a self-contained, square-note chant staff with
 SMuFL glyphs baked as inline paths (no external font). It consumes `score.tabula`,
 so the interpretation applied through `pondus` and `accentus` is already in the
 geometry. Microtuning lives on each tabula row's `bend`, `hz`, and `offset` for
@@ -373,7 +373,7 @@ a Web-Audio player to read directly.
 ### inscriptio — the standalone renderer
 
 `tonus.inscriptio(score, opts?)` draws a `Score` and returns `{ svg, geometry }`.
-Rendering is a standalone function that _takes_ a score, not a method on one — the
+Rendering is a standalone function that _takes_ a score, not a method on one. The
 score analyzes, `inscriptio` inks. It throws on a non-Score or an unknown
 notation species (the builder-function contract).
 
@@ -391,14 +391,14 @@ Two notation species, each with its own spacing pass:
 
 **Layout is deterministic, and lyric widths are computed rather than measured.**
 The same score and options give byte-identical SVG on every machine, with no
-DOM, no canvas, and no font file — `inscriptio` runs anywhere Node does. Note
+DOM, no canvas, and no font file, so `inscriptio` runs anywhere Node does. Note
 glyphs carry exact SMuFL advance widths; lyric text is computed from character
 classes, since measuring it would require the font's own metrics. Line breaks,
 system fill, and the width of the returned canvas all rest on that figure. It is
 close, not exact: a lyric set in a face far from the assumed proportions will
 break slightly early or late.
 
-Two consequences worth planning around. `width` is a **request, not a promise** —
+Two consequences worth planning around. `width` is a **request, not a promise**:
 the canvas returned is `max(width, content)`, so a chant whose content cannot fit
 comes back wider rather than clipped. And a caller who needs typographic
 precision should render at a generous `width` and scale the result, rather than
@@ -406,22 +406,22 @@ relying on the estimate to land a tight column exactly.
 
 Options, by group (all optional):
 
-- **layout** — `width` wraps systems to fit (absent = a single line); `scale`
+- **layout**: `width` wraps systems to fit (absent = a single line); `scale`
   sets how big the chant is drawn: `"small"`, `"normal"` (default), `"large"`,
   or a staff height in px for fitting a known column. Everything scales from it
-  — notes, lyrics, the air between systems — and it reflows the music, so a
+  (notes, lyrics, the air between systems), and it reflows the music, so a
   larger scale means fewer notes per line. The page margin does not scale: it
   belongs to the page rather than the notation, and scaling it gave a large
   chant *less* usable width than a small one.
-- **front matter** — set as the Solesmes books open a piece: `title` centers
+- **front matter**: set as the Solesmes books open a piece: `title` centers
   over the score; `rubric` (or `annotation: "auto"` to derive the genus/mode
   mark, e.g. _Introitus. 8._) sits upright at the left margin; `dropcap` draws
   the initial the printed books open with, taking the first letter out of the
   lyric and indenting the first system to hold it. Both species take the
-  title; the margin mark and the initial are **quadrata's alone** — moderna is
+  title; the margin mark and the initial are **quadrata's alone**, because moderna is
   a transcription read as an edition, and carries the analysis tracks a
   reserved cap column would fight. It ignores them rather than refusing.
-- **theme** — the dress: `fonts` and `colors`.
+- **theme**: the dress, `fonts` and `colors`.
 
 ### theme — faces and ink
 
@@ -441,14 +441,14 @@ tonus.inscriptio(score, {
 ```
 
 **`fonts`** carries four roles. A book's dropcap is very often *not* its lyric
-face — a Lombardic or uncial initial against a text hand, which is the pairing
+face, but a Lombardic or uncial initial against a text hand, which is the pairing
 the printed books use. Each role takes a font-family string or
 `{ family, weight?, scale? }` (`scale` adjusts that role's size, for a face
 whose apparent size differs from the house serif).
 
 The SVG carries font-family *references* by default, and the page hosting it
 supplies the face (`@font-face`). A slot may instead carry
-`embed: { base64, format? }` — the caller's own bytes — and the face then rides
+`embed: { base64, format? }` (the caller's own bytes), and the face then rides
 inside the SVG's `<style>`, making the file self-contained (at the cost of its
 size; one `@font-face` per family + weight, deduped). tonus bundles no font
 files: with `embed` it is a conduit for data the consumer supplies, so the
@@ -489,7 +489,7 @@ is 196 KB base64'd, which triples a typical chant and repeats in every file,
 where a reference is cached once.
 
 **`colors`** reach the SVG as CSS custom properties with the theme's own value
-as the fallback — `fill="var(--tonus-note, #111)"`. A rendered chant therefore
+as the fallback, `fill="var(--tonus-note, #111)"`. A rendered chant therefore
 carries the ink it was drawn with *and* stays themable: a host stylesheet that
 sets the property rethemes the score without re-rendering it.
 
@@ -502,8 +502,8 @@ sets the property rethemes the score without re-rendering it.
 }
 ```
 
-The emitter's semantic classes — `note`, `lyric`, `dropcap`, `custos`,
-`episema`, `divisio`, `clef`, `mora`, `ictus` — are stylable from the host page.
+The emitter's semantic classes (`note`, `lyric`, `dropcap`, `custos`,
+`episema`, `divisio`, `clef`, `mora`, `ictus`) are stylable from the host page.
 
 **`scale` is not part of the theme**: line breaking consumes it, so a scale
 change re-renders while a colour change does not.
@@ -537,11 +537,11 @@ is in, not an offset to add.
 ### The analysis tracks
 
 `tracks` draws an analysis band beneath every system. Any track rides either
-species, and all may ride one score — the selection is independent of the
+species, and all may ride one score: the selection is independent of the
 notation, as `notation` itself is. One governing ink system runs through them:
 every mark draws in the score's black, strata graded by opacity alone (the
-liturgical red belongs to the claims — the tonarium's mode line and the
-prosodia's accent dots), and every pressure-bearing line shares one nib law —
+liturgical red belongs to the claims, the tonarium's mode line and the
+prosodia's accent dots), and every pressure-bearing line shares one nib law:
 velocity as stroke width.
 
 ```js
@@ -679,7 +679,7 @@ interface ModalAffinity {
 
 ## Metrics
 
-`score.metrics` measures the chant's shape — counts, range, melisma, melodic
+`score.metrics` measures the chant's shape: counts, range, melisma, melodic
 motion, contour, tessitura, rhythm, cadence. It is chant-specific; `Harmony`
 has no metrics.
 
@@ -715,7 +715,7 @@ interface Metrics {
 The five composite fields each answer one question about the chant.
 
 **Where the melody sits, and the shape it traces.** `noteRange` is the plain
-compass; `arcus` reads the classic chant arch — rise to a peak, return to the
+compass; `arcus` reads the classic chant arch, a rise to a peak and a return to the
 final.
 
 ```ts
@@ -734,7 +734,7 @@ interface Arcus {
 ```
 
 **How the melody moves.** Chant is overwhelmingly stepwise, so `motus` sorts
-every adjacent within-phrase motion by size — the three names are the tradition's
+every adjacent within-phrase motion by size. The three names are the tradition's
 own, and a chant whose skips and leaps outnumber its steps is unusual enough to
 question.
 
@@ -778,12 +778,12 @@ broken by breaths.
 | `colon`     | `:`     | divisio maior   |    1.0 |
 | `doubleBar` | `::`    | divisio finalis |    1.5 |
 
-This table is canonical — `metrics.ts` cites it rather than restating the
+This table is canonical: `metrics.ts` cites it rather than restating the
 weights.
 
 ## Cadences
 
-`score.cadences` names the melodic close of each phrase — where metrics
+`score.cadences` names the melodic close of each phrase. Where metrics
 only counts the divisio bars, this identifies the figure. One `Cadence` per
 phrase-ending divisio: its resolution `target`, the melodic `approach`, and the
 `divisio` that tells medial from final (the double bar `::` is the final
@@ -795,21 +795,21 @@ the tabula.
 Two catalogues describe a cadence, and they answer different questions. Read
 this before deciding which field to use:
 
-> Every cadence carries a **`signature`** — always. Some are **catalogued** by
+> Every cadence carries a **`signature`**, always. Some are **catalogued** by
 > the corpus (`finality`, and everything in
 > [`CADENTIAE`](index.md#the-appendix)). Some, on the final, are **named** by
 > received theory (`formula`).
 
 - **`formula`** is _tradita_: the mode's cadence figures as the treatises give
   them ([tuning.md](tuning.md#cadence-figures)), matched in solmization
-  relative to the final — `"la-sol"`, `"mi-re"`. It fires **only on the
+  relative to the final (`"la-sol"`, `"mi-re"`). It fires **only on the
   finalis**, because the received catalogue holds only final figures.
 - **`signature`** is _inventa_: the tail's interval shape and where it lands,
   keyed as `"2,0,-2 @0"` and mined from the corpus. It fires on **any** target,
   so it is the one of the two that speaks about **medial** cadences.
 
-Measured over the cadences `notatio` reports across the shipped corpus — about
-26,800 of them — roughly 43% carry a formula, 57% join the catalogue, and 31%
+Measured over the cadences `notatio` reports across the shipped corpus (about
+26,800 of them), roughly 43% carry a formula, 57% join the catalogue, and 31%
 carry both, so about a third carry neither. Neither is derivable from the
 other, because the signature is mode-blind and the formula is mode-relative.
 
@@ -822,7 +822,7 @@ the final, 31 do not close, and finality across the catalogue runs the whole
 range from 0 to 1. So
 `arrival === 0` implies nothing about whether a close is final.
 
-It is `null` when the signature falls below the catalogue's floor — an
+It is `null` when the signature falls below the catalogue's floor: an
 uncatalogued close, not a close that never closes.
 
 ```ts
@@ -843,7 +843,7 @@ interface Cadence {
 }
 ```
 
-A one-note phrase is a cadence — a landing with no gesture — and keys with an
+A one-note phrase is a cadence (a landing with no gesture) and keys with an
 empty shape (`" @0"`), which is why `signature` is that key rather than null.
 
 `arrival` is signed and not octave-reduced: `@-5`, a fourth below the final,
@@ -852,7 +852,7 @@ and `@+7`, a fifth above, are distinct families.
 ## Modulations
 
 `score.modulations` marks where the tonal centre leans away from the home
-mode — the local, temporal counterpart to the imprint's global modal
+mode, the local counterpart to the imprint's global modal
 affinity. Each phrase is scored against all eight modes (the imprint's
 affinity math); a run of phrases that favours a foreign mode, by a margin,
 becomes one `Modulation` span. The margin is calibrated against Suñol's
@@ -861,13 +861,13 @@ distribution-based: it finds where a passage leans, not a functional analysis.
 
 `kind` says what the span is evidence OF, which matters because the three are
 not the same phenomenon. **`inflection`** is a single phrase leaning away and
-back — passing colour, not a shift. **`modulation`** is a sustained internal
+back: passing colour, not a shift. **`modulation`** is a sustained internal
 excursion, two phrases or more, that returns. **`transposition`** is the whole
 chant sitting in a foreign mode's frame: it does not close on its labelled
 final and one foreign mode dominates most of its phrases, meaning the melody is
 notated at a transposed position (the affinal) or the label disagrees with the
-notation. A transposed chant is not modulating — the displacement is global —
-so a caller displaying "modulations" should treat those spans as a re-reading of
+notation. A transposed chant is not modulating, because the displacement is
+global, so a caller displaying "modulations" should treat those spans as a re-reading of
 the whole chant rather than an event inside it.
 
 ```ts
@@ -913,35 +913,35 @@ The classifier applies Carroll's three melodic rules in priority order
 
 The first compound beat of an incise is always arsic. When every rule is inconclusive, the
 shape alternates from the previous group. Two conventional overrides
-precede the rules: the **salicus** is always arsic — the tension toward its
-summit is the arsic gesture — and the **doubly-dotted clivis** is always
+precede the rules. The **salicus** is always arsic, because the tension toward
+its summit is the arsic gesture, and the **doubly-dotted clivis** is always
 thetic, as a cadential figure.
 
 A salicus here is Cardine's: an ascent of at least three notes whose
 **next-to-last note is an oriscus** [biblio: cardine-semiology, ch. 16]. The
 oriscus is what makes one. An ascending group carrying only the editorial
-Solesmes ictus is a **scandicus** that was marked for rhythm — a distinction
-worth stating because conflating the two is, in Bevenot's word, a trap: over
+Solesmes ictus is a **scandicus** that was marked for rhythm. The distinction
+is worth stating because conflating the two is, in Bevenot's word, a trap: over
 the sung corpus tonus finds about 260 salici against about 1,900 scandici, so
 only about an eighth of that wider set carries an oriscus at all.
 
 Cardine's correction also decides WHICH note is principal. The printed
 editions lengthen the oriscus itself; the manuscripts show the principal note
-is the one **immediately following** it — the summit — so tonus prolongs that
+is the one **immediately following** it (the summit), so tonus prolongs that
 note and takes the oriscus lightly. This is the one point where the rhythmic
 layer departs from Mocquereau and Suñol, and it does so deliberately.
 
 ### Rhythmic types
 
-Above the per-beat arsis/thesis, each phrase carries a `rhythmicType` — Le
+Above the per-beat arsis/thesis, each phrase carries a `rhythmicType`, Le
 Guennant's taxonomy (via Carroll) of how the incise's compound beats chain, and
 the `beats` sequence it reads. The observable types are modeled: **IV** (a single
 arsis to a single thesis), **V** (several arses to one thesis), **VI** (one arsis
 to several theses), **VII** (regular A–T alternation), and **VIII** (a
-contraction — two simple rhythms overlapping at a shared ictus, after Suñol).
+contraction of two simple rhythms overlapping at a shared ictus, after Suñol).
 Types I–III use sub-beat cells that never surface in isolation and are not
 labeled; an incise that fits no type is `null`. The classification rules live at
-the data — see `classifyRhythmicType` in
+the data. See `classifyRhythmicType` in
 [`score/ir.ts`](https://github.com/jeffreypierce/tonus/blob/main/src/engines/score/ir.ts).
 
 ### Modeled and not

package/docs/api/tuning.md

@@ -343,11 +343,11 @@ interface GamutOptions {
 `modus` returns the full profile of one of the eight modes, as the
 medieval tonaries describe them:
 
-- its identity — Latin name, modern alias, _maneria_ (the family: Protus,
+- its identity: Latin name, modern alias, _maneria_ (the family: Protus,
   Deuterus, Tritus, Tetrardus), and authentic or plagal type;
-- its structure — finalis, tenor, scale degrees, ambitus, and the species
+- its structure: finalis, tenor, scale degrees, ambitus, and the species
   of fifth and fourth that build it;
-- its practice — hexachords in rank order, melodic profile, its cadence
+- its practice: hexachords in rank order, melodic profile, its cadence
   figures, and permitted modulations.
 
 Each mode also carries its traditional **ethos** (the character medieval theory
@@ -365,7 +365,7 @@ data, in [`temper/data/modes.ts`](https://github.com/jeffreypierce/tonus/blob/ma
 temperamentum: the **finalis** and **reciting** tone as tuned notes (pitch +
 Guidonian step), and **ambitusNotes**, the mode's diatonic range walked out
 note by note. The raw `ModeData` fields (`final`, `tenor`, `cadences`, …)
-remain alongside — `Modus` extends `ModeData`.
+remain alongside, because `Modus` extends `ModeData`.
 
 ```js
 t.modus(1);
@@ -436,7 +436,7 @@ interface Modus extends ModeData {
 ### Cadence figures
 
 Each mode carries the melodic figures its phrases characteristically close
-on, in `modus(n).cadences` — the shapes by which a chant comes to rest, stored
+on, in `modus(n).cadences`, the shapes by which a chant comes to rest, stored
 as diatonic steps relative to the final. The score engine reads them to name a
 phrase's cadence ([score.md](score.md#cadences)).
 
@@ -449,10 +449,10 @@ phrase's cadence ([score.md](score.md#cadences)).
 
 The catalogue is an editorial synthesis covering the final cadences; its step
 encoding, sources, and known gaps (medial cadences are not yet included) are
-documented at the data — see `CadenceFigure` in
+documented at the data. See `CadenceFigure` in
 [`temper/data/modes.ts`](https://github.com/jeffreypierce/tonus/blob/main/src/engines/temper/data/modes.ts).
 
-This is the **tradita** half — what the treatises say. Its counterpart is the
+This is the **tradita** half, what the treatises say. Its counterpart is the
 corpus tally below, and they are not interchangeable: see [one spine, two
 annotations](score.md#one-spine-two-annotations).
 
@@ -460,8 +460,8 @@ annotations](score.md#one-spine-two-annotations).
 
 Where the figures above are received, [`CADENTIAE`](index.md#the-appendix) is
 **mined**: every phrase-end in the sung corpus, grouped into families by what
-the melody actually did. A family is a **shape** — the closing tail's
-successive semitone intervals — and an **arrival**, where it landed relative
+the melody actually did. A family is a **shape** (the closing tail's
+successive semitone intervals) and an **arrival**, where it landed relative
 to the chant's own closing note. Together they are the key, `"2,0,-2 @0"`, and
 the key is the family's whole name.
 
@@ -505,14 +505,14 @@ lift(fam, 6); // 2.15
 lift(fam, 4); // 0.07
 ```
 
-The commonest family in the corpus — about 1,100 occurrences, about 4% of all
-phrase-ends, closing a little under half the time — is not reached for evenly.
+The commonest family in the corpus (about 1,100 occurrences, about 4% of all
+phrase-ends, closing a little under half the time) is not reached for evenly.
 Mode 6 reaches for this close more than twice as often as the corpus does;
 mode 4 almost never. That is the figure the tonarium prints under a cadence
 ([score.md](score.md#the-analysis-tracks)).
 
-**The ratio is not baked.** The table exports the vocabulary — counts and
-their denominators — and leaves the arithmetic to the caller. Two cautions when
+**The ratio is not baked.** The table exports the vocabulary (counts and
+their denominators) and leaves the arithmetic to the caller. Two cautions when
 you take it: below roughly ten in-mode occurrences the ratio is one or two
 chants deciding a number that reads like a measurement, and a mode-less chant
 (`"?"`) has no denominator at all. In both cases fall back to `share`.
@@ -524,7 +524,7 @@ pitches: the **intonatio** (the opening rise), the **mediatio** (the
 cadence at the verse's colon), and the **terminatio** (the closing
 cadence). The termination varies by **differentia**, the cadential variant
 chosen to lead back into the antiphon; the mode's default differentia is
-used when none is given. The mode must be set explicitly — with mode
+used when none is given. The mode must be set explicitly, because with mode
 `"auto"`, `tonus()` throws.
 
 ```js

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "tonus",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "type": "module",
-  "description": "Medieval music analysis and performance: GABC plainchant exports, liturgical calendar, tuning systems, ephemeris, and the harmony of the spheres",
+  "description": "Medieval music analysis: GABC plainchant exports, liturgical calendar, tuning systems, ephemeris, and the harmony of the spheres",
   "author": "Jeffrey Pierce <jeffrey@jeffreypierce.net>",
   "license": "PolyForm-Noncommercial-1.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jeffreypierce/tonus.git"
   },
-  "homepage": "https://jeffreypierce.github.io/orreliquum/",
+  "homepage": "https://orreliquum.com/",
   "bugs": "https://github.com/jeffreypierce/tonus/issues",
   "keywords": [
     "gregorian-chant",
@@ -36,6 +36,7 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "sideEffects": false,
   "files": [
     "dist",
     "docs/api",