tonus 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to tonus. Newest first.
 
+## 0.13.0 — 2026-10-01
+
+Every written head reaches its glyph.
+
+### Changed
+
+- **Breaking: the hollow is a flag, not a shape.** `WrittenShape` loses
+  `cavum` and `linea` and gains `lineaPunctum` (gabc `R`, the punctum between
+  two vertical lines). A hollow note keeps its shape and sets `hollow`, since
+  gregorio empties a punctum, an inclinatum or a lineaPunctum alike. `linea`
+  could never be parsed; its glyph was the lineaPunctum's under a wrong label.
+- `gr1`–`gr5` were read as hollow notes. They are full notes carrying a sign.
+
+### Added
+
+- Rows carry `liquescence` (`~` deminutive, `<` ascending, `>` descending),
+  `oriscusDirection` (written `o0`/`o1`, or toward the next pitch that differs,
+  as gregorio resolves it), `hollow`, and `signum` (gabc `r1`–`r5`).
+- The quadrata emitter draws the liquescent puncta and inclinata, the orisci
+  both ways and liquescent, the stropha and its auctus, the cavum and the
+  lineaPunctum (full and hollow) from their own Bravura glyphs, where it drew a
+  shrunk punctum for every liquescence. The signa print over the note; the
+  reversed accentus and the cup semicircle are Bravura's mirrored. A hollow
+  inclinatum, which Bravura does not carry, is the diamond's outline traced at
+  the staff line's weight — the way the score app already hollows it.
+- A lone `s` is a stropha, as in gregorio.
+
 ## 0.12.0 — 2026-09-24
 
 A mass number is a Mass.

package/dist/data/gabc-glyphs.d.ts

@@ -13,14 +13,21 @@ export declare const GLYPH: {
     readonly cClef: "E906";
     readonly punctum: "E990";
     readonly punctumInclinatum: "E991";
+    readonly punctumInclinatumAuctum: "E992";
+    readonly punctumInclinatumDeminutum: "E993";
+    readonly auctumAsc: "E994";
+    readonly auctumDesc: "E995";
     readonly virga: "E996";
     readonly virgaReversa: "E997";
     readonly cavum: "E998";
-    readonly linea: "E999";
+    readonly lineaPunctum: "E999";
+    readonly lineaPunctumCavum: "E99A";
     readonly quilisma: "E99B";
     readonly oriscusAsc: "E99C";
     readonly oriscusDesc: "E99D";
+    readonly oriscusLiquescens: "E99E";
     readonly strophicus: "E99F";
+    readonly strophicusAuctus: "E9A0";
     readonly punctumDeminutum: "E9A1";
     readonly custosUp: readonly ["EA04", "EA05", "EA06"];
     readonly custosDown: readonly ["EA07", "EA08", "EA09"];
@@ -28,14 +35,39 @@ export declare const GLYPH: {
     readonly podatusUpper: "E9B1";
     readonly ictusAbove: "E9D0";
     readonly ictusBelow: "E9D1";
+    readonly circulus: "E9D2";
+    readonly semicirculus: "E9D4";
+    readonly accentus: "E9D6";
     readonly episema: "E9D8";
     readonly mora: "E9D9";
     readonly flat: "E9E0";
     readonly natural: "E9E1";
     readonly sharp: "E262";
 };
-/** Written note shape → notehead glyph codepoint. */
+/** Written note shape → notehead glyph codepoint, before liquescence and the hollow. */
 export declare const SHAPE_GLYPH: Readonly<Record<string, string>>;
+/** The fields of a note that choose its head. */
+export interface HeadSpec {
+    shape: string;
+    liquescence: "deminutive" | "ascending" | "descending" | null;
+    oriscusDirection: "ascending" | "descending" | null;
+    hollow: boolean;
+}
+/**
+ * The notehead for a note, or null when Bravura draws no head for that
+ * combination (a liquescent virga or quilisma) and the caller keeps its
+ * fallback. Gregorio's rules: an oriscus takes only the deminutive
+ * liquescence; a strophicus either augmentation as its auctus. A hollow
+ * inclinatum returns the full diamond: Bravura has no cavum of it, so the
+ * emitter traces that outline instead (see `tracedHollow`).
+ */
+export declare function headGlyph(n: HeadSpec): string | null;
+/**
+ * A hollow head Bravura does not carry, drawn as its full glyph's outline:
+ * the inclinatum (gabc Gr, G<r). The score app hollows its diamond the same
+ * way, so the two agree.
+ */
+export declare function tracedHollow(n: HeadSpec): boolean;
 /** Divisio mark → glyph codepoint. */
 export declare const DIVISIO_GLYPH: Readonly<Record<string, string>>;
 /** EntryLineAsc component for a rising interval of `steps` diatonic degrees. */

package/dist/data/gabc-glyphs.js

@@ -30,17 +30,27 @@ export const GLYPH = {
     // clefs
     fClef: "E902",
     cClef: "E906",
-    // single notes
+    // single notes (SMuFL plainchant, E990–E9A1)
     punctum: "E990",
     punctumInclinatum: "E991",
+    punctumInclinatumAuctum: "E992",
+    punctumInclinatumDeminutum: "E993",
+    auctumAsc: "E994",
+    auctumDesc: "E995",
     virga: "E996",
     virgaReversa: "E997",
     cavum: "E998",
-    linea: "E999",
+    // chantPunctumLinea: a punctum BETWEEN two vertical lines, gabc R (and, hollow,
+    // r0). Not the linea — gabc's `=` bar-shaped note, which SMuFL does not carry.
+    // gabc-smufl's map labels it "bar note, no notehead"; the outline says otherwise.
+    lineaPunctum: "E999",
+    lineaPunctumCavum: "E99A",
     quilisma: "E99B",
     oriscusAsc: "E99C",
     oriscusDesc: "E99D",
+    oriscusLiquescens: "E99E",
     strophicus: "E99F",
+    strophicusAuctus: "E9A0",
     punctumDeminutum: "E9A1",
     // THE CUSTOS, added to the bake 2026-08-12. Bravura carries it at EA00-EA09
     // and the subset did not, so the emitter drew a plain punctum at a line's
@@ -75,6 +85,9 @@ export const GLYPH = {
     // rhythmic signs
     ictusAbove: "E9D0",
     ictusBelow: "E9D1",
+    circulus: "E9D2",
+    semicirculus: "E9D4",
+    accentus: "E9D6",
     episema: "E9D8",
     mora: "E9D9",
     // accidentals (medieval soft-b flat / natural; standard sharp fallback).
@@ -85,7 +98,7 @@ export const GLYPH = {
     natural: "E9E1",
     sharp: "E262",
 };
-/** Written note shape → notehead glyph codepoint. */
+/** Written note shape → notehead glyph codepoint, before liquescence and the hollow. */
 export const SHAPE_GLYPH = Object.freeze({
     punctum: GLYPH.punctum,
     inclinatum: GLYPH.punctumInclinatum,
@@ -94,9 +107,53 @@ export const SHAPE_GLYPH = Object.freeze({
     quilisma: GLYPH.quilisma,
     oriscus: GLYPH.oriscusAsc,
     strophicus: GLYPH.strophicus,
-    cavum: GLYPH.cavum,
-    linea: GLYPH.linea,
+    lineaPunctum: GLYPH.lineaPunctum,
 });
+/**
+ * The notehead for a note, or null when Bravura draws no head for that
+ * combination (a liquescent virga or quilisma) and the caller keeps its
+ * fallback. Gregorio's rules: an oriscus takes only the deminutive
+ * liquescence; a strophicus either augmentation as its auctus. A hollow
+ * inclinatum returns the full diamond: Bravura has no cavum of it, so the
+ * emitter traces that outline instead (see `tracedHollow`).
+ */
+export function headGlyph(n) {
+    const liq = n.liquescence;
+    switch (n.shape) {
+        case "punctum":
+            if (liq === "deminutive")
+                return GLYPH.punctumDeminutum;
+            if (liq === "ascending")
+                return GLYPH.auctumAsc;
+            if (liq === "descending")
+                return GLYPH.auctumDesc;
+            return n.hollow ? GLYPH.cavum : GLYPH.punctum;
+        case "inclinatum":
+            if (liq === "deminutive")
+                return GLYPH.punctumInclinatumDeminutum;
+            if (liq)
+                return GLYPH.punctumInclinatumAuctum;
+            return GLYPH.punctumInclinatum;
+        case "oriscus":
+            if (liq === "deminutive")
+                return GLYPH.oriscusLiquescens;
+            return n.oriscusDirection === "descending" ? GLYPH.oriscusDesc : GLYPH.oriscusAsc;
+        case "strophicus":
+            return liq ? GLYPH.strophicusAuctus : GLYPH.strophicus;
+        case "lineaPunctum":
+            return n.hollow ? GLYPH.lineaPunctumCavum : GLYPH.lineaPunctum;
+        default:
+            return liq ? null : SHAPE_GLYPH[n.shape] ?? null;
+    }
+}
+/**
+ * A hollow head Bravura does not carry, drawn as its full glyph's outline:
+ * the inclinatum (gabc Gr, G<r). The score app hollows its diamond the same
+ * way, so the two agree.
+ */
+export function tracedHollow(n) {
+    return n.hollow && n.shape === "inclinatum";
+}
 /** Divisio mark → glyph codepoint. */
 export const DIVISIO_GLYPH = Object.freeze({
     ",": GLYPH.divisioMinima,

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/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.12.0",
+  "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>",