tonus 0.9.0 → 0.10.0

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/score/infer.js

@@ -5,7 +5,7 @@ import { MODES } from "../temper/modes.js";
 // phrase: the Gloria's "Et in terra pax" (the celebrant sings "Gloria in
 // excelsis") and the Credo's "Patrem omnipotentem" ("Credo in unum Deum").
 const ORDINARY_INCIPITS = [
-    [/^kyrie/i, "ky"],
+    [/^kyrie/i, "ke"],
     [/^gloria/i, "gl"],
     [/^etinterra/i, "gl"],
     [/^credo/i, "cr"],

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/dist/index.d.ts

@@ -11,20 +11,16 @@ import { getCosmos } from "./engines/planet/planet.js";
 import { buildHarmonia } from "./engines/harmonia/api.js";
 import { getCensus } from "./engines/census/census.js";
 import type { FeastQuery, Feast, Pascha, Season, Grade } from "./engines/cal/types.js";
-import type { CantusQuery, Chant, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Corpus, GenusCount, ModeCount, SharedCount, CorpusLedger, CorpusFullCount, CorpusQuery } from "./engines/chant/types.js";
+import type { CantusQuery, Chant, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Corpus, CorpusLedger, CorpusQuery } from "./engines/chant/types.js";
 import type { TemperamentumInput, Temperamentum, Tuning, TemperamentumOpts, Pitch, PitchInput, Step, Neume, NeumeShape, Interval, ModeData, CadenceFigure, Modus, TunedNote, GamutOptions, Tonus, TonusOpts } from "./engines/temper/api.js";
-import type { Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, Cadence, CadenceTarget, CadenceApproach, Modulation } from "./engines/score/api.js";
-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 { Metrics, RhythmicProfile, NoteRange, CadenceDistribution } from "./engines/score/metrics.js";
+import type { Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, Cadence, Modulation } from "./engines/score/api.js";
+import type { Imprint } from "./engines/imprint.js";
+import type { Metrics } 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";
-import type { Note, Performance, Phrase, Syllable, LyricRun, RestEvent, ParseError, ArsisThesis, RhythmicType, CompoundBeat } from "./engines/score/types.js";
 import type { VoicedPitch } from "./engines/harmonia/voice.js";
 import type { Cosmos, CosmosQuery, Body, BodyName, Aspect } from "./engines/planet/types.js";
-import type { Census, CensusQuery, CensusBy, CensusGroup, CensusGroupProfile, CensusNeighbor } from "./engines/census/types.js";
 declare const tonus: {
     festum: typeof getFeast;
     pascha: typeof getPascha;
@@ -58,5 +54,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, Metrics, 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, CorpusLedger, CorpusQuery, Temperamentum, TemperamentumInput, TemperamentumOpts, Tuning, Pitch, PitchInput, Step, Neume, NeumeShape, Interval, ModeData, CadenceFigure, Modus, TunedNote, GamutOptions, Tonus, TonusOpts, Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, Cadence, Modulation, VoicedPitch, Cosmos, CosmosQuery, Body, BodyName, Aspect, Imprint, Metrics, Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author, HarmonyTabulaRow, PlanetVowel };
 //# sourceMappingURL=index.d.ts.map

package/dist/inscriptio.d.ts

@@ -0,0 +1,5 @@
+export { inscriptio } from "./engines/score/inscriptio.js";
+export type { InscriptioOpts, Inscriptio, NoteGeometry, FontSpec, FontSlot, FontEmbed, Theme, ThemeColors, TrackName, TrackData, } from "./engines/score/inscriptio.js";
+export type { ChantTabulaRow } from "./engines/score/tabula.js";
+export type { Score } from "./engines/score/api.js";
+//# sourceMappingURL=inscriptio.d.ts.map

package/dist/inscriptio.js

@@ -0,0 +1,23 @@
+// ---------------------------------------------------------------------------
+// tonus/inscriptio — the drawing entry point
+// ---------------------------------------------------------------------------
+// The rendering boundary, made addressable: `score` analyzes, `inscriptio`
+// draws. Everything reachable from here consumes a Score and produces SVG plus
+// the geometry contract; nothing here is read by an analysis pass.
+//
+// The root namespace still carries `inscriptio` — the export law puts verbs on
+// the namespace, and this module does not repeal it. What the entry adds is a
+// place to hold the drawing surface ON ITS OWN, so a caller who only wants a
+// picture imports one name and reads one type list rather than the library's
+// ninety-seven.
+//
+// It also surfaces four types the root index never exported: Theme and
+// ThemeColors (which an `opts.theme` caller had to spell out by hand) and
+// TrackName / TrackData (the same for `opts.tracks`). Reachable through the
+// signature, nameable nowhere — which is the drift this entry exists to stop.
+//
+// ChantTabulaRow and Score ride along because they are the OTHER HALF of the
+// geometry contract: geometry[i] and tabula[i] are the same note, and a caller
+// holding one without the other cannot use either.
+export { inscriptio } from "./engines/score/inscriptio.js";
+//# sourceMappingURL=inscriptio.js.map

package/dist/score.d.ts

@@ -0,0 +1,6 @@
+export type { Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, Cadence, CadenceTarget, CadenceApproach, Modulation, } from "./engines/score/api.js";
+export type { Note, Performance, Phrase, Syllable, LyricRun, RestEvent, ParseError, ArsisThesis, RhythmicType, CompoundBeat, } from "./engines/score/types.js";
+export type { ChantTabulaRow } from "./engines/score/tabula.js";
+export type { Metrics, RhythmicProfile, NoteRange, CadenceDistribution, } from "./engines/score/metrics.js";
+export type { Imprint, Attractor, VowelAttractor, ModalAffinity, } from "./engines/imprint.js";
+//# sourceMappingURL=score.d.ts.map

package/dist/score.js

@@ -0,0 +1,20 @@
+// ---------------------------------------------------------------------------
+// tonus/score — what a Score is made of
+// ---------------------------------------------------------------------------
+// `notatio` stays on the root namespace and still returns a Score, so the
+// common case — parse a chant, read its phrases — needs nothing from here. This
+// entry holds the STRUCTURE: the note, the syllable, the phrase, the rhythmic
+// vocabulary, the cadence and modulation records, and the measurement sub-
+// objects a Metrics is built from.
+//
+// They came off the root index because they are not answers, they are the
+// grain of one answer. Ten of the ninety-seven names it carried were reachable
+// only by holding a Score already, which meant a reader scanning the index for
+// what tonus DOES had to step over the anatomy of one return value to find the
+// next verb. That is the density, and this is where it goes.
+//
+// Nothing is hidden by the move: every name below is exported here, and the
+// types a verb hands back — Score, Cadence, Modulation, Metrics — stay on the
+// root as well, because the root's own signatures name them.
+export {};
+//# sourceMappingURL=score.js.map

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,8 +56,17 @@ interface CensusQuery {
 }
 ```
 
-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
+The census covers **7,733 of the 7,840 chants tonus ships**, one block per
+chant. The hundred and seven without one are the *Toni Communes* — office `or`,
+the recitation formulas — and they are left out on purpose: eleven *Benedicamus
+Domino* settings are one gesture, not eleven chants, and censusing them would
+invent a distribution out of a tone. They stay on the shelf; `cantus` finds
+them. They are simply not what typicality is measured against.
+
+That population is now the books themselves. Until 2026-08-31 it was the 2,187
+the calendar reached, which meant every typicality figure below was quietly
+measured against one rite's selection rather than against the repertory. 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,42 +87,42 @@ 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
+The reference is the mean block over all 7,733 chants, group by group. Because
 blocks are sums of durations and counts, they add: a season's blocks, summed and
 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 +131,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 +149,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 +210,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 +222,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 +242,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 +282,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