tonus 0.11.1 → 0.13.0

package/dist/engines/chant/ordinary.js

@@ -21,16 +21,20 @@ function resolveMasses(feast) {
         return resolved;
     return [feast.marian ? AD_LIB.bvm : AD_LIB.standard];
 }
-// The numbered kyriale runs 1–18. The book's appendix — ad libitum settings and
-// the like — carries synthetic numbers above that range, which no feast's
-// `masses` list ever names; those settings are therefore reachable only as a
-// last-resort fallback here, or by direct `ordinarium({ mass })` query.
-const NUMBERED_MASS_MAX = 18;
+// Where the Kyriale prints an entry. Only the "mass" section carries a mass
+// number; the others are addressed by section. The appendix used to carry its
+// Graduale page as a "mass" (Clemens Rector was mass 75, the Requiem 94, 101
+// and 102), and the two ad libitum Kyries whose incipits carry a numeral
+// collided with Masses VI and X.
+const KYRIALE_SECTIONS = new Set([
+    "mass", "credo", "sprinkling", "ad-libitum", "requiem",
+]);
+const SPRINKLING_OFFICES = new Set(["as", "va"]);
+// The Cantus ad libitum, which no feast's `masses` list ever names: reachable
+// on the appendix's solemnity turn, as a last-resort fallback here, or by a
+// direct `ordinarium({ section: "ad-libitum" })` query.
 function isAdLibitum(entry) {
-    // Most appendix settings sit above the numbered range, but two ad libitum
-    // Kyries are numbered 6 and 10 in the source data, colliding with the
-    // numbered masses — for those the incipit is the only discriminator.
-    return (entry.mass ?? 0) > NUMBERED_MASS_MAX || /\(ad lib\./i.test(entry.incipit);
+    return entry.section === "ad-libitum";
 }
 /** Prefer a proper numbered setting over an appendix one at equal standing. */
 function adLibLast(a, b) {
@@ -38,12 +42,13 @@ function adLibLast(a, b) {
 }
 // The Missa pro defunctis settings belong to the Requiem, not to the temporal or
 // sanctoral day. They stay out of every calendar-driven pick and remain
-// reachable only by direct `ordinarium({ mass })` query. Note the Requiem's own
-// dismissal carries the bare incipit "Requiescant" — no "(in Miss. def.)"
-// qualifier — so it must be named here explicitly, or it leaks through the
-// last-resort appendix onto every feria whose mass prints no dismissal.
+// reachable only by direct `ordinarium({ section: "requiem" })` query. The
+// Requiem's own dismissal carries the bare incipit "Requiescant", which is why
+// the section is data and not an incipit test: left to the incipit it leaked
+// through the last-resort appendix onto every feria whose mass prints no
+// dismissal.
 function isRequiem(entry) {
-    return /in\s+Miss\.\s*def|defunct|requiescant/i.test(entry.incipit);
+    return entry.section === "requiem";
 }
 /**
  * Deterministic rotation of a preference list by year.
@@ -104,8 +109,14 @@ function appendixLeadsThisYear(rubric, poolSize, year) {
     const n = poolSize + 1;
     return ((year % n) + n) % n === poolSize;
 }
+// The appendix in the book's own order. Its settings carry no mass number, so
+// the Graduale's page orders them: Kyrie I to XI, then the Glorias, and so on.
+function grPage(entry) {
+    const page = /\d+/.exec(entry.pages?.gr?.[0]?.page ?? "")?.[0];
+    return page == null ? Number.POSITIVE_INFINITY : Number(page);
+}
 function appendixFor(office, pool) {
-    return pool.filter((e) => e.office === office && isAdLibitum(e) && !isRequiem(e)).sort((a, b) => (a.mass ?? 0) - (b.mass ?? 0) || (a.id < b.id ? -1 : 1));
+    return pool.filter((e) => e.office === office && isAdLibitum(e) && !isRequiem(e)).sort((a, b) => grPage(a) - grPage(b) || (a.id < b.id ? -1 : 1));
 }
 /**
  * Candidate settings for one ordinary slot, most preferred first.
@@ -183,7 +194,7 @@ function entriesForOffice(office, massNumbers, year, appendixLeads, wholeMass =
     // is the standing answer — its ad libitum variants must NOT rotate against it
     // as equals, or the appendix would be sung more often than the rite itself.
     // They arrive on the appendix turn like every other appendix setting.
-    const unnumbered = pool.filter((e) => e.office === office && e.mass == null && !isRequiem(e));
+    const unnumbered = pool.filter((e) => e.office === office && SPRINKLING_OFFICES.has(office) && !isRequiem(e));
     const plain = unnumbered.filter((e) => !isAdLibitum(e));
     if (plain.length)
         return rotate(plain, year);
@@ -310,6 +321,7 @@ export function entryToOrdinaryChant(entry) {
         ordinary,
         ordinarium: ORDINARIA[ordinary] ?? entry.incipit,
         mass: entry.mass ?? 0,
+        section: entry.section,
     };
 }
 // Maundy Thursday (In Cena Domini) is a Triduum exception: it retains a full
@@ -454,7 +466,7 @@ function assertFeasts(feasts, method) {
             throw new Error(`${method}: feast must be a Feast (from tonus.festum) — got ${typeof f}`);
     }
 }
-const ORDINARIUM_QUERY_KEYS = new Set([...CANTUS_QUERY_KEYS, "feast", "ordinary", "mass"]);
+const ORDINARIUM_QUERY_KEYS = new Set([...CANTUS_QUERY_KEYS, "feast", "ordinary", "mass", "section"]);
 /**
  * Mass ordinary retrieval (`tonus.ordinarium`) from the Kyriale. A feast
  * drives mass selection; `mass` pins a kyriale number directly.
@@ -472,6 +484,10 @@ export function getOrdinary(query) {
     if (query.ordinary) {
         assertOrdinaryCodes(Array.isArray(query.ordinary) ? query.ordinary : [query.ordinary], "ordinarium");
     }
+    if (query.section != null && !KYRIALE_SECTIONS.has(query.section)) {
+        throw new Error(`ordinarium: unknown section "${query.section}" ` +
+            `(expected ${[...KYRIALE_SECTIONS].join(", ")}).`);
+    }
     const feasts = toArray(query.feast);
     assertFeasts(feasts, "ordinarium");
     // `mode` accepts a scalar or an array, with cantus's semantics: match any.
@@ -493,7 +509,7 @@ export function getOrdinary(query) {
             return ordinaryForFeast(f, query.mass, filterModes, adm);
         });
     }
-    else if (query.mass != null || query.ordinary) {
+    else if (query.mass != null || query.ordinary || query.section) {
         // Direct kyriale query without feast context — same admissibility rule as
         // cantus, so the two doors cannot disagree.
         let entries = KYRIALE.slice();
@@ -503,6 +519,8 @@ export function getOrdinary(query) {
         }
         if (query.mass != null)
             entries = entries.filter((e) => e.mass === query.mass);
+        if (query.section)
+            entries = entries.filter((e) => e.section === query.section);
         if (query.ordinary)
             entries = entries.filter((e) => e.office === query.ordinary);
         if (filterModes)
@@ -515,6 +533,9 @@ export function getOrdinary(query) {
         return [];
     }
     // Apply remaining CantusQuery filters
+    if (feasts && query.section) {
+        results = results.filter((c) => c.section === query.section);
+    }
     if (query.incipit) {
         const needle = query.incipit.toLowerCase();
         results = results.filter((c) => c.incipit.toLowerCase().includes(needle));

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

@@ -1,4 +1,5 @@
 import type { Season, Grade, Feast } from "../cal/types.js";
+import type { KyrialeSection } from "../../data/kyriale.js";
 export type { Season, Grade, Feast };
 export type OfficeCode = "an" | "al" | "ca" | "co" | "gr" | "hy" | "in" | "of" | "ps" | "re" | "rb" | "se" | "tr" | "tp" | "or" | "ky" | "va" | "im" | "pa" | "su";
 export type OrdinaryCode = "ke" | "gl" | "cr" | "sa" | "ag" | "be" | "it" | "as" | "va";
@@ -92,11 +93,14 @@ export interface Chant {
     ordinary?: OrdinaryCode;
     ordinarium?: string;
     mass?: number;
+    section?: KyrialeSection;
 }
 export interface OrdinaryChant extends Chant {
     ordinary: OrdinaryCode;
     ordinarium: string;
+    /** One of Masses I–XVIII; 0 outside the numbered Masses (see `section`). */
     mass: number;
+    section: KyrialeSection;
 }
 export interface GenusCount {
     office: OfficeCode;
@@ -219,7 +223,10 @@ export interface PropriumQuery extends CantusQuery {
 export interface OrdinariumQuery extends CantusQuery {
     feast?: Feast | Feast[];
     ordinary?: OrdinaryCode;
+    /** One of Masses I–XVIII. */
     mass?: number;
+    /** A section of the Kyriale: "mass", "credo", "sprinkling", "ad-libitum", "requiem". */
+    section?: KyrialeSection;
 }
 export interface OfficiumQuery extends CantusQuery {
     feast?: Feast | Feast[];

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

@@ -21,7 +21,7 @@ import { decideBreak } from "./breaking.js";
 import { trimRuns } from "../lyric.js";
 import { GLYPHS, GLYPH_UPM } from "../../../data/smufl-glyphs.js";
 import { computeAccidentals, } from "./accidentals.js";
-import { GLYPH, SHAPE_GLYPH, DIVISIO_GLYPH, ligaturaDesc, } from "../../../data/gabc-glyphs.js";
+import { GLYPH, SHAPE_GLYPH, headGlyph, tracedHollow, DIVISIO_GLYPH, ligaturaDesc, } from "../../../data/gabc-glyphs.js";
 import { buildChironomia, buildProsodia, buildTonarium, trackBands, } from "./tracks.js";
 function resolveFont(slot, fallback) {
     if (!slot)
@@ -352,14 +352,19 @@ function yAt(pos, systemY, L, r) {
 // SMuFL nominal (noteheads use r.noteScale; clefs/divisiones use 1). dyFont
 // shifts the glyph in font units (y-up) before the flip — used to re-register
 // base-registered components.
-function placeGlyph(code, x, y, r, cls, data = "", factor = 1, dyFont = 0) {
+// `traced` draws the outline alone, at the staff line's weight whatever the
+// scale — the hollow for a head Bravura carries only full.
+function placeGlyph(code, x, y, r, cls, data = "", factor = 1, dyFont = 0, traced = false) {
     const g = GLYPHS[code];
     if (!g)
         return null;
     const s = r.glyphScale * factor;
     const yy = y - dyFont * s;
+    const paint = traced
+        ? `fill="none" stroke="${r.noteColor}" stroke-width="${r.lineWeight.toFixed(2)}" vector-effect="non-scaling-stroke"`
+        : `fill="${r.noteColor}"`;
     const svg = `<g class="${cls}"${data} transform="translate(${x.toFixed(2)} ${yy.toFixed(2)}) scale(${s.toFixed(5)} ${(-s).toFixed(5)})">` +
-        `<path d="${g.path}" fill="${r.noteColor}"/></g>`;
+        `<path d="${g.path}" ${paint}/></g>`;
     return {
         svg,
         advance: g.advance * s,
@@ -484,10 +489,14 @@ export function toSvg(rows, chant, options = {}) {
     };
     // Place a notehead glyph for a row at x; returns the placement.
     const placeNote = (row, atX, code, dyFont = 0) => {
-        const glyphCode = code ?? SHAPE_GLYPH[row.shape] ?? GLYPH.punctum;
+        // A liquescent with a head of its own draws it at full size; one Bravura
+        // does not carry (a liquescent virga, a figure component) keeps the small
+        // head that stood for every liquescence before the heads were routed.
+        const head = code ? null : headGlyph(row);
+        const glyphCode = code ?? head ?? SHAPE_GLYPH[row.shape] ?? GLYPH.punctum;
         const y = yFor(row.staffPosition, L, r);
-        const sc = row.liquescent ? r.noteScale * 0.66 : r.noteScale;
-        const p = placeGlyph(glyphCode, atX, y, r, "note", dataAttrs(row), sc, dyFont);
+        const sc = row.liquescent && !head ? r.noteScale * 0.66 : r.noteScale;
+        const p = placeGlyph(glyphCode, atX, y, r, "note", dataAttrs(row), sc, dyFont, !code && tracedHollow(row));
         if (!p)
             return null;
         ledger(row.staffPosition, p.inkLeft, p.inkRight);
@@ -1126,6 +1135,40 @@ export function toSvg(rows, chant, options = {}) {
                 body.push(p.svg);
         }
     }
+    // ── Signa over the note (GABC r1–r5) ──
+    // Bravura carries the accentus and the semicirculus one way round only, so
+    // one of each pair is the glyph mirrored about its own ink. For the accentus
+    // that is the reversus; for the semicirculus it is the plain one — gregorio's
+    // r4 is the cup, r5 the cap, and Bravura's "semicirculus above" is the cap.
+    const SIGNUM = {
+        accentus: { code: GLYPH.accentus },
+        accentusReversus: { code: GLYPH.accentus, flip: "x" },
+        circulus: { code: GLYPH.circulus },
+        semicirculus: { code: GLYPH.semicirculus, flip: "y" },
+        semicirculusReversus: { code: GLYPH.semicirculus },
+    };
+    for (const pl of placements) {
+        const sign = pl.row.signum ? SIGNUM[pl.row.signum] : undefined;
+        const g = sign ? GLYPHS[sign.code] : undefined;
+        if (!sign || !g)
+            continue;
+        const s = r.glyphScale * r.noteScale;
+        const w = (g.bbox[2] - g.bbox[0]) * s;
+        const midX = (pl.inkLeft + pl.inkRight) / 2;
+        const y = yAt(pl.row.staffPosition, pl.systemY, L, r) - r.noteheadH * 0.45;
+        const p = placeGlyph(sign.code, midX - w / 2, y, r, "signum", "", r.noteScale);
+        if (!p)
+            continue;
+        if (!sign.flip) {
+            body.push(p.svg);
+            continue;
+        }
+        const cy = y - ((g.bbox[1] + g.bbox[3]) / 2) * s;
+        const m = sign.flip === "x"
+            ? `translate(${(2 * midX).toFixed(2)} 0) scale(-1 1)`
+            : `translate(0 ${(2 * cy).toFixed(2)}) scale(1 -1)`;
+        body.push(`<g transform="${m}">${p.svg}</g>`);
+    }
     // Close the final system; height reaches the last.
     systemMaxX.push(Math.max(x, prevLyricRight) + r.padding);
     // The canvas is what the CALLER asked for, not what the content happened to

package/dist/engines/score/ir.js

@@ -41,6 +41,10 @@ function rawToNote(raw, scale) {
             liquescent: raw.liquescent,
             strophicus: raw.strophicus,
             oriscus: raw.oriscus,
+            liquescence: raw.liquescence,
+            oriscusDirection: raw.oriscusDirection,
+            hollow: raw.hollow,
+            signum: raw.signum,
             mora: raw.mora,
             weight: raw.weight,
         },

package/dist/engines/score/parse.js

@@ -42,6 +42,27 @@ const DIVISIO_DURATIONS = new Map([
 const STAFF_STEPS = [0, 2, 4, 5, 7, 9, 11];
 const SYLLABLES_REGEX = /(?=.)((?:[^(])*)(?:\(?([^)]*)\)?)?/g;
 const NOTATIONS_REGEX = /z0|z|Z|::|:|[,;][1-6]?|`|[cf][1-4]|cb[1-4]|fb[1-4]|\/+| |\!|-?[a-mA-M][oOwWvVrRsxy#~\+><_\.'012345]*(?:\[[^\]]*\]?)*|\{([^}]+)\}?/g;
+// GABC r1–r5, the signs gregorio prints over a note.
+const SIGNA = Object.freeze({
+    "1": "accentus",
+    "2": "accentusReversus",
+    "3": "circulus",
+    "4": "semicirculus",
+    "5": "semicirculusReversus",
+});
+// An oriscus written without o0/o1 points at the next pitch that differs from
+// its own: up is ascending, down (or nothing after it) descending. Gregorio's
+// rule (gabc_determine_oriscus_orientation), run over the whole score because
+// the next pitch is often in the next syllable.
+function orientOrisci(events) {
+    const notes = events.filter((e) => e.type === "note");
+    notes.forEach((n, i) => {
+        if (!n.oriscus || n.oriscusDirection)
+            return;
+        const next = notes.slice(i + 1).find((m) => m.step !== n.step);
+        n.oriscusDirection = next && next.step > n.step ? "ascending" : "descending";
+    });
+}
 // Helpers
 function initialAccidentalState(clef) {
     const state = new Map();
@@ -279,12 +300,22 @@ function parseNeume(notation, context) {
         // Written note shape (gregorio's S_* vocabulary, simplified) — what the
         // renderer draws. Priority: the inclinatum diamond and the ornamental
         // shapes win over the plain punctum/virga forms.
+        //
+        // The r family is read the way gregorio's lexer reads it: r alone empties
+        // the note (cavum), R draws it between two vertical lines, r0 does both,
+        // and r1–r5 are signs printed over a FULL note. Testing for a bare "r"
+        // made gr1 a hollow head, which is the one thing its accent does not say.
+        const marks = modifiers.replace(/\[[^\]]*\]?/g, "");
+        const hollow = /r(?![1-8])/.test(marks);
+        const signum = SIGNA[/r([1-5])/.exec(marks)?.[1] ?? ""] ?? null;
         let shape = "punctum";
         if (isInclinatum)
             shape = "inclinatum";
         else if (isQuilisma)
             shape = "quilisma";
-        else if (isStrophicus)
+        // A lone s is gregorio's stropha too; the analytical `strophicus` flag
+        // above stays with the repeated ss/sss, whose weighting it drives.
+        else if (isStrophicus || marks.includes("s"))
             shape = "strophicus";
         else if (modifiers.includes("V"))
             shape = "virgaReversa";
@@ -292,10 +323,18 @@ function parseNeume(notation, context) {
             shape = "virga";
         else if (isOriscus)
             shape = "oriscus";
-        else if (modifiers.includes("r"))
-            shape = "cavum";
-        else if (modifiers.includes("="))
-            shape = "linea";
+        else if (marks.includes("R") || marks.includes("r0"))
+            shape = "lineaPunctum";
+        const liquescence = !isLiquescent ? null
+            : marks.includes("~") ? "deminutive"
+                : marks.includes("<") ? "ascending"
+                    : "descending";
+        // o0 / o1 write the orientation; a bare o leaves it to the next pitch,
+        // resolved after the syllable's notes are known (below).
+        const oriscusDirection = !isOriscus ? null
+            : marks.includes("o1") ? "ascending"
+                : marks.includes("o0") ? "descending"
+                    : null;
         intermed.push({
             step,
             degree,
@@ -318,6 +357,10 @@ function parseNeume(notation, context) {
             liquescent: isLiquescent,
             strophicus: isStrophicus,
             oriscus: isOriscus,
+            liquescence,
+            oriscusDirection,
+            hollow,
+            signum,
             mora,
             _weight: w,
             _durWeight: durWeight,
@@ -385,6 +428,10 @@ function parseNeume(notation, context) {
             liquescent: note.liquescent,
             strophicus: note.strophicus,
             oriscus: note.oriscus,
+            liquescence: note.liquescence,
+            oriscusDirection: note.oriscusDirection,
+            hollow: note.hollow,
+            signum: note.signum,
             mora: note.mora,
         };
     });
@@ -519,6 +566,7 @@ export function parseGABC(gabc, options = {}) {
     if (events.length === 0) {
         errors.push({ message: "No parseable notation found" });
     }
+    orientOrisci(events);
     return { events, errors };
 }
 //# sourceMappingURL=parse.js.map

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

@@ -1,6 +1,6 @@
 import type { ScoreIR, Neume, LyricRun } from "./types.js";
 import type { Cadence } from "./cadence.js";
-import type { ChantType, InterpretationOptions, WrittenShape } from "./types.js";
+import type { ChantType, InterpretationOptions, Liquescence, Signum, WrittenShape } from "./types.js";
 export type NoteRole = "finalis" | "tenor" | "alia" | null;
 export interface ChantTabulaRow {
     phraseIndex: number;
@@ -74,6 +74,14 @@ export interface ChantTabulaRow {
     liquescent: boolean;
     strophicus: boolean;
     oriscus: boolean;
+    /** Which way a liquescent bends (see `Liquescence`); null when not liquescent. */
+    liquescence: Liquescence | null;
+    /** An oriscus's orientation — written (o0/o1) or read off the next pitch; null otherwise. */
+    oriscusDirection: "ascending" | "descending" | null;
+    /** Written hollow (GABC r, cavum). */
+    hollow: boolean;
+    /** Editorial sign over the note (GABC r1–r5); null when none. */
+    signum: Signum | null;
     /** Mora vocis count: 0 none, 1 dot '.', 2 double dot '..' (a stronger cadential hold). */
     mora: 0 | 1 | 2;
     divisio: string | null;

package/dist/engines/score/tabula.js

@@ -122,6 +122,10 @@ export function computeTabula(ir, options = {}) {
             liquescent: n.context.liquescent,
             strophicus: n.context.strophicus,
             oriscus: n.context.oriscus,
+            liquescence: n.context.liquescence,
+            oriscusDirection: n.context.oriscusDirection,
+            hollow: n.context.hollow,
+            signum: n.context.signum,
             mora: n.context.mora,
             divisio: a.divisio,
             cadenceRef: cadenceRefByPos.get(`${a.phraseIndex}:${a.syllableIndex}:${a.noteIndex}`) ?? null,

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

@@ -14,7 +14,14 @@ export interface Performance {
     rhythmicShape: ArsisThesis;
     rhythmicIndex: number;
 }
-export type WrittenShape = "punctum" | "inclinatum" | "virga" | "virgaReversa" | "quilisma" | "oriscus" | "strophicus" | "cavum" | "linea";
+export type WrittenShape = "punctum" | "inclinatum" | "virga" | "virgaReversa" | "quilisma" | "oriscus" | "strophicus" | "lineaPunctum";
+/**
+ * Which way a liquescent note bends, from its GABC mark: `~` deminutive (the
+ * small head), `<` augmented ascending, `>` augmented descending.
+ */
+export type Liquescence = "deminutive" | "ascending" | "descending";
+/** An editorial sign printed over the note, GABC r1–r5 (gregorio's names). */
+export type Signum = "accentus" | "accentusReversus" | "circulus" | "semicirculus" | "semicirculusReversus";
 /**
  * One styled span of a syllable's lyric — the decoded form of GABC's text
  * markup (<i>, <b>, <sc>, <c>, elisions). The spans concatenate to the
@@ -71,6 +78,14 @@ export interface Context {
     liquescent: boolean;
     strophicus: boolean;
     oriscus: boolean;
+    /** Which way a liquescent bends (see `Liquescence`); null when not liquescent. */
+    liquescence: Liquescence | null;
+    /** An oriscus's orientation — written (o0/o1) or read off the next pitch; null otherwise. */
+    oriscusDirection: "ascending" | "descending" | null;
+    /** Written hollow (GABC r, cavum). */
+    hollow: boolean;
+    /** Editorial sign over the note (GABC r1–r5); null when none. */
+    signum: Signum | null;
     mora: 0 | 1 | 2;
     weight: number;
 }
@@ -204,6 +219,14 @@ export interface ParsedNote {
     liquescent: boolean;
     strophicus: boolean;
     oriscus: boolean;
+    /** Which way a liquescent bends (see `Liquescence`); null when not liquescent. */
+    liquescence: Liquescence | null;
+    /** An oriscus's orientation — written (o0/o1) or read off the next pitch; null otherwise. */
+    oriscusDirection: "ascending" | "descending" | null;
+    /** Written hollow (GABC r, cavum). */
+    hollow: boolean;
+    /** Editorial sign over the note (GABC r1–r5); null when none. */
+    signum: Signum | null;
     mora: 0 | 1 | 2;
 }
 export interface RestEvent {

package/docs/api/chant.md

@@ -405,8 +405,12 @@ interface PropriumQuery extends CantusQuery {
 `ordinarium(query?)` retrieves the fixed chants of the Mass from the
 Kyriale. A feast drives mass selection through its `masses` list, the
 masses the day's Kyriale RUBRIC appoints, derived as described in
-[calendar.md](calendar.md#the-days-feasts--festum); `mass` pins a kyriale
-number directly. Where the rubric names several masses, the year rotates
+[calendar.md](calendar.md#the-days-feasts--festum); `mass` pins one of the
+eighteen numbered Masses directly, and `section` asks for a part of the book:
+`mass` (Masses I–XVIII), `credo` (Credo I–VI), `sprinkling` (Asperges me,
+Vidi aquam), `ad-libitum` (the Cantus ad libitum) or `requiem` (the Missa pro
+defunctis). Only the `mass` section carries a mass number; every other entry
+reads `mass: 0`. Where the rubric names several masses, the year rotates
 through them (same feast, same year → same answer, every time), and sibling
 printings under one number (Mass I prints two dismissals; Mass XVII prints
 Kyrie A/B/C) rotate with it. Slots resolve independently, which the book
@@ -420,7 +424,7 @@ const [easter] = tonus.festum({ date: new Date("2026-04-05") });
 tonus.ordinarium({ feast: easter });
 // ky  Kyrie I       (mass 1) — Lux et origo, Paschal time, every year
 // gl  Gloria I      (mass 1)
-// cr  Credo III     (mass 3) — the credo rotates on its own cycle
+// cr  Credo III     (mass 0) — the credo rotates on its own cycle
 // sa  Sanctus I     (mass 1)
 // ag  Agnus Dei I   (mass 1)
 // it  Ite Ia        (mass 1)
@@ -437,7 +441,7 @@ sings Mass XVI whole with the Mass II Benedicamus. The ad libitum appendix
 is a **solemnity boost**, reachable only under the festal rubrics (it takes
 its turn in the rotation once every _n + 1_ years); it never reaches a
 penitential day or a feria, and the Requiem settings stay out of every
-calendar-driven pick (reachable by `ordinarium({ mass: 102 })` only). The
+calendar-driven pick (reachable by `ordinarium({ section: "requiem" })` only). The
 Triduum returns no ordinary at all: Good Friday has no Mass, and the
 Vigil's ordinary belongs to Easter. A pinned `mass` overrides the Triduum
 rule and the rotation both.
@@ -452,6 +456,7 @@ me** (`as`) otherwise.
 ```js
 tonus.ordinarium({ ordinary: "ke" }); // every Kyrie
 tonus.ordinarium({ mass: 9, ordinary: "gl" }); // Gloria of Cum jubilo
+tonus.ordinarium({ section: "ad-libitum", ordinary: "ke" }); // the eleven ad libitum Kyries
 ```
 
 | `ordinary` | `ordinarium`                                  |
@@ -470,13 +475,15 @@ tonus.ordinarium({ mass: 9, ordinary: "gl" }); // Gloria of Cum jubilo
 interface OrdinaryChant extends Chant {
   ordinary: OrdinaryCode; // movement code
   ordinarium: string; // Latin movement name, "Kyrie eleison" …
-  mass: number;
+  mass: number; // 1–18, or 0 outside the numbered Masses
+  section: "mass" | "credo" | "sprinkling" | "ad-libitum" | "requiem";
 }
 
 interface OrdinariumQuery extends CantusQuery {
   feast?: Feast | Feast[];
   ordinary?: OrdinaryCode;
-  mass?: number;
+  mass?: number; // 1–18
+  section?: "mass" | "credo" | "sprinkling" | "ad-libitum" | "requiem";
 }
 ```
 

package/docs/api/score.md

@@ -271,10 +271,15 @@ interface Context {
   liquescent: boolean;
   strophicus: boolean;
   oriscus: boolean;
+  liquescence: "deminutive" | "ascending" | "descending" | null; // ~ < >
+  oriscusDirection: "ascending" | "descending" | null; // o1/o0, else toward the next pitch
+  hollow: boolean; // cavum, gabc r
+  signum: "accentus" | "accentusReversus" | "circulus"
+    | "semicirculus" | "semicirculusReversus" | null; // gabc r1–r5
   mora: 0 | 1 | 2; // mora vocis: 0 none, 1 dot, 2 double dot
   staffLetter: string; // the GABC staff letter as written
   clef: string; // the clef in force at this note ("c3", "f4", …)
-  shape: string; // the notehead shape (punctum, inclinatum, quilisma, …)
+  shape: string; // the notehead shape (punctum, inclinatum, quilisma, lineaPunctum, …)
   weight: number; // articulation weight
 }
 ```
@@ -326,6 +331,11 @@ interface ChantTabulaRow {
   liquescent: boolean;
   strophicus: boolean;
   oriscus: boolean;
+  liquescence: "deminutive" | "ascending" | "descending" | null; // ~ < >
+  oriscusDirection: "ascending" | "descending" | null; // o1/o0, else toward the next pitch
+  hollow: boolean; // cavum, gabc r
+  signum: "accentus" | "accentusReversus" | "circulus"
+    | "semicirculus" | "semicirculusReversus" | null; // gabc r1–r5
   mora: 0 | 1 | 2; // mora vocis: 0 none, 1 dot, 2 double dot
   hz: number;
   offset: number;
@@ -333,7 +343,7 @@ interface ChantTabulaRow {
   staffLetter: string; // the GABC staff letter as written
   staffPosition: number; // vertical staff position (line/space index)
   clef: string; // the clef in force at this note ("c3", "f4", …)
-  shape: string; // the notehead shape (punctum, inclinatum, quilisma, …)
+  shape: string; // the notehead shape (punctum, inclinatum, quilisma, lineaPunctum, …)
   bend: number; // 14-bit MIDI pitch bend (8192 = center)
   velocity: number | null;
   duration: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tonus",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "type": "module",
   "description": "Medieval music analysis: GABC plainchant exports, liturgical calendar, tuning systems, ephemeris, and the harmony of the spheres",
   "author": "Jeffrey Pierce <jeffrey@jeffreypierce.net>",