tonus 0.1.8 → 0.5.0

package/dist/engines/chant/psalm.js

@@ -2,15 +2,17 @@
 // engines/chant/psalm — psalm and canticle retrieval as intoned Chant[]
 // ---------------------------------------------------------------------------
 import { PSALMS } from "../../data/psalms.js";
-import { OFFICE_PSALMS, } from "../../data/office-psalms-roman.js";
-import { OFFICE_PSALMS_MONASTIC } from "../../data/office-psalms-monastic.js";
+import { OFFICE_PSALMS_MONASTIC, } from "../../data/office-psalms-monastic.js";
 import { intone } from "./intone.js";
-import { MODE_LABELS } from "./types.js";
+import { MODI } from "./types.js";
+// Canticle numbers follow the generated psalms.json numbering (verified against
+// the incipits: 231 "Benedíctus Dóminus", 232 "Magníficat", 233 "Nunc dimíttis",
+// 210 "Benedícite, ómnia ópera"). The Te Deum is not psalmody — it carries its
+// own melody, has no rows in the psalter data, and is not addressable here.
 const CANTICLE_NAMES = {
     benedictus: 231,
-    magnificat: 234,
-    "nunc dimittis": 227,
-    "te deum": 240,
+    magnificat: 232,
+    "nunc dimittis": 233,
     benedicite: 210,
 };
 function lookupVerses(psalm, verse) {
@@ -37,15 +39,20 @@ function verseToChant(v, mode, differentia, intonation, inDirectum, solemn) {
         office: "ps",
         genus: "Psalmus",
         mode: String(mode),
-        modus: mode === 0 ? "Tonus Peregrinus" : (MODE_LABELS[String(mode)] ?? `Modus ${mode}`),
+        modus: mode === 0 ? "Tonus Peregrinus" : (MODI[String(mode)] ?? `Modus ${mode}`),
         pages: [],
         source: {
             book: "Psalterium",
-            year: new Date().getUTCFullYear(),
+            // Deterministic: intoned psalmody is computed, not dated — the library's
+            // determinism doctrine forbids a wall-clock stamp here.
+            year: null,
             editor: "tonus",
         },
     };
 }
+const PSALMUS_QUERY_KEYS = new Set([
+    "psalm", "verse", "mode", "differentia", "intonatio", "inDirectum", "solemn",
+]);
 /**
  * Psalm and canticle retrieval (`tonus.psalmus`) from the Psalterium,
  * intoned to the psalm tones (modes 1-8 plus tonus peregrinus) as GABC.
@@ -53,6 +60,13 @@ function verseToChant(v, mode, differentia, intonation, inDirectum, solemn) {
 export function getPsalm(query) {
     if (!query || Object.keys(query).length === 0)
         return [];
+    // The same door policy as cantus and officium: an unknown key throws, so a
+    // stale or misspelled option is learned immediately, not silently ignored.
+    const unknown = Object.keys(query).filter((k) => !PSALMUS_QUERY_KEYS.has(k));
+    if (unknown.length) {
+        throw new Error(`psalmus: unknown query key(s) ${unknown.map((k) => `"${k}"`).join(", ")} ` +
+            `(expected ${[...PSALMUS_QUERY_KEYS].join(", ")}).`);
+    }
     const verses = lookupVerses(query.psalm ?? 0, query.verse);
     if (!verses.length)
         return [];
@@ -83,12 +97,12 @@ export function intonePortion(p, mode = 8) {
 }
 /**
  * The little-hours psalmody for one hour on a given weekday (0 = Sunday), from
- * the extracted DO Tridentine scheme (`office-psalms-roman.ts`). Prefers the
+ * the extracted DO monastic scheme (`office-psalms-monastic.ts`). Prefers the
  * weekday-specific entry, then the ferial default (weekday null), then the
  * feast set; returns the psalm portions (not yet intoned).
  */
-export function officePsalmPortions(hour, weekday, rite = "romanum") {
-    const scheme = rite === "monasticum" ? OFFICE_PSALMS_MONASTIC : OFFICE_PSALMS;
+export function officePsalmPortions(hour, weekday) {
+    const scheme = OFFICE_PSALMS_MONASTIC;
     const forHour = scheme.filter((e) => e.hour === hour);
     const exact = forHour.find((e) => e.weekday === weekday && !e.festis);
     const ferial = forHour.find((e) => e.weekday === null && !e.festis);

package/dist/engines/chant/syllabify.d.ts

@@ -15,6 +15,7 @@ export declare function hyphenateWord(word: string): string;
 export declare function selectVowel(text: string): {
     vowel: string;
     accent: boolean;
+    diphthong: string | null;
 };
 export declare function detectVowelAccent(text: string): boolean;
 //# sourceMappingURL=syllabify.d.ts.map

package/dist/engines/chant/syllabify.js

@@ -3,21 +3,30 @@
 // ---------------------------------------------------------------------------
 //
 // Rules applied (in order):
-//   1. Digraphs ae, oe, au, ei, eu → single vowel unit (never split)
-//   2. qu → treated as single consonant (u is silent after q)
-//   3. V-ia/ie/io/iu/ua/ue/uo-V → always split before the i/u (ecclesiastical)
-//      Exception: ui after l/r is a diphthong (alleluia, huius)
-//   4. Single consonant between vowels → goes with following vowel (V·CV)
-//   5. Consonant clusters: muta cum liquida (tr, pr, br, gr, dr, cr, fr, pl, bl,
-//      cl, gl, fl) stay together; all other clusters split after first consonant
+//   1. Diphthongs ae, oe, au → single vowel unit (never split). ei and ui are
+//      NOT diphthongs in ecclesiastical Latin (De-i, e-le-i-son, fu-it, su-i)
+//      — except the pronoun stems cui/hui (cui, huic), where ui is true.
+//      eu is NOT a diphthong either (de-us, me-us split normally).
+//   2. qu → single consonant (u is silent after q); likewise the ngu glide
+//      (lin-gua, sán-guis) — but not gu elsewhere (e-xi-gu-us, ar-gu-it).
+//   3. i between vowels, or word-initial before a vowel, is consonantal (the
+//      j sound): e-ius, ma-ior, al-le-lu-ia, Ie-su — it opens the next
+//      syllable rather than closing this one.
+//   4. All other adjacent vowels split (ecclesiastical): fi-li-a, glo-ri-a
+//   5. Single consonant between vowels → goes with following vowel (V·CV)
+//   6. Consonant clusters: muta cum liquida (tr, pr, br, gr, dr, cr, fr, pl, bl,
+//      cl, gl, fl) and the Greek digraphs th, ph, ch stay with the following
+//      vowel; all other clusters split after the first consonant
 //
 // Diacritics (áéíóúàèìòùâêîôû etc.) are treated as their base vowel throughout.
 // ── Character classes ──
 const VOWELS = new Set("aeiouyáéíóúàèìòùâêîôûäëïöüæœý");
 const SOFT_HYPHEN = "\u00ad";
-// Latin diphthongs: ae, oe, au, ei are single syllable.
-// eu is not a classical Latin diphthong (de-us, me-us split normally).
-const DIPHTHONGS = new Set(["ae", "oe", "au", "ei", "ui"]);
+// Latin diphthongs treated as single syllables. ei and ui are deliberately
+// absent: in ecclesiastical Latin they are hiatus (De-i, fu-it, su-i) — ui is
+// a true diphthong only in the pronoun stems cui/hui, handled below. eu is not
+// a classical Latin diphthong (de-us, me-us split normally).
+const DIPHTHONGS = new Set(["ae", "oe", "au"]);
 // Muta cum liquida pairs that stay with the following vowel
 const MUTA_CUM_LIQUIDA = new Set([
     "tr",
@@ -58,16 +67,40 @@ function isConsonantBase(ch) {
  *      "ánima"   → ["á", "ni", "ma"]
  */
 export function syllabifyWord(word) {
-    if (word.length <= 2)
+    if (word.length <= 1)
         return [word];
     const chars = Array.from(word);
     const n = chars.length;
-    // Find all vowel positions (base-char aware).
+    const lower = chars.map(baseChar).join("");
+    // A glide u carries no syllable: after q always (qui), and in the ngu
+    // cluster before a vowel (lin-gua, sán-guis) — but a u after plain g is a
+    // real vowel (e-xi-gu-us, ar-gu-it).
+    const isGlideU = (i) => {
+        if (baseChar(chars[i]) !== "u")
+            return false;
+        const prev = i > 0 ? baseChar(chars[i - 1]) : "";
+        if (prev === "q")
+            return true;
+        const prev2 = i > 1 ? baseChar(chars[i - 2]) : "";
+        return prev === "g" && prev2 === "n" && i + 1 < n && isVowelBase(chars[i + 1]);
+    };
+    // A consonantal i (the j sound) carries no syllable of its own — it opens
+    // the following vowel's: between real vowels (e-ius, ma-ior, al-le-lu-ia)
+    // or word-initial before a vowel (Ie-su, iu-bi-lá-te).
+    const isConsonantalI = (i) => {
+        if (baseChar(chars[i]) !== "i")
+            return false;
+        if (i + 1 >= n || !isVowelBase(chars[i + 1]))
+            return false;
+        if (i === 0)
+            return true;
+        return isVowelBase(chars[i - 1]) && !isGlideU(i - 1);
+    };
+    // Find all vowel positions (base-char aware; glides and consonantal i out).
     const vpos = [];
     for (let i = 0; i < n; i++) {
         if (isVowelBase(chars[i])) {
-            const prev = i > 0 ? baseChar(chars[i - 1]) : "";
-            if (baseChar(chars[i]) === "u" && prev === "q")
+            if (isGlideU(i) || isConsonantalI(i))
                 continue;
             vpos.push(i);
         }
@@ -84,6 +117,10 @@ export function syllabifyWord(word) {
             const pair = baseChar(chars[v1]) + baseChar(chars[v2]);
             if (DIPHTHONGS.has(pair))
                 continue;
+            // ui is a true diphthong only in the pronoun stems (cui, huic, and the
+            // cui- compounds); everywhere else it is hiatus (fu-it, su-i).
+            if (pair === "ui" && /^(cui|hui)/.test(lower))
+                continue;
             // All other adjacent vowels split in ecclesiastical Latin
             splits.add(v2);
             continue;
@@ -170,21 +207,57 @@ export function selectVowel(text) {
     const nfd = expanded.normalize("NFD");
     let firstVowel = "";
     let accentedVowel = "";
+    // Every vowel in order with the index it sat at, so the diphthong pass below
+    // can ask whether two of them are adjacent in the source.
+    const found = [];
     for (let i = 0; i < nfd.length; i++) {
         const ch = nfd[i];
         const base = ch.replace(/[\u0300-\u036f]/g, "").toLowerCase();
         if (!isVowelBase(base))
             continue;
         const v = base === "y" ? "i" : base;
+        found.push({ v, at: i });
         if (!firstVowel)
             firstVowel = v;
         if (!accentedVowel && i + 1 < nfd.length && ACCENTED.test(nfd[i + 1])) {
             accentedVowel = v;
         }
     }
-    if (accentedVowel)
-        return { vowel: accentedVowel, accent: true };
-    return { vowel: firstVowel, accent: false };
+    const vowel = accentedVowel || firstVowel;
+    return { vowel, accent: Boolean(accentedVowel), diphthong: findDiphthong(nfd, found, vowel) };
+}
+/**
+ * The diphthong the SUNG vowel belongs to, or null. `vowel` is the nucleus — what
+ * a singer sustains — and a diphthong's second element is a late off-glide; this
+ * reports the pair so a renderer can flick toward it without re-deriving which
+ * pairs are real.
+ *
+ * It reuses the syllabifier's own DIPHTHONGS set, so "diphthong" here means
+ * exactly what it means when the word is split: ae · oe · au, plus ui in the
+ * cui/hui stems only. ei, ui elsewhere, and eu are hiatus (De-i, fu-it, de-us).
+ *
+ * THE ACCENT IS THE DISCRIMINATOR, which is why this cannot be recovered
+ * downstream from the lyric alone. `cae` is one syllable (nucleus a, glide e);
+ * `sa-é` is two — the same letters with the accent on the second, and no glide.
+ * A substring scan confuses the two, and also misreads `quae`, where `qu` is a
+ * consonantal glide: the nucleus is u, and the `ae` is not the sung pair.
+ */
+function findDiphthong(nfd, found, vowel) {
+    const lower = [...nfd].map(baseChar).join("");
+    for (let i = 0; i < found.length - 1; i++) {
+        const a = found[i];
+        const b = found[i + 1];
+        // Adjacent in the source, and the pair's nucleus is the vowel we selected —
+        // anything else belongs to a different syllable.
+        if (b.at !== a.at + 1 || a.v !== vowel)
+            continue;
+        const pair = a.v + b.v;
+        if (DIPHTHONGS.has(pair))
+            return pair;
+        if (pair === "ui" && /^(cui|hui)/.test(lower))
+            return pair;
+    }
+    return null;
 }
 export function detectVowelAccent(text) {
     return selectVowel(text).accent;

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

@@ -1,12 +1,44 @@
 import type { Season, Grade, Feast } from "../cal/types.js";
 export type { Season, Grade, Feast };
-export type OfficeCode = "an" | "al" | "ca" | "co" | "gr" | "hy" | "in" | "of" | "ps" | "re" | "rb" | "se" | "tr" | "tp" | "or";
+export type OfficeCode = "an" | "al" | "ca" | "co" | "gr" | "hy" | "in" | "of" | "ps" | "re" | "rb" | "se" | "tr" | "tp" | "or" | "im" | "pa" | "su";
 export type OrdinaryCode = "ky" | "gl" | "cr" | "sa" | "ag" | "be" | "it" | "as" | "va";
-export type ChantSource = "gr" | "lu" | "la" | "lh" | "am" | "nr";
+/**
+ * The books a chant can come from. `source` is PROVENANCE, not an acquisition
+ * unit: a book appears here because some chant the liturgy asks for is found in
+ * it, not because the whole book ships.
+ *
+ * The first seven are the original corpus. The office books after them widened
+ * it: they carry antiphons and short responsories that fill weekday office
+ * slots — without them a matcher could only bind a slot to a chant the five
+ * extracted books happened to hold, which is why 41 Fridays had no Vespers
+ * ("Per singulos dies" lives in the Psalterium Monasticum).
+ *
+ * That widening brought in eight; six are gone again. am1, am2,
+ * am3, lr, ar1 and ar2 are bare transcriptions — no episema, no ictus,
+ * essentially no mora — so once the office matchers began preferring a
+ * rhythmically marked witness, every text they carried was better served by a
+ * book we already ship. tonus reads those marks for playback, so a bare chant is
+ * a worse copy, not a missing one.
+ *
+ * ams and psm stayed because they are fully marked, and psm holds "Per singulos
+ * dies" — the Friday Vespers antiphon the widening was for. Every chant tonus
+ * now ships carries rhythmic notation.
+ */
+export type ChantSource = "gr" | "lu" | "la" | "lh" | "am" | "nr" | "ams" | "psm" | "cse" | "cot";
 export type CanonicalHour = "matutinum" | "laudes" | "prima" | "tertia" | "sexta" | "nona" | "vesperae" | "completorium";
-export declare const MODE_LABELS: Readonly<Record<string, string>>;
-export declare const OFFICE_LABELS: Readonly<Record<OfficeCode, string>>;
-export declare const ORDINARY_LABELS: Readonly<Record<string, string>>;
+/** The eight canonical hours in the order they are sung, Matins first. The
+ *  order is the content: a day's office read out of sequence is not the day's
+ *  office. `officium` validates `hora` against this, so the list a caller reads
+ *  and the check it must satisfy cannot drift apart. */
+export declare const HORAE: readonly CanonicalHour[];
+/** The keys cantus() accepts — the base set the day verbs extend. Lives here,
+ *  cycle-free, so ordinary.ts can build its own key set without importing
+ *  chant.ts (the two are an import cycle). */
+export declare const CANTUS_QUERY_KEYS: Set<string>;
+export declare const MODI: Readonly<Record<string, string>>;
+export declare const OFFICIA: Readonly<Record<OfficeCode, string>>;
+export declare const ORDINARIA: Readonly<Record<string, string>>;
+export declare const KY_SOURCE: Chant["source"];
 export interface Chant {
     id: string;
     incipit: string;
@@ -27,7 +59,7 @@ export interface Chant {
         year: number | null;
         editor: string | null;
         scanSource?: string | null;
-        code?: ChantSource | "user";
+        code?: ChantSource | "user" | "ky";
     };
     ordinary?: OrdinaryCode;
     ordinarium?: string;
@@ -61,12 +93,56 @@ export interface Corpus {
     editor: string | null;
     scanSource: string | null;
     count: number;
+    total: number | null;
+    unique: number | null;
+    shared: SharedCount[] | null;
+    genera: GenusCount[];
+    modes: ModeCount[];
+    /**
+     * What the book HOLDS, before the cut — the ledger of what was left behind.
+     * Same genera/modes shape as the shipped counts above, so an omission is
+     * visible rather than merely implied by a smaller number. `null` for a book
+     * outside GregoBase (nr, ky), the same "unmeasured, not zero" rule as
+     * `total`/`unique`/`shared`.
+     */
+    full: CorpusFullCount | null;
+}
+/** A book's pre-cut tally, in the shape `corpus()` reports the shipped one. */
+export interface CorpusFullCount {
     total: number;
-    unique: number;
-    shared: SharedCount[];
     genera: GenusCount[];
     modes: ModeCount[];
 }
+/**
+ * The whole shelf: every book's ledger, and the corpus-wide rollup.
+ * Returned by `corpus()` with no argument.
+ */
+export interface CorpusLedger {
+    /**
+     * How many chants tonus holds — every chant it can name, counted once.
+     *
+     * This is THE number: distinct chants, so it does not move with how many
+     * books happen to print the same melody. Listings are `listings` below —
+     * a fact about the shelf, not about the repertoire.
+     */
+    count: number;
+    /**
+     * Book listings across the shelf: a chant printed in two books counts twice.
+     * `listings - count` is how much the books overlap. Secondary on purpose —
+     * it answers "how long is the shelf", not "how much chant is there".
+     */
+    listings: number;
+    /** Chants the books hold in total, before the cut. */
+    total: number;
+    genera: GenusCount[];
+    modes: ModeCount[];
+    /** Per book, in corpus order. */
+    books: Corpus[];
+}
+/** `corpus({ book })` — the query form; `corpus(code)` still works. */
+export interface CorpusQuery {
+    book?: ChantSource;
+}
 export interface CantusQuery {
     id?: string | string[];
     gabc?: string;
@@ -74,6 +150,37 @@ export interface CantusQuery {
     mode?: number | string | (number | string)[];
     office?: OfficeCode | OfficeCode[];
     source?: ChantSource | ChantSource[];
+    /**
+     * A part of the Mass ordinary — `"ky"` for the Kyries, `"gl"` the Glorias,
+     * and so on. This is the door to the Kyriale, which is addressable but not
+     * shelved (it is a partition of the Graduale, not a book), so it is absent
+     * from `source` and from an unfiltered search. Asking for an ordinary can
+     * only mean one thing, which is why it may reach where `mode` alone does not.
+     *
+     * For the setting a given DAY calls for, `ordinarium({ feast })` is the verb:
+     * it applies the Kyriale's own rubrics. This is the flat retrieval — every
+     * Kyrie in the book, whatever day would sing it.
+     */
+    ordinary?: OrdinaryCode | OrdinaryCode[];
+    /**
+     * Only chants ATTESTED by this year — the repertoire as of a date, the
+     * analogue of `festum({ before })`, and the two COMPOSE: a Feast resolved by
+     * `festum({ date, before })` carries the view, and every day verb (proprium,
+     * ordinarium, officium) serves under it without being told the year twice;
+     * an own `before` overrides the feast's. Only centuries wholly CLOSED by
+     * the year count as witnessed: `before: 1098` keeps what a manuscript of
+     * the 10th century or earlier already holds (see attest.ts for why).
+     *
+     * This is evidence, not existence: the date comes from CANTUS's manuscript
+     * index, so it is a terminus ante quem. A chant with no dated witness is
+     * excluded rather than assumed old — silence is not evidence of age.
+     * This is the ONE time argument: a `century` spelling is deliberately
+     * absent, because it was `before: N * 100` in different clothes — one
+     * cutoff internally, two spellings at the door (see attest.ts).
+     */
+    before?: number;
+    /** Only chants transmitted by this cursus; `both` always qualifies. */
+    cursus?: "monastic" | "secular";
     limit?: number;
     offset?: number;
     sort?: "incipit" | "mode" | "id";
@@ -86,13 +193,9 @@ export interface OrdinariumQuery extends CantusQuery {
     ordinary?: OrdinaryCode;
     mass?: number;
 }
-/** Which rite's Office to assemble. `romanum` (default) is the Tridentine Roman
- *  cursus; `monasticum` is the Benedictine cursus (Antiphonale Monasticum). */
-export type Rite = "romanum" | "monasticum";
 export interface OfficiumQuery extends CantusQuery {
     feast?: Feast | Feast[];
     hora?: CanonicalHour;
-    rite?: Rite;
 }
 export interface PsalmusQuery {
     psalm?: number | string;

package/dist/engines/chant/types.js

@@ -1,9 +1,24 @@
+/** The eight canonical hours in the order they are sung, Matins first. The
+ *  order is the content: a day's office read out of sequence is not the day's
+ *  office. `officium` validates `hora` against this, so the list a caller reads
+ *  and the check it must satisfy cannot drift apart. */
+export const HORAE = Object.freeze([
+    "matutinum", "laudes", "prima", "tertia", "sexta", "nona",
+    "vesperae", "completorium",
+]);
 // ── Display labels ──
-export const MODE_LABELS = Object.freeze({
+/** The keys cantus() accepts — the base set the day verbs extend. Lives here,
+ *  cycle-free, so ordinary.ts can build its own key set without importing
+ *  chant.ts (the two are an import cycle). */
+export const CANTUS_QUERY_KEYS = new Set([
+    "id", "gabc", "incipit", "mode", "office", "source", "limit", "offset", "sort",
+    "before", "cursus", "ordinary",
+]);
+export const MODI = Object.freeze({
     "1": "Modus I", "2": "Modus II", "3": "Modus III", "4": "Modus IV",
     "5": "Modus V", "6": "Modus VI", "7": "Modus VII", "8": "Modus VIII",
 });
-export const OFFICE_LABELS = Object.freeze({
+export const OFFICIA = Object.freeze({
     an: "Antiphona",
     al: "Alleluia",
     ca: "Canticum",
@@ -16,11 +31,15 @@ export const OFFICE_LABELS = Object.freeze({
     re: "Responsorium",
     rb: "Responsorium Breve",
     se: "Sequentia",
+    // Reported in the pre-cut tallies, not shipped — see OfficeCode above.
+    im: "Improperia", // the Good Friday Reproaches (Popule meus)
+    pa: "Antiphona Mariana", // Marian antiphons outside the office cycle
+    su: "Supplicatio", // litanies and supplications (the Easter Vigil litany)
     tr: "Tractus",
     tp: "Tonus Peregrinus",
     or: "Ordinarium",
 });
-export const ORDINARY_LABELS = Object.freeze({
+export const ORDINARIA = Object.freeze({
     ky: "Kyrie eleison",
     gl: "Gloria",
     cr: "Credo",
@@ -31,4 +50,20 @@ export const ORDINARY_LABELS = Object.freeze({
     as: "Asperges",
     va: "Vidi aquam",
 });
+// The Kyriale's bibliographic identity. NOT a ChantSource: `ky` is a partition
+// of the Graduale, not a book of its own (chant.ts, CORPUS), so it is not a
+// value `cantus({ source })` takes and not a row in the shelf. This record
+// still rides every kyriale chant, because a chant should say which book it is
+// printed in — and the Kyriale is what a singer would be holding.
+// Hand-authored (the other books' SOURCE constants ride their generated data
+// files; the kyriale's data file predates its book registration): the chants
+// are the Kyriale section of the 1961 Solesmes Graduale Romanum, extracted
+// from GregoBase GR source pages. Shared by the corpus surface (chant.ts) and
+// the ordinary engine so a kyriale chant carries ONE identity everywhere.
+export const KY_SOURCE = Object.freeze({
+    book: "Kyriale (Graduale Romanum)",
+    year: 1961,
+    editor: "Solesmes",
+    code: "ky",
+});
 //# sourceMappingURL=types.js.map

package/dist/engines/harmonia/api.js

@@ -63,6 +63,10 @@ export function buildHarmonia(input, opts = {}) {
     if (cosmosArray.length === 0) {
         throw new RangeError("harmonia requires at least one Cosmos");
     }
+    for (const c of cosmosArray) {
+        if (!c || typeof c !== "object" || !Array.isArray(c.bodies))
+            throw new Error("harmonia: input must be a Cosmos (from tonus.caelum) — its bodies are what get voiced");
+    }
     const temper = opts.temperamentum ?? buildTemper();
     const scale = resolveScale(temper);
     const doctrinaKey = opts.doctrina ?? "boethius";

package/dist/engines/harmonia/data/doctrines.js

@@ -7,7 +7,9 @@
 // as [numerator, denominator] pairs.
 //
 // All v1 doctrinae are geocentric — Earth is the silent listener at the
-// center, not a voiced body (except Pliny, where Earth is a boundary tone).
+// center, not a voiced body. Pliny's table does assign Earth a boundary tone
+// (proslambanomenos, kept below as documentation), but Earth carries no
+// classical vowel, so the voicing engine leaves it silent there too.
 // The Sun holds the mese position in all four systems.
 //
 // The ratios are reconstructed from the primary texts [biblio:

package/dist/engines/harmonia/tabula.d.ts

@@ -11,6 +11,9 @@ export interface HarmonyTabulaRow {
     oct: number;
     spn: string;
     hz: number;
+    /** The doctrina's ratio against the mese, [num, den] — what the sphere IS
+     *  in the scheme, of which spn and hz are the sounding. */
+    ratio: readonly [number, number];
     presence: number;
     motion: number;
     velocity: number;

package/dist/engines/harmonia/tabula.js

@@ -15,6 +15,7 @@ export function computeHarmonyTabula(bodies, aspects) {
         oct: b.nota.pitch.oct,
         spn: b.nota.pitch.spn,
         hz: b.nota.pitch.hz,
+        ratio: b.ratio,
         presence: b.presence,
         motion: b.motion,
         velocity: b.nota.performance.velocity,

package/dist/engines/harmonia/voice.d.ts

@@ -13,6 +13,10 @@ export interface VoicedBody extends Body {
     presence: number;
     motion: number;
     greekName: string;
+    /** The doctrina's own ratio for this sphere, [num, den] against the mese.
+     *  The pitch is DERIVED from it, so this is the primary datum and the note
+     *  name is the reading — a caller comparing doctrinae wants the fraction. */
+    ratio: readonly [number, number];
     vowel: PlanetVowel;
 }
 export declare function voiceBodies(bodies: Body[], doctrina: Doctrina, scale: Scale): VoicedBody[];

package/dist/engines/harmonia/voice.js

@@ -5,9 +5,8 @@ import { computePresence, computeMotion } from "./presence.js";
 // reference. Ratios in the doctrina are multiplied by this anchor to produce Hz.
 const ANCHOR_MIDI = 69;
 function voiceOne(body, voice, vowel, scale) {
-    const pliny = voice.greekName === "proslambanomenos" && body.name === "Earth";
-    const presence = pliny ? 1 : computePresence(body);
-    const motion = pliny ? 0 : computeMotion(body);
+    const presence = computePresence(body);
+    const motion = computeMotion(body);
     // Direct Hz from anchor (A4) and doctrina ratio — bypass scale quantization
     // so the ratio's pure Hz relationship is preserved.
     const ratioVal = voice.ratio[0] / voice.ratio[1];
@@ -28,6 +27,7 @@ function voiceOne(body, voice, vowel, scale) {
         presence,
         motion,
         greekName: voice.greekName,
+        ratio: voice.ratio,
         vowel,
     };
 }
@@ -41,9 +41,13 @@ export function voiceBodies(bodies, doctrina, scale) {
         const voice = voiceByBody.get(body.name);
         if (!voice)
             continue; // body not part of this doctrina (e.g. Earth in Boethius)
+        // Only the seven vowel-bearing planets voice. Earth stays silent even
+        // under Pliny, whose table assigns it proslambanomenos — the ratio is
+        // kept in the doctrina as documentation, but no classical vowel exists
+        // for Earth, and tonus does not invent one.
         const vowel = PLANET_VOWELS[body.name];
         if (!vowel)
-            continue; // body has no classical vowel mapping (e.g. Earth, FixedStars)
+            continue;
         result.push(voiceOne(body, voice, vowel, scale));
     }
     return result;

package/dist/engines/imprint.js

@@ -84,6 +84,10 @@ export function computeImprint(phrases, scale, opts = {}) {
     const cadenceNotes = opts.cadenceNotes;
     const pcCounts = new Array(12).fill(0);
     let total = 0;
+    // For the tessitura signal: the mean MIDI of every note, and the last note.
+    let midiSum = 0;
+    let noteCount = 0;
+    let lastNote = null;
     for (let pi = 0; pi < phrases.length; pi++) {
         const phrase = phrases[pi];
         for (let si = 0; si < phrase.syllables.length; si++) {
@@ -97,6 +101,9 @@ export function computeImprint(phrases, scale, opts = {}) {
                     w *= CADENCE_WEIGHT;
                 pcCounts[note.pitch.pc] += w;
                 total += w;
+                midiSum += note.pitch.midi;
+                noteCount++;
+                lastNote = { pc: note.pitch.pc, midi: note.pitch.midi };
             }
         }
     }
@@ -105,11 +112,17 @@ export function computeImprint(phrases, scale, opts = {}) {
         pcDistribution[pc] = total > 0 ? pcCounts[pc] / total : 0;
     }
     const firstNotePc = phrases[0]?.syllables[0]?.notes[0]?.pitch.pc;
+    // Tessitura = the melody's mean height above where it comes to rest.
+    const tessitura = lastNote && noteCount > 0 ? midiSum / noteCount - lastNote.midi : undefined;
     return {
         pcDistribution,
         attractors: computeAttractors(pcDistribution, scale),
         vowelAttractors: computeVowelAttractors(phrases, scale),
-        modalAffinity: computeModalAffinity(pcDistribution, firstNotePc),
+        modalAffinity: computeModalAffinity(pcDistribution, {
+            firstNotePc,
+            lastNotePc: lastNote?.pc,
+            tessitura,
+        }),
     };
 }
 /** Build an Imprint from voiced planetary bodies (presence-weighted pc counts). */

package/dist/engines/planet/orbital.js

@@ -34,7 +34,7 @@ export const ORBITAL_ELEMENTS = new Map([
             datasets: [
                 [
                     [0.72333566, 0.0000039],
-                    [0.00676399, -0.00005107],
+                    [0.00677672, -0.00004107],
                     [3.39467605, -0.0007889],
                     [181.9790995, 58517.81538729],
                     [131.60246718, 0.00268329],
@@ -42,7 +42,7 @@ export const ORBITAL_ELEMENTS = new Map([
                 ],
                 [
                     [0.72332102, -0.00000026],
-                    [-0.00005107, 0.01673163],
+                    [0.00676399, -0.00005107],
                     [3.39777545, 0.00043494],
                     [181.9797085, 58517.8156026],
                     [131.76755713, 0.05679648],
@@ -68,7 +68,7 @@ export const ORBITAL_ELEMENTS = new Map([
                     [0, 0],
                 ],
                 [
-                    [1.00000018, 1.52371243],
+                    [1.00000018, -0.00000003],
                     [0.01673163, -0.00003661],
                     [-0.00054346, -0.01337178],
                     [100.46691572, 35999.37306329],
@@ -129,7 +129,7 @@ export const ORBITAL_ELEMENTS = new Map([
                     [14.27495244, 0.18199196],
                     [100.29282654, 0.13024619],
                 ],
-                [0.00012452, 0.0606406, -0.35635438, 38.35125],
+                [-0.00012452, 0.0606406, -0.35635438, 38.35125],
             ],
             radius: 69911,
             rotation_period: 0.41354,