tonus 0.1.8 → 0.5.0

package/dist/engines/temper/modality.js

@@ -12,6 +12,35 @@ const FINALIS_WEIGHT = 3;
 const TENOR_WEIGHT = 2;
 const REGULAR_MOD_WEIGHT = 1;
 const CONCEDED_MOD_WEIGHT = 0.5;
+// `ModeData.recitingNotes` (see data/modes.ts) carries more than the
+// principal tenor for several modes — auxiliary/secondary/pseudo/rare
+// reciting notes, sourced from the Gregorian Modes Degree Summary Tables.
+// A first attempt at wiring this in weighted every rank into degreeWeight
+// unconditionally (via the same max-of-roles `set` used below) and broke
+// ../../../tests/modality.test.mjs's authentic/plagal initials-bonus case for
+// modes 7/8: that test relies on an exact baseline tie between the pair, broken
+// only by the initials bonus. Mode 7's new auxiliary pc 0 partly overlapped
+// a pc it already carried as a conceded modulation degree (weight 0.5),
+// and "same rank, same weight" silently PROMOTED that existing pc to the
+// higher auxiliary weight — mode 8 had no equivalent already-weighted pc to
+// promote, so the promotion alone tipped the tie before the initials bonus
+// got a chance to run.
+//
+// The fix below is additive-only: a non-principal reciting note contributes
+// weight ONLY to a pc that isn't already weighted by the finalis, the tenor,
+// or a modulation degree (see the second loop after `set(data.final, ...)`).
+// It never promotes an existing weight. That keeps the 7/8 tie intact — both
+// modes pick up their (as it happens, shared) new auxiliary pc 11 identically
+// — while still letting genuinely new degrees (e.g. mode 4's pseudo-tenor at
+// pc 5, mode 5's rare recitation on its own final) contribute real signal.
+// `principal` entries are skipped outright: by construction they already
+// coincide with `data.tenor` or `data.final` and would always be a no-op.
+const RECITING_WEIGHT = {
+    auxiliary: 1.2,
+    secondary: 0.8,
+    pseudo: 0.5,
+    rare: 0.3,
+};
 // A chant's opening note is a modal signal: each mode lists its valid initials
 // in rank order, most characteristic first (Rockstro's Grove ordering
 // [biblio: rockstro-grove]). Opening on a mode's primary initial boosts it more
@@ -19,11 +48,33 @@ const CONCEDED_MOD_WEIGHT = 0.5;
 // from its plagal partner, since the two share a finalis but rank the same
 // opening pitch differently.
 const INITIAL_BONUS = 0.3;
+// The last note is the treatises' first determinant of mode: a chant comes to
+// rest on its final. Landing on a mode's final is the single strongest signal.
+const FINAL_NOTE_BONUS = 0.5;
+// Tessitura — how high the melody sits above its final — is the classical
+// authentic/plagal separator (an authentic mode ranges a fifth-and-more above the
+// final; its plagal partner straddles it). The bonus peaks when the observed
+// tessitura matches the mode's expected value and falls off linearly over
+// TESSITURA_TOLERANCE.
+//
+// THE CALIBRATION IS PENDING RE-DERIVATION (noted 2026-08-11). These constants
+// were fitted over the corpus at n≈6,666 — a count from before the accidental
+// fix in `parse.ts`, which was emitting a phantom note at every accidental and
+// so moved every mean pitch that used one. The SEPARATION still holds on a
+// re-measure (authentic sits higher than plagal, cleanly), which is what these
+// constants encode, so they are left in force rather than replaced by a worse
+// number. What is not yet re-derived is where exactly the two centres sit.
+const TESSITURA_AUTHENTIC = 4.0;
+const TESSITURA_PLAGAL = 1.7;
+const TESSITURA_TOLERANCE = 3;
+const TESSITURA_WEIGHT = 1.0;
 /**
  * Rank a pitch-class distribution against the eight modes, best fit first.
- * `firstNotePc`, when given, applies the rank-weighted initials bonus.
+ * The optional signals sharpen the ranking: the opening note (initials bonus),
+ * the closing note (final-note bonus), and the tessitura (authentic/plagal).
  */
-export function computeModalAffinity(pcDistribution, firstNotePc) {
+export function computeModalAffinity(pcDistribution, opts = {}) {
+    const { firstNotePc, lastNotePc, tessitura } = opts;
     const results = [];
     for (let m = 1; m <= 8; m++) {
         const data = MODES.get(m);
@@ -41,6 +92,16 @@ export function computeModalAffinity(pcDistribution, firstNotePc) {
             set(pc % 12, REGULAR_MOD_WEIGHT);
         set(data.tenor, TENOR_WEIGHT);
         set(data.final, FINALIS_WEIGHT);
+        // Additive-only pass: see the comment on RECITING_WEIGHT above for why
+        // this fills in gaps rather than using `set` (which would promote an
+        // existing weight, not just add a new one).
+        for (const rn of data.recitingNotes) {
+            if (rn.rank === "principal")
+                continue;
+            const pc = rn.pc % 12;
+            if (!degreeWeight.has(pc))
+                degreeWeight.set(pc, RECITING_WEIGHT[rn.rank]);
+        }
         let score = 0;
         for (const [pc, w] of degreeWeight)
             score += (pcDistribution[pc] ?? 0) * w;
@@ -51,6 +112,17 @@ export function computeModalAffinity(pcDistribution, firstNotePc) {
             if (rank !== -1)
                 score += (INITIAL_BONUS * (initials.length - rank)) / initials.length;
         }
+        // Final-note + tessitura: only apply when the chant actually rests on this
+        // mode's final. The tessitura then separates the mode from its authentic/
+        // plagal partner (which share the final but sit at different heights).
+        if (lastNotePc != null && lastNotePc === data.final % 12) {
+            score += FINAL_NOTE_BONUS;
+            if (tessitura != null) {
+                const expected = data.type === "authentic" ? TESSITURA_AUTHENTIC : TESSITURA_PLAGAL;
+                const fit = Math.max(0, 1 - Math.abs(tessitura - expected) / TESSITURA_TOLERANCE);
+                score += TESSITURA_WEIGHT * fit;
+            }
+        }
         results.push({ mode: m, alias: data.alias, score });
     }
     return results.sort((a, b) => b.score - a.score);

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

@@ -1,5 +1,5 @@
 import type { ModeData } from "./data/modes.js";
-export type { ModeProfile, ModeData, CadenceFigure } from "./data/modes.js";
+export type { ModeProfile, ModeData, CadenceFigure, RecitingNote } from "./data/modes.js";
 export { MODES } from "./data/modes.js";
 /** Return ModeData for mode 1–8. Throws on unknown mode. */
 export declare function getMode(mode: number): ModeData;

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

@@ -35,6 +35,6 @@ export interface PitchContext {
     a4?: number;
 }
 export declare function parsePitch(input: PitchInput, ctx?: PitchContext): number;
-export declare function toPitch(input: PitchInput, scale: Scale): Pitch;
+export declare function toPitch(input: PitchInput, scale: Scale, prefer?: "flat" | "sharp"): Pitch;
 export declare function scaleDegreeInMode(midi: number, mode: number): number | null;
 //# sourceMappingURL=pitch.d.ts.map

package/dist/engines/temper/pitch.js

@@ -62,13 +62,23 @@ export function parsePitch(input, ctx = {}) {
 // Resolves a PitchInput through a Scale into a tuned Pitch.
 // Applies the Scale's transpose and returns a Pitch with midi/pc/oct/spn
 // from the transposed MIDI plus tuning-derived hz/offset/bend/ratio.
-export function toPitch(input, scale) {
+export function toPitch(input, scale, prefer) {
     const rawMidi = parsePitch(input, { mode: scale.mode, a4: scale.a4 });
     const { hz, offset, bend } = midiToHz(rawMidi, scale);
     const midi = clamp(rawMidi + scale.transpose);
     const pc = midi % 12;
     const oct = Math.floor(midi / 12) - 1;
-    const useFlat = PREFER_FLAT_PCS.has(pc);
+    // Spell as the source WROTE it when the caller knows. Deriving the spelling
+    // from the pitch class alone cannot: pc 1 is D-flat in a chant that wrote a
+    // flat and C-sharp in one that wrote a sharp, and the class is identical.
+    // PREFER_FLAT_PCS ({3, 8, 10}) is a reasonable default but omits pc 1 and 6,
+    // so a written flat landing there came back spelled — and reported in `acc` —
+    // as a SHARP, the opposite of what the source said.
+    //
+    // The Graduale only ever writes B-flat (pc 10, the bmolle), so the corpus
+    // never reached the gap; `notatio` passes the hint because a caller may set
+    // any GABC accidental on any degree.
+    const useFlat = prefer ? prefer === "flat" : PREFER_FLAT_PCS.has(pc);
     const sp = useFlat ? FLAT_SPELLING[pc] : SHARP_SPELLING[pc];
     const accStr = sp.acc === -1 ? "b" : sp.acc === 1 ? "#" : "";
     const spn = `${sp.step}${accStr}${oct}`;

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

@@ -20,6 +20,15 @@ export interface RatioResult {
     cents: number;
     display: string;
 }
+/** Stern-Brocot rational approximation — the nearest simple fraction to a
+ *  decimal ratio, as `[numerator, denominator]`.
+ *
+ *  Exported because `toRatio` only reaches it through a STRING, and a caller
+ *  holding a computed ratio (a gamut row's `ratio`, a string fraction derived
+ *  from two frequencies) has a number. Without this the caller writes the
+ *  search again — which is how the site came to carry a second copy of this
+ *  same algorithm. */
+export declare function approximate(value: number, maxDen?: number): [number, number];
 export declare function toRatio(input: string): RatioResult;
 export declare function parseStep(v: number | string): number;
 export interface ScalaFile {
@@ -28,6 +37,50 @@ export interface ScalaFile {
 }
 export declare function parseScala(input: string): ScalaFile;
 export declare function getPtolemaicRatios(tuning: string): string[] | undefined;
+/**
+ * The pure-fifth chain's ET-cents deviation per pitch class, anchored A = 0
+ * (the a4-reference anchor `offset` carries under the default tuning). The
+ * heji/cents accidental baseline reads THIS, so the emitters and the engine
+ * can never disagree about the chain's spelling.
+ */
+export declare function pythagoreanCentsByPc(): number[];
+/** The wolf: what is left of the octave when the chain of fifths runs out. */
+export interface Lupus {
+    /** Pitch class the wolf is measured UP from — the chain's last link. */
+    from: number;
+    /** Pitch class it lands on — the chain's first. */
+    to: number;
+    /** The two, spelled as the chain spells them. */
+    spn: [string, string];
+    /** Its size, tempered, in cents. */
+    cents: number;
+    /** A pure fifth, for the comparison this exists to invite. */
+    pure: number;
+    /** Signed: positive is wide of a pure fifth, negative narrow. */
+    fromPure: number;
+}
+/**
+ * THE WOLF, from the chain the ratios are built on.
+ *
+ * Twelve fifths do not close an octave. Stack them from E♭ and the twelfth
+ * lands beside the first rather than on it, and the gap it leaves has to go
+ * somewhere: it goes into the one interval nobody stacked, G♯ up to E♭. That
+ * interval is a fifth by position and not by size, which is why it howls.
+ *
+ * Under pure fifths it comes out NARROW (678.5¢, the Pythagorean comma taken
+ * out of it). Temper the fifths and the leftover grows: every cent taken off
+ * eleven fifths is given back to this one, so it passes a pure fifth and goes
+ * wide (737.6¢ at quarter-comma). That sign change is the thing a reader of
+ * the slider is watching, and it is why `fromPure` is signed.
+ *
+ * Derived from the SAME walk `buildPythagoreanRatios` does, deliberately.
+ * There is a closed form (1200·7 − 11·fifth, which agrees to the decimal),
+ * but two derivations of one number is how they drift apart.
+ *
+ * Null when no chain built the scale: a Ptolemaic genus and a custom Scala
+ * list are given as ratios, and have no fifths chain to leave a remainder.
+ */
+export declare function wolfOf(commaN: number): Lupus;
 export declare function buildRatios(opts?: ScaleOpts): Scale;
 export declare function midiToHz(midi: number, scala: Scale): {
     hz: number;

package/dist/engines/temper/scale.js

@@ -20,8 +20,15 @@
 // ptolemy-harmonics, Harmonics I.15–16]. See expandDiatonicSteps for how a
 // 7-ratio genus is laid onto the fixed gamut, and why.
 import { MODES } from "./modes.js";
-// Stern-Brocot rational approximation — finds nearest simple fraction
-function approximate(value, maxDen = 1000) {
+/** Stern-Brocot rational approximation — the nearest simple fraction to a
+ *  decimal ratio, as `[numerator, denominator]`.
+ *
+ *  Exported because `toRatio` only reaches it through a STRING, and a caller
+ *  holding a computed ratio (a gamut row's `ratio`, a string fraction derived
+ *  from two frequencies) has a number. Without this the caller writes the
+ *  search again — which is how the site came to carry a second copy of this
+ *  same algorithm. */
+export function approximate(value, maxDen = 1000) {
     if (value === Math.round(value))
         return [Math.round(value), 1];
     let [a, b, c, d] = [0, 1, 1, 0];
@@ -128,9 +135,16 @@ export function parseScala(input) {
 }
 const PURE_FIFTH = 3 / 2;
 const SYNTONIC_COMMA = 81 / 80;
-// The circle of fifths, as chromatic pitch classes: C G D A E B F♯ … stacking
-// twelve 3/2s. buildPythagoreanRatios walks this and octave-folds each.
-const FIFTH_TO_CHROM = [0, 7, 2, 9, 4, 11, 6, 1, 8, 3, 10, 5];
+// The chain of fifths as chromatic pitch classes, running E♭–G♯:
+//   E♭ B♭ F C G D A E B F♯ C♯ G♯
+// The naturals sit F–B (ut–fa is a pure 4/3 — b molle exists precisely to make
+// that fourth over F), b molle and E♭ take the flat side, the ficta sharps
+// (F♯ C♯ G♯) the sharp side. This is the received medieval dodecachord; an
+// ascending-only chain from C would spell F as E♯ (a wolf ut–fa of 521.5¢)
+// and b molle as A♯. buildPythagoreanRatios walks this and octave-folds each.
+// The heji/cents baseline in score/emitters/accidentals.ts derives from this
+// same chain via pythagoreanCentsByPc() — keep them coupled.
+const FIFTH_TO_CHROM = [3, 10, 5, 0, 7, 2, 9, 4, 11, 6, 1, 8];
 // Ptolemy's three diatonic genera [biblio: ptolemy-harmonics, Harmonics I.15–16],
 // each a tetrachord (1/1 … 4/3) doubled up a 3/2 to fill the octave:
 //   intense (syntonon)  — classical just intonation: pure 5/4 major, 6/5 minor.
@@ -144,6 +158,18 @@ const PTOLEMAIC = {
 export function getPtolemaicRatios(tuning) {
     return PTOLEMAIC[tuning];
 }
+/**
+ * The pure-fifth chain's ET-cents deviation per pitch class, anchored A = 0
+ * (the a4-reference anchor `offset` carries under the default tuning). The
+ * heji/cents accidental baseline reads THIS, so the emitters and the engine
+ * can never disagree about the chain's spelling.
+ */
+export function pythagoreanCentsByPc() {
+    const ratios = buildPythagoreanRatios(0); // C-anchored, folded to [1, 2)
+    const cents = ratios.map((r, pc) => 1200 * Math.log2(r) - 100 * pc);
+    const anchor = cents[9];
+    return cents.map((c) => Math.round((c - anchor) * 100) / 100);
+}
 function buildPythagoreanRatios(commaN) {
     const tf = commaN === 0
         ? PURE_FIFTH
@@ -153,9 +179,13 @@ function buildPythagoreanRatios(commaN) {
         const pc = FIFTH_TO_CHROM[k];
         out[pc] = foldOct(tf ** k);
     }
+    // Anchor on C and fold each pitch class into the C-register [1, 2): the
+    // table's contract is "ascending within the C octave, then normalized to
+    // root". The E♭–G♯ chain reaches some pcs below C, so without this fold the
+    // table comes out octave-scrambled (A at 27/32, a broken ratio() matcher).
     const root = out[0] ?? 1;
     for (let i = 0; i < 12; i++)
-        out[i] = (out[i] ?? 1) / root;
+        out[i] = foldOct((out[i] ?? 1) / root);
     return out;
 }
 // The natural (white-key) pitch classes in ascending pitch order: C D E F G A B.
@@ -191,7 +221,52 @@ function normalizeToRoot(ratios, rootPc) {
 function ratiosToCents(ratios) {
     return ratios.map((r) => 1200 * Math.log2(r));
 }
-// ── Public ──
+const PURE_FIFTH_CENTS = 1200 * Math.log2(3 / 2);
+// The chain's own spelling, in its own order. A wolf is named by where it
+// falls in the chain, not by an enharmonic the gamut might prefer: the
+// interval G♯–E♭ is the wolf, and calling either end by its other name
+// ("A♭–D♯") describes a different reading of the same two frequencies.
+const CHAIN_SPELLING = ["Eb", "Bb", "F", "C", "G", "D", "A", "E", "B", "F#", "C#", "G#"];
+/**
+ * THE WOLF, from the chain the ratios are built on.
+ *
+ * Twelve fifths do not close an octave. Stack them from E♭ and the twelfth
+ * lands beside the first rather than on it, and the gap it leaves has to go
+ * somewhere: it goes into the one interval nobody stacked, G♯ up to E♭. That
+ * interval is a fifth by position and not by size, which is why it howls.
+ *
+ * Under pure fifths it comes out NARROW (678.5¢, the Pythagorean comma taken
+ * out of it). Temper the fifths and the leftover grows: every cent taken off
+ * eleven fifths is given back to this one, so it passes a pure fifth and goes
+ * wide (737.6¢ at quarter-comma). That sign change is the thing a reader of
+ * the slider is watching, and it is why `fromPure` is signed.
+ *
+ * Derived from the SAME walk `buildPythagoreanRatios` does, deliberately.
+ * There is a closed form (1200·7 − 11·fifth, which agrees to the decimal),
+ * but two derivations of one number is how they drift apart.
+ *
+ * Null when no chain built the scale: a Ptolemaic genus and a custom Scala
+ * list are given as ratios, and have no fifths chain to leave a remainder.
+ */
+export function wolfOf(commaN) {
+    const ratios = buildPythagoreanRatios(commaN);
+    const cents = ratios.map((r) => 1200 * Math.log2(r));
+    const from = FIFTH_TO_CHROM[11];
+    const to = FIFTH_TO_CHROM[0];
+    // Upward and octave-folded: the chain's ends sit either side of the fold,
+    // so the raw difference is negative about as often as not.
+    let span = cents[to] - cents[from];
+    if (span < 0)
+        span += 1200;
+    return {
+        from,
+        to,
+        spn: [CHAIN_SPELLING[11], CHAIN_SPELLING[0]],
+        cents: span,
+        pure: PURE_FIFTH_CENTS,
+        fromPure: span - PURE_FIFTH_CENTS,
+    };
+}
 export function buildRatios(opts = {}) {
     const mode = opts.mode ?? 1;
     const a4 = opts.a4 ?? 440;
@@ -202,7 +277,31 @@ export function buildRatios(opts = {}) {
     const rootPc = opts.root ?? finalisPc;
     let ratios;
     if (opts.steps != null) {
-        const parsed = opts.steps.map(parseStep);
+        let parsed = opts.steps.map(parseStep);
+        // Two USER step conventions circulate, and mistaking one for the other
+        // mistunes silently: a DEGREE LIST begins at 1/1 (the ptolemy presets), a
+        // SCALA list gives the degrees above an implicit tonic and ends at 2/1
+        // (every .scl file). Normalize both to 1/1-first; anything else is
+        // ambiguous and throws rather than resolving a plausible-looking wrong
+        // tuning. The check applies to USER intake only — string steps. An
+        // all-number list is the engine's own resolved table riding back in
+        // (notatio carries temperamentum.cents), root-relative by construction.
+        const userIntake = opts.steps.some((v) => typeof v === "string");
+        if (userIntake) {
+            const EPS = 1e-9;
+            const firstIsUnison = Math.abs((parsed[0] ?? 0) - 1) < EPS;
+            const lastIsOctave = Math.abs((parsed[parsed.length - 1] ?? 0) - 2) < EPS;
+            if (!firstIsUnison && lastIsOctave) {
+                parsed = [1, ...parsed.slice(0, -1)]; // Scala convention → shift under the tonic
+            }
+            else if (firstIsUnison && lastIsOctave) {
+                parsed = parsed.slice(0, -1); // both stated → drop the closing octave
+            }
+            else if (!firstIsUnison) {
+                throw new RangeError("Custom scale must begin at 1/1 (a degree list) or end at 2/1 (Scala convention)");
+            }
+            parsed = parsed.map(foldOct);
+        }
         if (parsed.length === 7) {
             ratios = expandDiatonicSteps(parsed);
         }

package/dist/index.d.ts

@@ -3,26 +3,28 @@ import { getChants, getCorpus } from "./engines/chant/chant.js";
 import { getPropers } from "./engines/chant/propers.js";
 import { getOrdinary } from "./engines/chant/ordinary.js";
 import { getHour } from "./engines/chant/hour.js";
-import { getMatins } from "./engines/chant/matutinum.js";
 import { getPsalm } from "./engines/chant/psalm.js";
 import { buildTemper } from "./engines/temper/api.js";
 import { buildScore } from "./engines/score/api.js";
+import { inscriptio } from "./engines/score/inscriptio.js";
 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, Rite, Corpus, GenusCount, ModeCount, SharedCount } from "./engines/chant/types.js";
-import type { Matins, Nocturn } from "./engines/chant/matutinum.js";
+import type { CantusQuery, Chant, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Corpus, GenusCount, ModeCount, SharedCount, CorpusLedger, CorpusFullCount, 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, MidiOpts, MidiEmitResult, MidiJsonResult, MidiJsonEvent, MusicXmlOpts, MusicXmlEmitResult } from "./engines/score/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 { Prosody, RhythmicProfile, NoteRange, CadenceDistribution } from "./engines/score/prosody.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, RestEvent, ParseError, ArsisThesis, RhythmicType, CompoundBeat } from "./engines/score/types.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;
@@ -31,14 +33,30 @@ declare const tonus: {
     proprium: typeof getPropers;
     ordinarium: typeof getOrdinary;
     officium: typeof getHour;
-    matutinum: typeof getMatins;
     psalmus: typeof getPsalm;
     temperamentum: typeof buildTemper;
     notatio: typeof buildScore;
+    inscriptio: typeof inscriptio;
     caelum: typeof getCosmos;
     harmonia: typeof buildHarmonia;
+    census: typeof getCensus;
 };
 export default tonus;
-export { SEASON_LABELS, TEMPUS_NAMES, GRADE_ORDER, GRADE_NAMES, gradeOrder, compareGrade, ritusToGrade, } from "./engines/cal/types.js";
-export type { Feast, FeastQuery, Pascha, Season, Grade, Chant, CantusQuery, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Rite, Corpus, GenusCount, ModeCount, SharedCount, Matins, Nocturn, 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, MidiOpts, MidiEmitResult, MidiJsonResult, MidiJsonEvent, MusicXmlOpts, MusicXmlEmitResult, ChantTabulaRow, Note, Performance, Phrase, Syllable, RestEvent, ParseError, ArsisThesis, RhythmicType, CompoundBeat, VoicedPitch, Cosmos, CosmosQuery, Body, BodyName, Aspect, Imprint, Attractor, VowelAttractor, ModalAffinity, Prosody, RhythmicProfile, NoteRange, CadenceDistribution, Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author, HarmonyTabulaRow, PlanetVowel, };
+export { SEASON_LABEL, // season code → English name        ("adv" → "Advent")
+TEMPORA, // season code → Latin name          ("adv" → "Tempus Adventus")
+GRADE_ORDER, // grade code → rank, low is higher
+GRADUS, } from "./engines/cal/types.js";
+export { HORAE, // the eight canonical hours, Matins first — the order is content
+OFFICIA, // office code → Latin genus  ("an" → "Antiphona")
+ORDINARIA, // ordinary code → Latin name ("kyrie" → "Kyrie eleison")
+MODI, } from "./engines/chant/types.js";
+export { SOURCES } from "./engines/chant/chant.js";
+export { MODES } from "./engines/temper/data/modes.js";
+export { TONES } from "./engines/temper/data/tones.js";
+export type { PsalmTone, Differentia } from "./engines/temper/data/tones.js";
+export { CADENTIAE, CADENTIAE_POPULATION } from "./data/cadentiae.js";
+export type { CadentiaFamilia } from "./data/cadentiae.js";
+export { SIGNS, SIGNA } from "./engines/planet/planet.js";
+export { CENSUS_GROUPS, CENSUS_ORDER } from "./data/census.js";
+export type { Feast, FeastQuery, Pascha, Season, Grade, Chant, CantusQuery, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Corpus, GenusCount, ModeCount, SharedCount, CorpusLedger, CorpusFullCount, CorpusQuery, Census, CensusQuery, CensusBy, CensusGroup, CensusGroupProfile, CensusNeighbor, Temperamentum, TemperamentumInput, TemperamentumOpts, Tuning, Pitch, PitchInput, Step, Neume, NeumeShape, Interval, ModeData, CadenceFigure, Modus, TunedNote, GamutOptions, Tonus, TonusOpts, Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, Cadence, CadenceTarget, CadenceApproach, Modulation, InscriptioOpts, Inscriptio, NoteGeometry, FontSpec, FontSlot, FontEmbed, ChantTabulaRow, Note, Performance, Phrase, Syllable, LyricRun, RestEvent, ParseError, ArsisThesis, RhythmicType, CompoundBeat, VoicedPitch, Cosmos, CosmosQuery, Body, BodyName, Aspect, Imprint, Attractor, VowelAttractor, ModalAffinity, Prosody, RhythmicProfile, NoteRange, CadenceDistribution, Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author, HarmonyTabulaRow, PlanetVowel, };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -3,12 +3,13 @@ import { getChants, getCorpus } from "./engines/chant/chant.js";
 import { getPropers } from "./engines/chant/propers.js";
 import { getOrdinary } from "./engines/chant/ordinary.js";
 import { getHour } from "./engines/chant/hour.js";
-import { getMatins } from "./engines/chant/matutinum.js";
 import { getPsalm } from "./engines/chant/psalm.js";
 import { buildTemper } from "./engines/temper/api.js";
 import { buildScore } from "./engines/score/api.js";
+import { inscriptio } from "./engines/score/inscriptio.js";
 import { getCosmos } from "./engines/planet/planet.js";
 import { buildHarmonia } from "./engines/harmonia/api.js";
+import { getCensus } from "./engines/census/census.js";
 const tonus = {
     festum: getFeast,
     pascha: getPascha,
@@ -17,14 +18,46 @@ const tonus = {
     proprium: getPropers,
     ordinarium: getOrdinary,
     officium: getHour,
-    matutinum: getMatins,
     psalmus: getPsalm,
     temperamentum: buildTemper,
     notatio: buildScore,
+    inscriptio,
     caelum: getCosmos,
     harmonia: buildHarmonia,
+    census: getCensus,
 };
 export default tonus;
-// Reference maps and grade helpers (display strings live here, not on objects).
-export { SEASON_LABELS, TEMPUS_NAMES, GRADE_ORDER, GRADE_NAMES, gradeOrder, compareGrade, ritusToGrade, } from "./engines/cal/types.js";
+// ── The appendix ──
+// The export law: verbs live on the namespace; return values are plain data;
+// the appendix exports canonical constant tables — nothing with a (). A
+// function that earns public life earns a fifteenth Latin noun instead.
+// A constant is admitted when a caller would otherwise TYPE IT OUT — a mode
+// list, an hour list, the valid `by:` values. Those transcriptions drift, and a
+// caller's drifted copy fails as wrong answers rather than as an error. Naming
+// follows the register rule: a table of Latin values takes a Latin name
+// (TEMPORA, "Tempus Adventus"), a table of codes or English keeps English
+// (SEASON_LABEL, "Advent"). So the name says which one you are holding.
+// cal — the liturgical year
+export { SEASON_LABEL, // season code → English name        ("adv" → "Advent")
+TEMPORA, // season code → Latin name          ("adv" → "Tempus Adventus")
+GRADE_ORDER, // grade code → rank, low is higher
+GRADUS, // grade code → Latin name
+ } from "./engines/cal/types.js";
+// chant — the corpus vocabulary
+export { HORAE, // the eight canonical hours, Matins first — the order is content
+OFFICIA, // office code → Latin genus  ("an" → "Antiphona")
+ORDINARIA, // ordinary code → Latin name ("kyrie" → "Kyrie eleison")
+MODI, // mode number → Latin name   ("1" → "Modus I")
+ } from "./engines/chant/types.js";
+export { SOURCES } from "./engines/chant/chant.js"; // book code → bibliographic record
+// temper — modes, tones, cadences
+export { MODES } from "./engines/temper/data/modes.js";
+export { TONES } from "./engines/temper/data/tones.js";
+export { CADENTIAE, CADENTIAE_POPULATION } from "./data/cadentiae.js";
+// planet — the zodiac
+export { SIGNS, SIGNA } from "./engines/planet/planet.js";
+// census — the field groups and the block index. CENSUS_GROUPS keys are the
+// valid `by:` values AND the `profile` keys; CENSUS_ORDER holds every censused
+// id, so asking whether a chant is in the census stops needing a try/catch.
+export { CENSUS_GROUPS, CENSUS_ORDER } from "./data/census.js";
 //# sourceMappingURL=index.js.map